523 lines
13 KiB
JavaScript
523 lines
13 KiB
JavaScript
import axios from 'axios';
|
|
import Vue from 'vue';
|
|
import _script from './script';
|
|
|
|
export default {
|
|
data() {
|
|
return {
|
|
loading: false,
|
|
};
|
|
},
|
|
|
|
methods: {
|
|
getExtensionId() {
|
|
return browser.i18n.getMessage('@@extension_id');
|
|
},
|
|
|
|
async notify(message, title = 'platypush', error = false) {
|
|
let msg = '';
|
|
if (title && title.length) {
|
|
msg = `${title}`;
|
|
}
|
|
|
|
if (message && message.length) {
|
|
if (msg.length > 0) {
|
|
msg += ': ';
|
|
}
|
|
msg += message;
|
|
}
|
|
|
|
if (msg.length) {
|
|
if (error) {
|
|
console.error(msg);
|
|
} else {
|
|
console.log(msg);
|
|
}
|
|
}
|
|
|
|
await browser.notifications.create({
|
|
type: 'basic',
|
|
title: title,
|
|
message: message,
|
|
});
|
|
},
|
|
|
|
async getCurrentTab() {
|
|
let tabs = [];
|
|
|
|
try {
|
|
tabs = await browser.tabs.query({
|
|
currentWindow: true,
|
|
active: true,
|
|
});
|
|
} catch (e) {
|
|
console.warn('Could not get active tab', e);
|
|
return;
|
|
}
|
|
|
|
if (!tabs.length) {
|
|
await this.notify('No active tab', '', true);
|
|
return;
|
|
}
|
|
|
|
return tabs[0];
|
|
},
|
|
|
|
async getURL() {
|
|
const tab = await this.getCurrentTab();
|
|
try {
|
|
return await browser.tabs.sendMessage(tab.id, { type: 'getURL' });
|
|
} catch (e) {
|
|
console.warn('Could not get URL', e);
|
|
}
|
|
},
|
|
|
|
async getDOM() {
|
|
try {
|
|
const tab = await this.getCurrentTab();
|
|
return await browser.tabs.sendMessage(tab.id, { type: 'getDOM' });
|
|
} catch (e) {
|
|
console.warn('Could not get DOM', e);
|
|
}
|
|
},
|
|
|
|
async setDOM(html) {
|
|
const tab = await this.getCurrentTab();
|
|
try {
|
|
await browser.tabs.sendMessage(tab.id, { type: 'setDOM', html: html });
|
|
} catch (e) {
|
|
console.warn('Could not set DOM', e);
|
|
}
|
|
},
|
|
|
|
async getTargetElement() {
|
|
const tab = await this.getCurrentTab();
|
|
let target = null;
|
|
try {
|
|
target = await browser.tabs.sendMessage(tab.id, { type: 'getTargetElement' });
|
|
} catch (e) {
|
|
console.warn('Could not get current element', e);
|
|
return;
|
|
}
|
|
|
|
if (!target) {
|
|
return;
|
|
}
|
|
|
|
return new DOMParser().parseFromString(target, 'text/html').documentElement.getElementsByTagName('body')[0].firstChild;
|
|
},
|
|
|
|
async run(action, host, url) {
|
|
const execURL = (host.ssl ? 'https' : 'http') + '://' + host.address + ':' + host.port + '/execute';
|
|
const config = {};
|
|
let args = action.args || {};
|
|
let currentURL = url;
|
|
|
|
if (!url) {
|
|
try {
|
|
currentURL = await this.getURL();
|
|
} catch (e) {}
|
|
}
|
|
|
|
if (Array.isArray(action.args)) {
|
|
args = action.args
|
|
.filter(arg => arg.value != null && (typeof arg.value !== 'string' || arg.value.length))
|
|
.reduce((obj, arg) => {
|
|
obj[arg.name] = arg.value;
|
|
return obj;
|
|
}, {});
|
|
} else {
|
|
args = Object.entries(args)
|
|
.filter(([, value]) => value != null && (typeof value !== 'string' || value.length))
|
|
.reduce((obj, [name, value]) => {
|
|
obj[name] = value;
|
|
return obj;
|
|
}, {});
|
|
}
|
|
|
|
Object.keys(args).forEach(name => {
|
|
// URL wildcard
|
|
if (args[name] === '$URL$') {
|
|
if (!currentURL) {
|
|
console.warn('Unable to get the current URL');
|
|
} else {
|
|
args[name] = currentURL;
|
|
}
|
|
}
|
|
});
|
|
|
|
if (host.token && host.token.length) {
|
|
config.headers = {
|
|
'X-Token': host.token,
|
|
};
|
|
}
|
|
|
|
try {
|
|
const msg = await axios.post(
|
|
execURL,
|
|
{
|
|
type: 'request',
|
|
action: action.action,
|
|
args: args,
|
|
},
|
|
config
|
|
);
|
|
|
|
const errors = msg.data.response.errors;
|
|
if (errors && errors.length) {
|
|
// noinspection ExceptionCaughtLocallyJS
|
|
throw errors[0];
|
|
}
|
|
|
|
return msg.data.response.output;
|
|
} catch (e) {
|
|
await this.notify(e.toString(), 'Request error');
|
|
throw e;
|
|
}
|
|
},
|
|
|
|
prepareScript(script, host, tab, target, ...args) {
|
|
args = JSON.stringify({
|
|
host: host,
|
|
tabId: tab ? tab.id : null,
|
|
target: typeof target === 'object' ? target.outerHTML : target,
|
|
...args,
|
|
});
|
|
|
|
return `(${script})(${_script.api}, ${args})`;
|
|
},
|
|
|
|
async runScript(script, host, tab, target, ...args) {
|
|
this.loading = true;
|
|
|
|
try {
|
|
if (!tab) {
|
|
tab = await this.getCurrentTab();
|
|
}
|
|
|
|
if (!tab) {
|
|
return;
|
|
}
|
|
|
|
const code = this.prepareScript(script, host, tab, target, ...args);
|
|
return await browser.tabs.executeScript(tab.id, {
|
|
code: code,
|
|
});
|
|
} catch (e) {
|
|
await this.notify(e.message, 'Script error', true);
|
|
throw e;
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async getHosts() {
|
|
this.loading = true;
|
|
|
|
try {
|
|
const response = await browser.storage.local.get('hosts');
|
|
if (!response.hosts) {
|
|
return {};
|
|
}
|
|
|
|
return JSON.parse(response.hosts);
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async saveHosts(hosts) {
|
|
this.loading = true;
|
|
try {
|
|
await browser.storage.local.set({ hosts: JSON.stringify(hosts) });
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async getActions() {
|
|
this.loading = true;
|
|
|
|
try {
|
|
const response = await browser.storage.local.get('actions');
|
|
if (!response.actions) {
|
|
return {};
|
|
}
|
|
|
|
return JSON.parse(response.actions);
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async getScripts() {
|
|
this.loading = true;
|
|
|
|
try {
|
|
const response = await browser.storage.local.get('scripts');
|
|
if (!response.scripts) {
|
|
return {};
|
|
}
|
|
|
|
return Object.entries(JSON.parse(response.scripts)).reduce((obj, [name, info]) => {
|
|
obj[name] = info;
|
|
return obj;
|
|
}, {});
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async saveActions(actions) {
|
|
this.loading = true;
|
|
|
|
try {
|
|
await browser.storage.local.set({ actions: JSON.stringify(actions) });
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async saveAction(action) {
|
|
const actions = await this.getActions();
|
|
if (action.displayName in actions) {
|
|
if (!confirm('An action with this name already exists. Do you want to overwrite it?')) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
actions[action.displayName] = action;
|
|
await this.saveActions(actions);
|
|
await this.notify('You can find this action under the Local Actions menu', 'Action saved');
|
|
},
|
|
|
|
async saveScripts(scripts) {
|
|
this.loading = true;
|
|
|
|
try {
|
|
scripts = Object.entries(scripts).reduce((obj, [name, info]) => {
|
|
if (typeof info.script === 'function') {
|
|
info.script = info.script.toString();
|
|
}
|
|
|
|
obj[name] = info;
|
|
return obj;
|
|
}, {});
|
|
|
|
await browser.storage.local.set({ scripts: JSON.stringify(scripts) });
|
|
} catch (e) {
|
|
await this.notify(e.message, 'Error on script save');
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async saveScript(script) {
|
|
const scripts = await this.getScripts(false);
|
|
if (script.displayName in scripts) {
|
|
if (!confirm('A script with this name already exists. Do you want to overwrite it?')) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
scripts[script.displayName] = script;
|
|
await this.saveScripts(scripts);
|
|
await this.notify('You can find this script under the Local Actions menu', 'Script saved');
|
|
},
|
|
|
|
async getCommands() {
|
|
this.loading = true;
|
|
|
|
try {
|
|
const response = await browser.storage.local.get('commands');
|
|
if (!response.commands) {
|
|
return {};
|
|
}
|
|
|
|
return JSON.parse(response.commands);
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async saveCommands(commands) {
|
|
this.loading = true;
|
|
try {
|
|
await browser.storage.local.set({ commands: JSON.stringify(commands) });
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async saveCommand(command, action) {
|
|
const commands = await this.getCommands();
|
|
if (command in commands) {
|
|
if (action === commands[command]) {
|
|
return;
|
|
}
|
|
|
|
if (!confirm(`The action ${commands[command]} is already linked to this key binding. Do you want to overwrite it?`)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
Object.entries(commands).forEach(([cmd, act]) => {
|
|
if (act === action) {
|
|
delete commands[cmd];
|
|
}
|
|
});
|
|
|
|
commands[command] = action;
|
|
await this.saveCommands(commands);
|
|
},
|
|
|
|
async removeCommand(command, action) {
|
|
const commands = await this.getCommands();
|
|
if (!(command in commands) || !confirm('Are you sure that you want to remove this key binding?')) {
|
|
return;
|
|
}
|
|
|
|
delete commands[command];
|
|
await this.saveCommands(commands);
|
|
},
|
|
|
|
async loadConfig() {
|
|
this.loading = true;
|
|
|
|
try {
|
|
const [hosts, actions, scripts, commands] = await Promise.all([this.getHosts(), this.getActions(), this.getScripts(false), this.getCommands()]);
|
|
return {
|
|
hosts: hosts,
|
|
actions: actions,
|
|
scripts: scripts,
|
|
commands: commands,
|
|
};
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async saveConfig(config) {
|
|
this.loading = true;
|
|
const hosts = config.hosts || {};
|
|
const actions = config.actions || {};
|
|
const scripts = config.scripts || {};
|
|
const commands = config.commands || {};
|
|
|
|
try {
|
|
await Promise.all([this.saveHosts(hosts), this.saveActions(actions), this.saveScripts(scripts), this.saveCommands(commands)]);
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async backupConfig(host) {
|
|
if (typeof host === 'string') {
|
|
const hosts = await this.getHosts();
|
|
if (!(host in hosts)) {
|
|
await this.notify(host, 'No such Platypush host');
|
|
return;
|
|
}
|
|
|
|
host = hosts[host];
|
|
}
|
|
|
|
this.loading = true;
|
|
const config = JSON.stringify(await this.loadConfig());
|
|
const basedir = `\${Config.get("workdir")}/webext`;
|
|
const filename = `${basedir}/config.json`;
|
|
|
|
try {
|
|
await this.run(
|
|
{
|
|
action: 'file.mkdir',
|
|
args: { directory: basedir },
|
|
},
|
|
host
|
|
);
|
|
|
|
await this.run(
|
|
{
|
|
action: 'file.write',
|
|
args: {
|
|
file: filename,
|
|
content: config,
|
|
},
|
|
},
|
|
host
|
|
);
|
|
|
|
await this.notify(`Configuration successfully backed up to ${host.name}`, 'Backup successful');
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
async getConfig(host) {
|
|
if (typeof host === 'string') {
|
|
const hosts = await this.getHosts();
|
|
if (!(host in hosts)) {
|
|
await this.notify(host, 'No such Platypush host');
|
|
return;
|
|
}
|
|
|
|
host = hosts[host];
|
|
}
|
|
|
|
this.loading = true;
|
|
const basedir = `\${Config.get("workdir")}/webext`;
|
|
const filename = `${basedir}/config.json`;
|
|
|
|
try {
|
|
return await this.run(
|
|
{
|
|
action: 'file.read',
|
|
args: { file: filename },
|
|
},
|
|
host
|
|
);
|
|
} finally {
|
|
this.loading = false;
|
|
}
|
|
},
|
|
|
|
formToHost(form) {
|
|
return {
|
|
name: form.name.value,
|
|
address: form.address.value,
|
|
port: parseInt(form.port.value),
|
|
websocketPort: parseInt(form.websocketPort.value),
|
|
ssl: form.ssl.checked,
|
|
token: form.token.value,
|
|
};
|
|
},
|
|
|
|
onAddrChange(form) {
|
|
if (form.name.value.length && !form.address.value.startsWith(form.name.value)) {
|
|
return;
|
|
}
|
|
|
|
form.name.value = form.address.value;
|
|
},
|
|
|
|
onPortChange(form) {
|
|
const port = form.port.value;
|
|
if (!this.isPortValid(port)) return;
|
|
form.websocketPort.value = '' + (parseInt(port) + 1);
|
|
},
|
|
|
|
isPortValid(port) {
|
|
port = parseInt(port);
|
|
return !isNaN(port) && port > 0 && port < 65536;
|
|
},
|
|
|
|
isHostFormValid(form) {
|
|
return form.name.value.length && form.address.value.length && this.isPortValid(form.port.value) && this.isPortValid(form.websocketPort.value);
|
|
},
|
|
},
|
|
};
|
|
|
|
export const bus = new Vue();
|
|
|
|
// vim:sw=2:ts=2:et:
|