mirror of https://github.com/keeweb/keeweb.git
313 lines
11 KiB
JavaScript
313 lines
11 KiB
JavaScript
import { Events } from 'framework/events';
|
|
import { AutoTypeHelper } from 'auto-type/auto-type-helper';
|
|
import { AutoTypeParser } from 'auto-type/auto-type-parser';
|
|
import { SelectEntryFilter } from 'comp/app/select-entry-filter';
|
|
import { Launcher } from 'comp/launcher';
|
|
import { Features } from 'util/features';
|
|
import { Alerts } from 'comp/ui/alerts';
|
|
import { Timeouts } from 'const/timeouts';
|
|
import { AppSettingsModel } from 'models/app-settings-model';
|
|
import { AppModel } from 'models/app-model';
|
|
import { Locale } from 'util/locale';
|
|
import { Logger } from 'util/logger';
|
|
import { Links } from 'const/links';
|
|
import { SelectEntryView } from 'views/select/select-entry-view';
|
|
|
|
const logger = new Logger('auto-type');
|
|
const clearTextAutoTypeLog = !!localStorage.debugAutoType;
|
|
|
|
const AutoType = {
|
|
enabled: !!(Launcher && Launcher.autoTypeSupported),
|
|
supportsEventsWithWindowId: !!(Launcher && Launcher.platform() === 'linux'),
|
|
selectEntryView: false,
|
|
running: false,
|
|
|
|
init() {
|
|
if (!this.enabled) {
|
|
return;
|
|
}
|
|
Events.on('auto-type', (e) => this.handleEvent(e));
|
|
},
|
|
|
|
handleEvent(e) {
|
|
const entry = (e && e.entry) || null;
|
|
const sequence = (e && e.sequence) || null;
|
|
const context = (e && e.context) || null;
|
|
logger.debug('Auto type event', entry);
|
|
if (this.running) {
|
|
logger.debug('Already running, skipping event');
|
|
return;
|
|
}
|
|
if (entry) {
|
|
this.hideWindow(() => {
|
|
this.runAndHandleResult({ entry, sequence, context });
|
|
});
|
|
} else {
|
|
if (this.selectEntryView) {
|
|
return;
|
|
}
|
|
if (Launcher.isAppFocused()) {
|
|
return Alerts.error({
|
|
header: Locale.autoTypeError,
|
|
body: Locale.autoTypeErrorGlobal,
|
|
skipIfAlertDisplayed: true
|
|
});
|
|
}
|
|
this.selectEntryAndRun();
|
|
}
|
|
},
|
|
|
|
runAndHandleResult(result, windowId) {
|
|
this.run(result, windowId, (err) => {
|
|
if (err) {
|
|
let body = Locale.autoTypeErrorGeneric.replace('{}', err.message || err.toString());
|
|
let link;
|
|
if (err.keyPressFailed && Features.isMac) {
|
|
body = Locale.autoTypeErrorAccessibilityMacOS;
|
|
link = Links.AutoTypeMacOS;
|
|
}
|
|
Alerts.error({
|
|
header: Locale.autoTypeError,
|
|
body,
|
|
link
|
|
});
|
|
}
|
|
});
|
|
|
|
if (AppSettingsModel.lockOnAutoType) {
|
|
Events.emit('lock-workspace');
|
|
}
|
|
},
|
|
|
|
run(result, windowId, callback) {
|
|
this.running = true;
|
|
const sequence = result.sequence || result.entry.getEffectiveAutoTypeSeq();
|
|
const context = result.context;
|
|
logger.debug('Start', sequence);
|
|
const ts = logger.ts();
|
|
try {
|
|
const parser = new AutoTypeParser(sequence);
|
|
const runner = parser.parse();
|
|
logger.debug('Parsed', this.printOps(runner.ops));
|
|
runner.resolve(result.entry, context, (err) => {
|
|
if (err) {
|
|
this.running = false;
|
|
logger.error('Resolve error', err);
|
|
return callback && callback(err);
|
|
}
|
|
logger.debug('Resolved', this.printOps(runner.ops));
|
|
if (result.entry.autoTypeObfuscation) {
|
|
try {
|
|
runner.obfuscate();
|
|
} catch (e) {
|
|
this.running = false;
|
|
logger.error('Obfuscate error', e);
|
|
return callback && callback(e);
|
|
}
|
|
logger.debug('Obfuscated');
|
|
}
|
|
runner.run((err) => {
|
|
this.running = false;
|
|
if (err) {
|
|
logger.error('Run error', err);
|
|
return callback && callback(err);
|
|
}
|
|
logger.debug('Complete', logger.ts(ts));
|
|
return callback && callback();
|
|
}, windowId);
|
|
});
|
|
} catch (ex) {
|
|
this.running = false;
|
|
logger.error('Parse error', ex);
|
|
return callback && callback(ex);
|
|
}
|
|
},
|
|
|
|
validate(entry, sequence, callback) {
|
|
try {
|
|
const parser = new AutoTypeParser(sequence);
|
|
const runner = parser.parse();
|
|
runner.resolve(entry, null, callback);
|
|
} catch (ex) {
|
|
return callback(ex);
|
|
}
|
|
},
|
|
|
|
printOps(ops) {
|
|
return '[' + ops.map(this.printOp, this).join(',') + ']';
|
|
},
|
|
|
|
printOp(op) {
|
|
const mod = op.mod ? Object.keys(op.mod).join('') : '';
|
|
if (op.type === 'group') {
|
|
return mod + this.printOps(op.value);
|
|
}
|
|
if (op.type === 'text') {
|
|
let value = op.value;
|
|
if (!clearTextAutoTypeLog) {
|
|
value = value.replace(/./g, '*');
|
|
}
|
|
return mod + value;
|
|
}
|
|
return mod + op.type + ':' + op.value;
|
|
},
|
|
|
|
hideWindow(callback) {
|
|
logger.debug('Hide window');
|
|
if (Launcher.isAppFocused()) {
|
|
Launcher.hideApp();
|
|
setTimeout(callback, Timeouts.AutoTypeAfterHide);
|
|
} else {
|
|
callback();
|
|
}
|
|
},
|
|
|
|
getActiveWindowInfo(callback) {
|
|
logger.debug('Getting window info');
|
|
const helper = new AutoTypeHelper();
|
|
return helper.getActiveWindowInfo((err, windowInfo) => {
|
|
if (err) {
|
|
logger.error('Error getting window info', err);
|
|
} else {
|
|
if (!windowInfo.url) {
|
|
// try to find a URL in the title
|
|
const urlMatcher = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\\+~#=]{2,256}\.[a-z]{2,4}\b([-a-zA-Z0-9@:%_\\+.~#?&\/=]*)/;
|
|
const urlMatches = urlMatcher.exec(windowInfo.title);
|
|
windowInfo.url = urlMatches && urlMatches.length > 0 ? urlMatches[0] : null;
|
|
}
|
|
logger.debug('Window info', windowInfo.id, windowInfo.title, windowInfo.url);
|
|
}
|
|
return callback(err, windowInfo);
|
|
});
|
|
},
|
|
|
|
activeWindowMatches(windowInfo, callback) {
|
|
if (!windowInfo || !windowInfo.id) {
|
|
logger.debug('Skipped active window check because window id is unknown');
|
|
return callback(true);
|
|
}
|
|
this.getActiveWindowInfo((err, activeWindowInfo) => {
|
|
if (!activeWindowInfo) {
|
|
logger.debug('Error during active window check, something is wrong', err);
|
|
return callback(false);
|
|
}
|
|
if (activeWindowInfo.id !== windowInfo.id && !this.supportsEventsWithWindowId) {
|
|
logger.info(
|
|
`Active window doesn't match: ID is different. ` +
|
|
`Expected ${windowInfo.id}, got ${activeWindowInfo.id}`
|
|
);
|
|
return callback(false, activeWindowInfo);
|
|
}
|
|
if (activeWindowInfo.url !== windowInfo.url && !this.supportsEventsWithWindowId) {
|
|
logger.info(
|
|
`Active window doesn't match: url is different. ` +
|
|
`Expected "${windowInfo.url}", got "${activeWindowInfo.url}"`
|
|
);
|
|
return callback(false, activeWindowInfo);
|
|
}
|
|
logger.info('Active window matches');
|
|
callback(true, activeWindowInfo);
|
|
});
|
|
},
|
|
|
|
selectEntryAndRun() {
|
|
this.getActiveWindowInfo(async (e, windowInfo) => {
|
|
const filter = new SelectEntryFilter(
|
|
windowInfo,
|
|
AppModel.instance,
|
|
AppModel.instance.files,
|
|
{
|
|
autoType: true
|
|
}
|
|
);
|
|
const evt = { filter, windowInfo };
|
|
if (!AppModel.instance.files.hasOpenFiles()) {
|
|
logger.debug('auto-type event delayed');
|
|
this.focusMainWindow();
|
|
try {
|
|
await AppModel.instance.unlockAnyFile('autoTypeUnlockMessage');
|
|
} catch {
|
|
logger.debug('auto-type event canceled');
|
|
return;
|
|
}
|
|
if (this.selectEntryView) {
|
|
this.selectEntryView.show();
|
|
}
|
|
}
|
|
logger.debug('processing auto-type event');
|
|
this.processEventWithFilter(evt);
|
|
});
|
|
},
|
|
|
|
focusMainWindow() {
|
|
if (!Launcher.isAppFocused()) {
|
|
setTimeout(() => Launcher.showMainWindow(), Timeouts.RedrawInactiveWindow);
|
|
}
|
|
},
|
|
|
|
processEventWithFilter(evt) {
|
|
let entries = evt.filter.getEntries();
|
|
if (entries.length === 1 && AppSettingsModel.directAutotype) {
|
|
this.hideWindow(() => {
|
|
this.runAndHandleResult({ entry: entries[0] }, evt.windowInfo.id);
|
|
});
|
|
return;
|
|
}
|
|
this.focusMainWindow();
|
|
|
|
if (entries.length === 0) {
|
|
if (evt.filter.useUrl) {
|
|
evt.filter.useUrl = false;
|
|
if (evt.filter.title && AppSettingsModel.autoTypeTitleFilterEnabled) {
|
|
evt.filter.useTitle = true;
|
|
}
|
|
}
|
|
entries = evt.filter.getEntries();
|
|
if (entries.length === 0 && evt.filter.useTitle) {
|
|
evt.filter.useTitle = false;
|
|
}
|
|
}
|
|
|
|
const humanReadableTarget = evt.filter.title || evt.filter.url;
|
|
const topMessage = humanReadableTarget
|
|
? Locale.autoTypeMsgMatchedByWindow.replace('{}', humanReadableTarget)
|
|
: Locale.autoTypeMsgNoWindow;
|
|
|
|
this.selectEntryView = new SelectEntryView({
|
|
isAutoType: true,
|
|
itemOptions: true,
|
|
filter: evt.filter,
|
|
topMessage
|
|
});
|
|
this.selectEntryView.on('result', (result) => {
|
|
logger.debug('Entry selected', result);
|
|
this.selectEntryView.off('result');
|
|
this.selectEntryView.remove();
|
|
this.selectEntryView = null;
|
|
this.hideWindow(() => {
|
|
if (result?.entry) {
|
|
this.activeWindowMatches(evt.windowInfo, (matches, activeWindowInfo) => {
|
|
if (matches) {
|
|
this.runAndHandleResult(result, evt.windowInfo.id);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
this.selectEntryView.render();
|
|
this.selectEntryView.on('show-open-files', async () => {
|
|
this.selectEntryView.hide();
|
|
try {
|
|
await AppModel.instance.unlockAnyFile('autoTypeUnlockMessage');
|
|
} catch {
|
|
this.selectEntryView.emit('result', undefined);
|
|
return;
|
|
}
|
|
this.selectEntryView.show();
|
|
this.selectEntryView.render();
|
|
});
|
|
}
|
|
};
|
|
|
|
export { AutoType };
|