Merge branch 'develop' into master

2021-03-07 14:23:29 +01:00 · 2021-03-07 14:23:29 +01:00 · 31214b10e7
parent 69f7b02ce6 5bbc324b2e
commit 31214b10e7
155 changed files with 27531 additions and 5012 deletions
--- a/.github/actions/linux-build/entrypoint.sh
+++ b/.github/actions/linux-build/entrypoint.sh
@ -2,7 +2,4 @@

 cd /github/workspace
 npm ci
-cd desktop
-npm ci
-cd /github/workspace
 grunt desktop-linux
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@ -24,6 +24,11 @@ jobs:
        run: npm test
      - name: Grunt
        run: grunt
+      - name: Upload artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.html
+          path: dist
      - name: Write secrets
        env:
          VIRUS_TOTAL: ${{ secrets.VIRUS_TOTAL }}
@ -33,11 +38,6 @@ jobs:
      - name: Check on VirusTotal
        run: grunt virustotal
        if: ${{ github.repository == 'keeweb/keeweb' }}
-      - name: Upload artifact
-        uses: actions/upload-artifact@v1
-        with:
-          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.html
-          path: dist

  linux:
    runs-on: ubuntu-latest
@ -95,11 +95,6 @@ jobs:
        with:
          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x86_64.rpm
          path: dist/desktop/KeeWeb-${{ steps.get_tag.outputs.tag }}.linux.x86_64.rpm
-      - name: Upload update artifact
-        uses: actions/upload-artifact@v1
-        with:
-          name: UpdateDesktop.zip
-          path: dist/desktop/UpdateDesktop.zip

  darwin:
    runs-on: macos-latest
@ -124,9 +119,6 @@ jobs:
          path: dist
      - name: Install npm modules
        run: npm ci
-      - name: Install desktop npm modules
-        working-directory: desktop
-        run: npm ci
      - name: Install grunt
        run: sudo npm i -g grunt-cli
      - name: Write secrets
@ -134,10 +126,12 @@ jobs:
          CODESIGN: ${{ secrets.CODESIGN }}
          APPLE_DEPLOY_PASSWORD: ${{ secrets.APPLE_DEPLOY_PASSWORD }}
          APPLE_ID_USERNAME: ${{ secrets.APPLE_ID_USERNAME }}
+          APPLE_PROVISIONING_PROFILE: ${{ secrets.APPLE_PROVISIONING_PROFILE }}
        run: |
          mkdir keys
          echo "$CODESIGN" > keys/codesign.json
          xcrun altool --store-password-in-keychain-item "AC_PASSWORD" -u "$APPLE_ID_USERNAME" -p "$APPLE_DEPLOY_PASSWORD"
+          echo "$APPLE_PROVISIONING_PROFILE" | base64 -d > keys/keeweb.provisionprofile
      - name: Import certificates
        uses: keeweb/import-codesign-certs@v1
        with:
@ -179,9 +173,6 @@ jobs:
          path: dist
      - name: Install npm modules
        run: npm ci
-      - name: Install desktop npm modules
-        working-directory: desktop
-        run: npm ci
      - name: Install grunt
        run: npm i -g grunt-cli
      - name: Write secrets
@ -328,11 +319,6 @@ jobs:
        with:
          name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.arm64.zip
          path: assets
-      - name: Download update artifact
-        uses: actions/download-artifact@v1
-        with:
-          name: UpdateDesktop.zip
-          path: assets
      - name: Zip html
        working-directory: html
        run: zip -vr ../assets/KeeWeb-${{ steps.get_tag.outputs.tag }}.html.zip .
@ -505,15 +491,6 @@ jobs:
          asset_path: assets/KeeWeb-${{ steps.get_tag.outputs.tag }}.win.arm64.zip
          asset_name: KeeWeb-${{ steps.get_tag.outputs.tag }}.win.arm64.zip
          asset_content_type: application/octet-stream
-      - name: Upload update asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: assets/UpdateDesktop.zip
-          asset_name: UpdateDesktop.zip
-          asset_content_type: application/octet-stream
      - name: Upload verify.sign asset
        uses: actions/upload-release-asset@v1
        env:
--- a/Gruntfile.js
+++ b/Gruntfile.js
@ -25,16 +25,24 @@ module.exports = function (grunt) {

    const dt = date.toISOString().replace(/T.*/, '');
    const year = date.getFullYear();
-    const minElectronVersionForUpdate = '11.0.3';
-    const zipCommentPlaceholderPart = 'zip_comment_placeholder_that_will_be_replaced_with_hash';
-    const zipCommentPlaceholder =
-        zipCommentPlaceholderPart + '.'.repeat(512 - zipCommentPlaceholderPart.length);
    const electronVersion = pkg.dependencies.electron.replace(/^\D/, '');
    const skipSign = grunt.option('skip-sign');
    const getCodeSignConfig = () =>
        skipSign ? { identities: {} } : require('./keys/codesign.json');

-    const sha = execSync('git rev-parse --short HEAD').toString('utf8').trim();
+    let sha = grunt.option('commit-sha');
+    if (!sha) {
+        try {
+            sha = execSync('git rev-parse --short HEAD').toString('utf8').trim();
+        } catch (e) {
+            grunt.warn(
+                "Cannot get commit sha from git. It's recommended to build KeeWeb from a git repo " +
+                    'because commit sha is displayed in the UI, however if you would like to build from a folder, ' +
+                    'you can override what will be displayed in the UI with --commit-sha=xxx.'
+            );
+        }
+    }
+    grunt.log.writeln(`Building KeeWeb v${pkg.version} (${sha})`);

    const webpackOptions = {
        date,
@ -68,6 +76,15 @@ module.exports = function (grunt) {
        ]
    });

+    const linuxDependencies = [
+        'libappindicator1',
+        'libgconf-2-4',
+        'gnome-keyring',
+        'libxtst6',
+        'libx11-6',
+        'libatspi2.0-0'
+    ];
+
    grunt.initConfig({
        noop: { noop: {} },
        clean: {
@ -127,18 +144,6 @@ module.exports = function (grunt) {
                expand: true,
                nonull: true
            },
-            'desktop-update': {
-                cwd: 'tmp/desktop/keeweb-linux-x64/resources/',
-                src: 'app.asar',
-                dest: 'tmp/desktop/update/',
-                expand: true,
-                nonull: true
-            },
-            'desktop-update-helper': {
-                src: ['helper/darwin/KeeWebHelper', 'helper/win32/KeeWebHelper.exe'],
-                dest: 'tmp/desktop/update/',
-                nonull: true
-            },
            'desktop-darwin-helper-x64': {
                src: 'helper/darwin/KeeWebHelper',
                dest: 'tmp/desktop/KeeWeb-darwin-x64/KeeWeb.app/Contents/Resources/',
@ -152,7 +157,7 @@ module.exports = function (grunt) {
                options: { mode: '0755' }
            },
            'desktop-darwin-installer-helper-x64': {
-                cwd: 'package/osx/KeeWeb Installer.app',
+                cwd: 'tmp/desktop/KeeWeb Installer.app',
                src: '**',
                dest:
                    'tmp/desktop/KeeWeb-darwin-x64/KeeWeb.app/Contents/Installer/KeeWeb Installer.app',
@ -161,7 +166,7 @@ module.exports = function (grunt) {
                options: { mode: true }
            },
            'desktop-darwin-installer-helper-arm64': {
-                cwd: 'package/osx/KeeWeb Installer.app',
+                cwd: 'tmp/desktop/KeeWeb Installer.app',
                src: '**',
                dest:
                    'tmp/desktop/KeeWeb-darwin-arm64/KeeWeb.app/Contents/Installer/KeeWeb Installer.app',
@ -243,6 +248,11 @@ module.exports = function (grunt) {
                src: `tmp/desktop/electron-builder/keeweb-${pkg.version}.AppImage`,
                dest: `dist/desktop/KeeWeb-${pkg.version}.linux.AppImage`,
                nonull: true
+            },
+            'darwin-installer-icon': {
+                src: 'graphics/icon.icns',
+                dest: 'tmp/desktop/KeeWeb Installer.app/Contents/Resources/applet.icns',
+                nonull: true
            }
        },
        eslint: {
@ -250,7 +260,8 @@ module.exports = function (grunt) {
            desktop: ['desktop/**/*.js', '!desktop/node_modules/**'],
            build: ['Gruntfile.js', 'grunt.*.js', 'build/**/*.js', 'webpack.config.js'],
            plugins: ['plugins/**/*.js'],
-            util: ['util/**/*.js']
+            util: ['util/**/*.js'],
+            installer: ['package/osx/installer.js']
        },
        inline: {
            app: {
@ -263,7 +274,7 @@ module.exports = function (grunt) {
                algo: 'sha512',
                expected: {
                    style: 1,
-                    script: 2
+                    script: 1
                }
            },
            app: {
@ -283,20 +294,20 @@ module.exports = function (grunt) {
            }
        },
        'string-replace': {
-            manifest: {
+            'update-manifest': {
                options: {
                    replacements: [
                        {
-                            pattern: '# YYYY-MM-DD:v0.0.0',
-                            replacement: '# ' + dt + ':v' + pkg.version
+                            pattern: /"version":\s*".*?"/,
+                            replacement: `"version": "${pkg.version}"`
                        },
                        {
-                            pattern: '# updmin:v0.0.0',
-                            replacement: '# updmin:v' + minElectronVersionForUpdate
+                            pattern: /"date":\s*".*?"/,
+                            replacement: `"date": "${dt}"`
                        }
                    ]
                },
-                files: { 'dist/manifest.appcache': 'app/manifest.appcache' }
+                files: { 'dist/update.json': 'app/update.json' }
            },
            'service-worker': {
                options: { replacements: [{ pattern: '0.0.0', replacement: pkg.version }] },
@ -437,26 +448,37 @@ module.exports = function (grunt) {
                            category: 'Utility'
                        },
                        rpm: {
-                            // depends: ['libappindicator1', 'libgconf-2-4', 'gnome-keyring']
+                            // depends: linuxDependencies
                        },
                        snap: {
-                            stagePackages: ['libappindicator1', 'libgconf-2-4', 'gnome-keyring']
+                            stagePackages: linuxDependencies
                        }
                    }
                }
            }
        },
+        'electron-patch': {
+            'win32-x64': 'tmp/desktop/KeeWeb-win32-x64/KeeWeb.exe',
+            'win32-ia32': 'tmp/desktop/KeeWeb-win32-ia32/KeeWeb.exe',
+            'win32-arm64': 'tmp/desktop/KeeWeb-win32-arm64/KeeWeb.exe',
+            'darwin-x64': 'tmp/desktop/KeeWeb-darwin-x64/KeeWeb.app',
+            'darwin-arm64': 'tmp/desktop/KeeWeb-darwin-arm64/KeeWeb.app',
+            'linux': 'tmp/desktop/KeeWeb-linux-x64/keeweb'
+        },
+        osacompile: {
+            options: {
+                language: 'JavaScript'
+            },
+            installer: {
+                files: {
+                    'tmp/desktop/KeeWeb Installer.app': 'package/osx/installer.js'
+                }
+            }
+        },
        compress: {
            options: {
                level: 6
            },
-            'desktop-update': {
-                options: {
-                    archive: 'dist/desktop/UpdateDesktop.zip',
-                    comment: zipCommentPlaceholder
-                },
-                files: [{ cwd: 'tmp/desktop/update', src: '**', expand: true, nonull: true }]
-            },
            'win32-x64': {
                options: { archive: `dist/desktop/KeeWeb-${pkg.version}.win.x64.zip` },
                files: [{ cwd: 'tmp/desktop/KeeWeb-win32-x64', src: '**', expand: true }]
@ -565,7 +587,7 @@ module.exports = function (grunt) {
                        pkgName: `KeeWeb-${pkg.version}.linux.x64.deb`,
                        targetDir: 'dist/desktop',
                        appName: 'KeeWeb',
-                        depends: 'libappindicator1, libgconf-2-4, gnome-keyring',
+                        depends: linuxDependencies.join(', '),
                        scripts: {
                            postinst: 'package/deb/scripts/postinst'
                        }
@ -588,50 +610,30 @@ module.exports = function (grunt) {
                ]
            }
        },
-        'sign-archive': {
-            'desktop-update': {
-                options: {
-                    file: 'dist/desktop/UpdateDesktop.zip',
-                    signature: zipCommentPlaceholder
-                }
-            }
-        },
-        'sign-desktop-files': {
-            'desktop-update': {
-                options: {
-                    path: 'tmp/desktop/update'
-                }
-            }
-        },
-        'validate-desktop-update': {
-            desktop: {
-                options: {
-                    file: 'dist/desktop/UpdateDesktop.zip',
-                    expected: [
-                        'app.asar',
-                        'helper/darwin/KeeWebHelper',
-                        'helper/win32/KeeWebHelper.exe'
-                    ],
-                    expectedCount: 7,
-                    publicKey: 'app/resources/public-key.pem'
-                }
-            }
-        },
        'osx-sign': {
            options: {
                get identity() {
                    return getCodeSignConfig().identities.app;
                },
                hardenedRuntime: true,
-                entitlements: 'package/osx/entitlements.mac.plist',
-                'entitlements-inherit': 'package/osx/entitlements.mac.plist',
+                entitlements: 'package/osx/entitlements.plist',
+                'entitlements-inherit': 'package/osx/entitlements-inherit.plist',
                'gatekeeper-assess': false
            },
            'desktop-x64': {
+                options: {
+                    'provisioning-profile': './keys/keeweb.provisionprofile'
+                },
                src: 'tmp/desktop/KeeWeb-darwin-x64/KeeWeb.app'
            },
            'desktop-arm64': {
+                options: {
+                    'provisioning-profile': './keys/keeweb.provisionprofile'
+                },
                src: 'tmp/desktop/KeeWeb-darwin-arm64/KeeWeb.app'
+            },
+            'installer': {
+                src: 'tmp/desktop/KeeWeb Installer.app'
            }
        },
        notarize: {
@ -747,10 +749,7 @@ module.exports = function (grunt) {
                    sign: 'dist/desktop/Verify.sign.sha256'
                },
                files: {
-                    'dist/desktop/Verify.sha256': [
-                        'dist/desktop/KeeWeb-*',
-                        'dist/desktop/UpdateDesktop.zip'
-                    ]
+                    'dist/desktop/Verify.sha256': ['dist/desktop/KeeWeb-*']
                }
            }
        },
--- a/2
+++ b/2
@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2020 Antelle https://antelle.net
+Copyright (c) 2021 Antelle https://antelle.net

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.md
+++ b/README.md
@ -90,7 +90,7 @@ Please note: donation does not imply any type of service contract.

 Notable contributions to KeeWeb:

- Florian Reuschel ([@Loilo](https://github.com/Loilo)): [German translation](http://keeweb.oneskyapp.com/collaboration/translate/project/project/173183/language/550)
+- Florian Reuschel ([@Loilo](https://github.com/Loilo)): [German translation](https://keeweb.oneskyapp.com/collaboration/translate/project/project/173183/language/550)
 - Dennis Ploeger ([@dploeger](https://github.com/dploeger)): [auto-type improvements](https://github.com/keeweb/keeweb/pulls?q=is%3Apr+is%3Aclosed+author%3Adploeger)
 - Hackmanit ([hackmanit.de](https://www.hackmanit.de)): [penetration test](https://www.hackmanit.de/en/blog-en/104-pro-bono-penetration-test-keeweb)
 - Peter Bittner ([@bittner](https://github.com/bittner)): [Wikipedia article](https://en.wikipedia.org/wiki/KeeWeb)
--- a/app/index.html
+++ b/app/index.html
@ -72,7 +72,6 @@
        <link rel="manifest" href="manifest.json" />
        <link rel="stylesheet" href="css/app.css?__inline=true" />
        <script src="js/app.js?__inline=true"></script>
-        <script src="js/runtime.js?__inline=true"></script>
    </head>
    <body class="th-d">
        <noscript>
--- a/app/manifest.appcache
+++ b/app/manifest.appcache
@ -1,7 +0,0 @@
-CACHE MANIFEST
-
-# YYYY-MM-DD:v0.0.0
-# updmin:v0.0.0
-
-NETWORK:
-*
--- a/app/scripts/app.js
+++ b/app/scripts/app.js
@ -9,6 +9,7 @@ import { UsbListener } from 'comp/app/usb-listener';
 import { FeatureTester } from 'comp/browser/feature-tester';
 import { FocusDetector } from 'comp/browser/focus-detector';
 import { IdleTracker } from 'comp/browser/idle-tracker';
+import { ThemeWatcher } from 'comp/browser/theme-watcher';
 import { KeyHandler } from 'comp/browser/key-handler';
 import { PopupNotifier } from 'comp/browser/popup-notifier';
 import { Launcher } from 'comp/launcher';
@ -91,6 +92,8 @@ ready(() => {
        KdbxwebInit.init();
        FocusDetector.init();
        AutoType.init();
+        ThemeWatcher.init();
+        SettingsManager.init();
        window.kw = ExportApi;
        return PluginManager.init().then(() => {
            StartProfiler.milestone('initializing modules');
@ -111,13 +114,13 @@ ready(() => {
    function loadRemoteConfig() {
        return Promise.resolve()
            .then(() => {
-                SettingsManager.setBySettings(appModel.settings);
+                SettingsManager.setBySettings();
                const configParam = getConfigParam();
                if (configParam) {
                    return appModel
                        .loadConfig(configParam)
                        .then(() => {
-                            SettingsManager.setBySettings(appModel.settings);
+                            SettingsManager.setBySettings();
                        })
                        .catch((e) => {
                            if (!appModel.settings.cacheConfigSettings) {
--- a/app/scripts/auto-type/auto-type-emitter-factory.js
+++ b/app/scripts/auto-type/auto-type-emitter-factory.js
@ -1,10 +1,15 @@
 import { Launcher } from 'comp/launcher';
+import { AppSettingsModel } from 'models/app-settings-model';
+import { AutoTypeEmitter } from 'auto-type/auto-type-emitter';

 const AutoTypeEmitterFactory = {
    create(callback, windowId) {
        if (Launcher && Launcher.autoTypeSupported) {
-            const { AutoTypeEmitter } = require('./emitter/auto-type-emitter-' +
-                Launcher.platform());
+            if (AppSettingsModel.useLegacyAutoType) {
+                const { AutoTypeEmitter } = require('./emitter/auto-type-emitter-' +
+                    Launcher.platform());
+                return new AutoTypeEmitter(callback, windowId);
+            }
            return new AutoTypeEmitter(callback, windowId);
        }
        return null;
--- a/app/scripts/auto-type/auto-type-emitter.js
+++ b/app/scripts/auto-type/auto-type-emitter.js
@ -0,0 +1,160 @@
+import { Features } from 'util/features';
+import { NativeModules } from 'comp/launcher/native-modules';
+import { Logger } from 'util/logger';
+import { Launcher } from 'comp/launcher';
+import { Timeouts } from 'const/timeouts';
+
+const logger = new Logger('auto-type-emitter');
+
+const KeyMap = {
+    tab: 'Tab',
+    enter: 'Return',
+    space: 'Space',
+    up: 'UpArrow',
+    down: 'DownArrow',
+    left: 'LeftArrow',
+    right: 'RightArrow',
+    home: 'Home',
+    end: 'End',
+    pgup: 'PageUp',
+    pgdn: 'PageDown',
+    ins: 'Insert',
+    del: 'ForwardDelete',
+    bs: 'BackwardDelete',
+    esc: 'Escape',
+    win: 'Meta',
+    rwin: 'RightMeta',
+    f1: 'F1',
+    f2: 'F2',
+    f3: 'F3',
+    f4: 'F4',
+    f5: 'F5',
+    f6: 'F6',
+    f7: 'F7',
+    f8: 'F8',
+    f9: 'F9',
+    f10: 'F10',
+    f11: 'F11',
+    f12: 'F12',
+    f13: 'F13',
+    f14: 'F14',
+    f15: 'F15',
+    f16: 'F16',
+    add: 'KeypadPlus',
+    subtract: 'KeypadMinus',
+    multiply: 'KeypadMultiply',
+    divide: 'KeypadDivide',
+    n0: 'D0',
+    n1: 'D1',
+    n2: 'D2',
+    n3: 'D3',
+    n4: 'D4',
+    n5: 'D5',
+    n6: 'D6',
+    n7: 'D7',
+    n8: 'D8',
+    n9: 'D9'
+};
+
+const ModMap = {
+    '^': Features.isMac ? 'Command' : 'Ctrl',
+    '+': 'Shift',
+    '%': 'Alt',
+    '^^': 'Ctrl'
+};
+
+class AutoTypeEmitter {
+    constructor(callback) {
+        this.callback = callback;
+        this.mod = {};
+    }
+
+    begin() {
+        this.withCallback(NativeModules.kbdEnsureModifierNotPressed());
+    }
+
+    setMod(mod, enabled) {
+        const nativeMod = ModMap[mod];
+        if (!nativeMod) {
+            return this.callback(`Bad modifier: ${mod}`);
+        }
+        NativeModules.kbdKeyMoveWithModifier(!!enabled, [nativeMod]).catch((e) => {
+            logger.error('Error moving modifier', mod, enabled ? 'down' : 'up', e);
+        });
+        if (enabled) {
+            this.mod[nativeMod] = true;
+        } else {
+            delete this.mod[nativeMod];
+        }
+    }
+
+    text(str) {
+        if (!str) {
+            return this.withCallback(Promise.resolve());
+        }
+        const mods = Object.keys(this.mod);
+        if (mods.length) {
+            this.withCallback(NativeModules.kbdTextAsKeys(str, mods));
+        } else {
+            this.withCallback(NativeModules.kbdText(str));
+        }
+    }
+
+    key(key) {
+        const mods = Object.keys(this.mod);
+        if (typeof key === 'number') {
+            this.withCallback(NativeModules.kbdKeyPressWithCharacter(0, key, mods));
+        } else {
+            if (!KeyMap[key]) {
+                return this.callback('Bad key: ' + key);
+            }
+            const code = KeyMap[key];
+            this.withCallback(NativeModules.kbdKeyPress(code, mods));
+        }
+    }
+
+    copyPaste(text) {
+        setTimeout(() => {
+            Launcher.setClipboardText(text);
+            setTimeout(() => {
+                this.withCallback(NativeModules.kbdShortcut('V'));
+            }, Timeouts.AutoTypeCopyPaste);
+        }, Timeouts.AutoTypeCopyPaste);
+    }
+
+    wait(time) {
+        setTimeout(() => this.withCallback(Promise.resolve()), time);
+    }
+
+    waitComplete() {
+        this.withCallback(Promise.resolve());
+    }
+
+    setDelay() {
+        this.callback('Not implemented');
+    }
+
+    withCallback(promise) {
+        promise
+            .then(() => {
+                try {
+                    this.callback();
+                } catch (err) {
+                    logger.error('Callback error', err);
+                }
+            })
+            .catch((err) => {
+                const keyPressFailed = err.message === 'Key press failed';
+                if (keyPressFailed) {
+                    err.keyPressFailed = true;
+                }
+                try {
+                    this.callback(err);
+                } catch (err) {
+                    logger.error('Callback error', err);
+                }
+            });
+    }
+}
+
+export { AutoTypeEmitter };
--- a/app/scripts/auto-type/auto-type-helper-factory.js
+++ b/app/scripts/auto-type/auto-type-helper-factory.js
@ -1,9 +1,15 @@
 import { Launcher } from 'comp/launcher';
+import { AppSettingsModel } from 'models/app-settings-model';
+import { AutoTypeHelper } from 'auto-type/auto-type-helper';

 const AutoTypeHelperFactory = {
    create() {
        if (Launcher && Launcher.autoTypeSupported) {
-            const { AutoTypeHelper } = require('./helper/auto-type-helper-' + Launcher.platform());
+            if (AppSettingsModel.useLegacyAutoType) {
+                const { AutoTypeHelper } = require('./helper/auto-type-helper-' +
+                    Launcher.platform());
+                return new AutoTypeHelper();
+            }
            return new AutoTypeHelper();
        }
        return null;
--- a/app/scripts/auto-type/auto-type-helper.js
+++ b/app/scripts/auto-type/auto-type-helper.js
@ -0,0 +1,16 @@
+import { NativeModules } from 'comp/launcher/native-modules';
+
+class AutoTypeHelper {
+    getActiveWindowInfo(callback) {
+        NativeModules.kbdGetActiveWindow({
+            getWindowTitle: true,
+            getBrowserUrl: true
+        })
+            .then((win) => {
+                callback(undefined, win);
+            })
+            .catch((err) => callback(err));
+    }
+}
+
+export { AutoTypeHelper };
--- a/app/scripts/auto-type/auto-type-runner.js
+++ b/app/scripts/auto-type/auto-type-runner.js
@ -2,11 +2,12 @@ import { AutoTypeEmitterFactory } from 'auto-type/auto-type-emitter-factory';
 import { AutoTypeObfuscator } from 'auto-type/auto-type-obfuscator';
 import { StringFormat } from 'util/formatting/string-format';
 import { Logger } from 'util/logger';
+import { AppSettingsModel } from 'models/app-settings-model';

 const emitterLogger = new Logger(
    'auto-type-emitter',
    undefined,
-    localStorage.debugAutoType ? Logger.Level.All : Logger.Level.Warn
+    localStorage.debugAutoType ? Logger.Level.All : Logger.Level.Info
 );

 const AutoTypeRunner = function (ops) {
@ -239,7 +240,7 @@ AutoTypeRunner.prototype.tryParseCommand = function (op) {
            // {VKEY 10} {VKEY 0x1F}
            op.type = 'key';
            op.value = parseInt(op.arg);
-            if (isNaN(op.value) || op.value <= 0) {
+            if (isNaN(op.value) || op.value < 0) {
                throw 'Bad vkey: ' + op.arg;
            }
            return true;
@ -432,6 +433,8 @@ AutoTypeRunner.prototype.obfuscateOp = function (op) {
 };

 AutoTypeRunner.prototype.run = function (callback, windowId) {
+    const emitterType = AppSettingsModel.useLegacyAutoType ? 'legacy' : 'native';
+    emitterLogger.info(`Using ${emitterType} auto-type emitter`);
    this.emitter = AutoTypeEmitterFactory.create(this.emitNext.bind(this), windowId);
    this.emitterState = {
        callback,
@ -442,7 +445,7 @@ AutoTypeRunner.prototype.run = function (callback, windowId) {
        activeMod: {},
        finished: null
    };
-    this.emitNext();
+    this.emitter.begin();
 };

 AutoTypeRunner.prototype.emitNext = function (err) {
--- a/app/scripts/auto-type/emitter/auto-type-emitter-darwin.js
+++ b/app/scripts/auto-type/emitter/auto-type-emitter-darwin.js
@ -65,6 +65,10 @@ const AutoTypeEmitter = function (callback) {
    this.pendingScript = [];
 };

+AutoTypeEmitter.prototype.begin = function () {
+    this.callback();
+};
+
 AutoTypeEmitter.prototype.setMod = function (mod, enabled) {
    if (enabled) {
        this.mod[ModMap[mod]] = true;
--- a/app/scripts/auto-type/emitter/auto-type-emitter-linux.js
+++ b/app/scripts/auto-type/emitter/auto-type-emitter-linux.js
@ -68,6 +68,10 @@ const AutoTypeEmitter = function (callback, windowId) {
    }
 };

+AutoTypeEmitter.prototype.begin = function () {
+    this.callback();
+};
+
 AutoTypeEmitter.prototype.setMod = function (mod, enabled) {
    if (enabled) {
        this.mod[ModMap[mod]] = true;
--- a/app/scripts/auto-type/emitter/auto-type-emitter-win32.js
+++ b/app/scripts/auto-type/emitter/auto-type-emitter-win32.js
@ -65,6 +65,10 @@ const AutoTypeEmitter = function (callback) {
    this.pendingScript = [];
 };

+AutoTypeEmitter.prototype.begin = function () {
+    this.callback();
+};
+
 AutoTypeEmitter.prototype.setMod = function (mod, enabled) {
    if (enabled) {
        this.mod[ModMap[mod]] = true;
--- a/app/scripts/auto-type/index.js
+++ b/app/scripts/auto-type/index.js
@ -3,19 +3,20 @@ import { AutoTypeFilter } from 'auto-type/auto-type-filter';
 import { AutoTypeHelperFactory } from 'auto-type/auto-type-helper-factory';
 import { AutoTypeParser } from 'auto-type/auto-type-parser';
 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 { AutoTypeSelectView } from 'views/auto-type/auto-type-select-view';

 const logger = new Logger('auto-type');
 const clearTextAutoTypeLog = !!localStorage.debugAutoType;

 const AutoType = {
-    helper: AutoTypeHelperFactory.create(),
    enabled: !!(Launcher && Launcher.autoTypeSupported),
    supportsEventsWithWindowId: !!(Launcher && Launcher.platform() === 'linux'),
    selectEntryView: false,
@ -64,9 +65,16 @@ const AutoType = {
    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: Locale.autoTypeErrorGeneric.replace('{}', err.toString())
+                    body,
+                    link
                });
            }
        });
@ -160,8 +168,10 @@ const AutoType = {
    },

    getActiveWindowInfo(callback) {
-        logger.debug('Getting window info');
-        return this.helper.getActiveWindowInfo((err, windowInfo) => {
+        const helperType = AppSettingsModel.useLegacyAutoType ? 'legacy' : 'native';
+        logger.debug(`Getting window info using ${helperType} helper`);
+        const helper = AutoTypeHelperFactory.create();
+        return helper.getActiveWindowInfo((err, windowInfo) => {
            if (err) {
                logger.error('Error getting window info', err);
            } else {
--- a/app/scripts/comp/app/app-rights-checker.js
+++ b/app/scripts/comp/app/app-rights-checker.js
@ -58,6 +58,7 @@ const AppRightsChecker = {
    runInstaller() {
        Launcher.spawn({
            cmd: this.AppPath + '/Contents/Installer/KeeWeb Installer.app/Contents/MacOS/applet',
+            args: ['--install'],
            complete: () => {
                this.needRunInstaller((needRun) => {
                    if (this.alert && !needRun) {
--- a/app/scripts/comp/app/online-password-checker.js
+++ b/app/scripts/comp/app/online-password-checker.js
@ -0,0 +1,37 @@
+import kdbxweb from 'kdbxweb';
+import { Logger } from 'util/logger';
+
+const logger = new Logger('online-password-checker');
+
+const exposedPasswords = {};
+
+function checkIfPasswordIsExposedOnline(password) {
+    if (!password || !password.isProtected || !password.byteLength) {
+        return false;
+    }
+    const saltedValue = password.saltedValue();
+    const cached = exposedPasswords[saltedValue];
+    if (cached !== undefined) {
+        return cached;
+    }
+    const passwordBytes = password.getBinary();
+    return crypto.subtle
+        .digest({ name: 'SHA-1' }, passwordBytes)
+        .then((sha1) => {
+            kdbxweb.ByteUtils.zeroBuffer(passwordBytes);
+            sha1 = kdbxweb.ByteUtils.bytesToHex(sha1).toUpperCase();
+            const shaFirst = sha1.substr(0, 5);
+            return fetch(`https://api.pwnedpasswords.com/range/${shaFirst}`)
+                .then((response) => response.text())
+                .then((response) => {
+                    const isPresent = response.includes(sha1.substr(5));
+                    exposedPasswords[saltedValue] = isPresent;
+                    return isPresent;
+                });
+        })
+        .catch((e) => {
+            logger.error('Error checking password online', e);
+        });
+}
+
+export { checkIfPasswordIsExposedOnline };
--- a/app/scripts/comp/app/updater.js
+++ b/app/scripts/comp/app/updater.js
@ -1,3 +1,4 @@
+import kdbxweb from 'kdbxweb';
 import { Events } from 'framework/events';
 import { RuntimeInfo } from 'const/runtime-info';
 import { Transport } from 'comp/browser/transport';
@ -15,10 +16,9 @@ const Updater = {
    UpdateInterval: 1000 * 60 * 60 * 24,
    MinUpdateTimeout: 500,
    MinUpdateSize: 10000,
-    UpdateCheckFiles: ['app.asar'],
    nextCheckTimeout: null,
    updateCheckDate: new Date(0),
-    enabled: Launcher && Launcher.updaterEnabled(),
+    enabled: Launcher?.updaterEnabled(),

    getAutoUpdateType() {
        if (!this.enabled) {
@ -34,7 +34,7 @@ const Updater = {
    updateInProgress() {
        return (
            UpdateModel.status === 'checking' ||
-            ['downloading', 'extracting'].indexOf(UpdateModel.updateStatus) >= 0
+            ['downloading', 'extracting', 'updating'].indexOf(UpdateModel.updateStatus) >= 0
        );
    },

@ -97,13 +97,12 @@ const Updater = {
        }
        logger.info('Checking for update...');
        Transport.httpGet({
-            url: Links.Manifest,
-            utf8: true,
-            success: (data) => {
+            url: Links.UpdateJson,
+            json: true,
+            success: (updateJson) => {
                const dt = new Date();
-                const match = data.match(/#\s*(\d+\-\d+\-\d+):v([\d+\.\w]+)/);
-                logger.info('Update check: ' + (match ? match[0] : 'unknown'));
-                if (!match) {
+                logger.info('Update check: ' + (updateJson.version || 'unknown'));
+                if (!updateJson.version) {
                    const errMsg = 'No version info found';
                    UpdateModel.set({
                        status: 'error',
@ -114,16 +113,15 @@ const Updater = {
                    this.scheduleNextCheck();
                    return;
                }
-                const updateMinVersionMatch = data.match(/#\s*updmin:v([\d+\.\w]+)/);
                const prevLastVersion = UpdateModel.lastVersion;
                UpdateModel.set({
                    status: 'ok',
                    lastCheckDate: dt,
                    lastSuccessCheckDate: dt,
-                    lastVersionReleaseDate: new Date(match[1]),
-                    lastVersion: match[2],
+                    lastVersionReleaseDate: new Date(updateJson.date),
+                    lastVersion: updateJson.version,
                    lastCheckError: null,
-                    lastCheckUpdMin: updateMinVersionMatch ? updateMinVersionMatch[1] : null
+                    lastCheckUpdMin: updateJson.minVersion || null
                });
                UpdateModel.save();
                this.scheduleNextCheck();
@ -161,7 +159,7 @@ const Updater = {
    canAutoUpdate() {
        const minLauncherVersion = UpdateModel.lastCheckUpdMin;
        if (minLauncherVersion) {
-            const cmp = SemVer.compareVersions(Launcher.version, minLauncherVersion);
+            const cmp = SemVer.compareVersions(RuntimeInfo.version, minLauncherVersion);
            if (cmp < 0) {
                UpdateModel.set({ updateStatus: 'ready', updateManual: true });
                return false;
@ -182,28 +180,55 @@ const Updater = {
        }
        UpdateModel.set({ updateStatus: 'downloading', updateError: null });
        logger.info('Downloading update', ver);
+        const updateAssetName = this.getUpdateAssetName(ver);
+        if (!updateAssetName) {
+            logger.error('Empty updater asset name for', Launcher.platform(), Launcher.arch());
+            return;
+        }
+        const updateUrlBasePath = Links.UpdateBasePath.replace('{ver}', ver);
+        const updateAssetUrl = updateUrlBasePath + updateAssetName;
        Transport.httpGet({
-            url: Links.UpdateDesktop.replace('{ver}', ver),
-            file: 'KeeWeb-' + ver + '.zip',
-            cache: !startedByUser,
-            success: (filePath) => {
-                UpdateModel.set({ updateStatus: 'extracting' });
-                logger.info('Extracting update file', this.UpdateCheckFiles, filePath);
-                this.extractAppUpdate(filePath, (err) => {
-                    if (err) {
-                        logger.error('Error extracting update', err);
+            url: updateAssetUrl,
+            file: updateAssetName,
+            cleanupOldFiles: true,
+            cache: true,
+            success: (assetFilePath) => {
+                logger.info('Downloading update signatures');
+                Transport.httpGet({
+                    url: updateUrlBasePath + 'Verify.sign.sha256',
+                    text: true,
+                    file: updateAssetName + '.sign',
+                    cleanupOldFiles: true,
+                    cache: true,
+                    success: (assetFileSignaturePath) => {
+                        this.verifySignature(assetFilePath, updateAssetName, (err, valid) => {
+                            if (err || !valid) {
+                                UpdateModel.set({
+                                    updateStatus: 'error',
+                                    updateError: err
+                                        ? 'Error verifying update signature'
+                                        : 'Invalid update signature'
+                                });
+                                Launcher.deleteFile(assetFilePath);
+                                Launcher.deleteFile(assetFileSignaturePath);
+                                return;
+                            }
+                            logger.info('Update is ready', assetFilePath);
+                            UpdateModel.set({ updateStatus: 'ready', updateError: null });
+                            if (!startedByUser) {
+                                Events.emit('update-app');
+                            }
+                            if (typeof successCallback === 'function') {
+                                successCallback();
+                            }
+                        });
+                    },
+                    error(e) {
+                        logger.error('Error downloading update signatures', e);
                        UpdateModel.set({
                            updateStatus: 'error',
-                            updateError: 'Error extracting update'
+                            updateError: 'Error downloading update signatures'
                        });
-                    } else {
-                        UpdateModel.set({ updateStatus: 'ready', updateError: null });
-                        if (!startedByUser) {
-                            Events.emit('update-app');
-                        }
-                        if (typeof successCallback === 'function') {
-                            successCallback();
-                        }
                    }
                });
            },
@ -217,61 +242,64 @@ const Updater = {
        });
    },

-    extractAppUpdate(updateFile, cb) {
-        const expectedFiles = this.UpdateCheckFiles;
-        const appPath = Launcher.getUserDataPath();
-        const StreamZip = Launcher.req('node-stream-zip');
-        StreamZip.setFs(Launcher.req('original-fs'));
-        const zip = new StreamZip({ file: updateFile, storeEntries: true });
-        zip.on('error', cb);
-        zip.on('ready', () => {
-            const containsAll = expectedFiles.every((expFile) => {
-                const entry = zip.entry(expFile);
-                return entry && entry.isFile;
+    verifySignature(assetFilePath, assetName, callback) {
+        logger.info('Verifying update signature', assetName);
+        const fs = Launcher.req('fs');
+        const signaturesTxt = fs.readFileSync(assetFilePath + '.sign', 'utf8');
+        const assetSignatureLine = signaturesTxt
+            .split('\n')
+            .find((line) => line.endsWith(assetName));
+        if (!assetSignatureLine) {
+            logger.error('Signature not found for asset', assetName);
+            callback('Asset signature not found');
+            return;
+        }
+        const signature = kdbxweb.ByteUtils.hexToBytes(assetSignatureLine.split(' ')[0]);
+        const fileBytes = fs.readFileSync(assetFilePath);
+        SignatureVerifier.verify(fileBytes, signature)
+            .catch((e) => {
+                logger.error('Error verifying signature', e);
+                callback('Error verifying signature');
+            })
+            .then((valid) => {
+                logger.info(`Update asset signature is ${valid ? 'valid' : 'invalid'}`);
+                callback(undefined, valid);
            });
-            if (!containsAll) {
-                return cb('Bad archive');
-            }
-            this.validateArchiveSignature(updateFile, zip)
-                .then(() => {
-                    zip.extract(null, appPath, (err) => {
-                        zip.close();
-                        if (err) {
-                            return cb(err);
-                        }
-                        Launcher.deleteFile(updateFile);
-                        cb();
-                    });
-                })
-                .catch((e) => {
-                    return cb('Invalid archive: ' + e);
-                });
-        });
    },

-    validateArchiveSignature(archivePath, zip) {
-        if (!zip.comment) {
-            return Promise.reject('No comment in ZIP');
+    getUpdateAssetName(ver) {
+        const platform = Launcher.platform();
+        const arch = Launcher.arch();
+        switch (platform) {
+            case 'win32':
+                switch (arch) {
+                    case 'x64':
+                        return `KeeWeb-${ver}.win.x64.exe`;
+                    case 'ia32':
+                        return `KeeWeb-${ver}.win.ia32.exe`;
+                    case 'arm64':
+                        return `KeeWeb-${ver}.win.arm64.exe`;
+                }
+                break;
+            case 'darwin':
+                switch (arch) {
+                    case 'x64':
+                        return `KeeWeb-${ver}.mac.x64.dmg`;
+                    case 'arm64':
+                        return `KeeWeb-${ver}.mac.arm64.dmg`;
+                }
+                break;
        }
-        if (zip.comment.length !== 512) {
-            return Promise.reject('Bad comment length in ZIP: ' + zip.comment.length);
-        }
-        try {
-            const zipFileData = Launcher.req('fs').readFileSync(archivePath);
-            const dataToVerify = zipFileData.slice(0, zip.centralDirectory.headerOffset + 22);
-            const signature = window.Buffer.from(zip.comment, 'hex');
-            return SignatureVerifier.verify(dataToVerify, signature)
-                .catch(() => {
-                    throw new Error('Error verifying signature');
-                })
-                .then((isValid) => {
-                    if (!isValid) {
-                        throw new Error('Invalid signature');
-                    }
-                });
-        } catch (err) {
-            return Promise.reject(err.toString());
+        return undefined;
+    },
+
+    installAndRestart() {
+        if (!Launcher) {
+            return;
        }
+        const updateAssetName = this.getUpdateAssetName(UpdateModel.lastVersion);
+        const updateFilePath = Transport.cacheFilePath(updateAssetName);
+        Launcher.requestRestartAndUpdate(updateFilePath);
    }
 };

--- a/app/scripts/comp/browser/theme-watcher.js
+++ b/app/scripts/comp/browser/theme-watcher.js
@ -0,0 +1,17 @@
+import { Events } from 'framework/events';
+
+const ThemeWatcher = {
+    dark: false,
+
+    init() {
+        const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        mediaQuery.addEventListener('change', (e) => {
+            const dark = e.matches;
+            this.dark = dark;
+            Events.emit('dark-mode-changed', { dark });
+        });
+        this.dark = mediaQuery.matches;
+    }
+};
+
+export { ThemeWatcher };
--- a/app/scripts/comp/browser/transport.js
+++ b/app/scripts/comp/browser/transport.js
@ -1,15 +1,33 @@
 import { Launcher } from 'comp/launcher';
 import { Logger } from 'util/logger';
 import { noop } from 'util/fn';
+import { StringFormat } from 'util/formatting/string-format';

 const logger = new Logger('transport');

 const Transport = {
+    cacheFilePath(fileName) {
+        return Launcher.getTempPath(fileName);
+    },
+
    httpGet(config) {
        let tmpFile;
        const fs = Launcher.req('fs');
        if (config.file) {
-            tmpFile = Launcher.getTempPath(config.file);
+            const baseTempPath = Launcher.getTempPath();
+            if (config.cleanupOldFiles) {
+                const allFiles = fs.readdirSync(baseTempPath);
+                for (const file of allFiles) {
+                    if (
+                        file !== config.file &&
+                        StringFormat.replaceVersion(file, '0') ===
+                            StringFormat.replaceVersion(config.file, '0')
+                    ) {
+                        fs.unlinkSync(Launcher.joinPath(baseTempPath, file));
+                    }
+                }
+            }
+            tmpFile = Launcher.joinPath(baseTempPath, config.file);
            if (fs.existsSync(tmpFile)) {
                try {
                    if (config.cache && fs.statSync(tmpFile).size > 0) {
@ -62,9 +80,16 @@ const Transport = {
                            });
                            res.on('end', () => {
                                data = window.Buffer.concat(data);
-                                if (config.utf8) {
+                                if (config.text || config.json) {
                                    data = data.toString('utf8');
                                }
+                                if (config.json) {
+                                    try {
+                                        data = JSON.parse(data);
+                                    } catch (e) {
+                                        config.error('Error parsing JSON: ' + e.message);
+                                    }
+                                }
                                config.success(data);
                            });
                        }
--- a/app/scripts/comp/launcher/launcher-electron.js
+++ b/app/scripts/comp/launcher/launcher-electron.js
@ -17,6 +17,9 @@ const Launcher = {
    platform() {
        return process.platform;
    },
+    arch() {
+        return process.arch;
+    },
    electron() {
        return this.req('electron');
    },
@ -55,7 +58,15 @@ const Launcher = {
        return this.joinPath(this.userDataPath, fileName || '');
    },
    getTempPath(fileName) {
-        return this.joinPath(this.remoteApp().getPath('temp'), fileName || '');
+        let tempPath = this.joinPath(this.remoteApp().getPath('temp'), 'KeeWeb');
+        const fs = this.req('fs');
+        if (!fs.existsSync(tempPath)) {
+            fs.mkdirSync(tempPath);
+        }
+        if (fileName) {
+            tempPath = this.joinPath(tempPath, fileName);
+        }
+        return tempPath;
    },
    getDocumentsPath(fileName) {
        return this.joinPath(this.remoteApp().getPath('documents'), fileName || '');
@ -164,18 +175,18 @@ const Launcher = {
    requestExit() {
        const app = this.remoteApp();
        app.setHookBeforeQuitEvent(false);
-        if (this.restartPending) {
-            app.restartApp();
+        if (this.pendingUpdateFile) {
+            app.restartAndUpdate(this.pendingUpdateFile);
        } else {
            app.quit();
        }
    },
-    requestRestart() {
-        this.restartPending = true;
+    requestRestartAndUpdate(updateFilePath) {
+        this.pendingUpdateFile = updateFilePath;
        this.requestExit();
    },
    cancelRestart() {
-        this.restartPending = false;
+        this.pendingUpdateFile = undefined;
    },
    setClipboardText(text) {
        return this.electron().clipboard.writeText(text);
@ -203,7 +214,7 @@ const Launcher = {
        return process.platform !== 'linux';
    },
    updaterEnabled() {
-        return this.electron().remote.process.argv.indexOf('--disable-updater') === -1;
+        return process.platform !== 'linux';
    },
    getMainWindow() {
        return this.remoteApp().getMainWindow();
@ -301,6 +312,18 @@ const Launcher = {
    },
    setGlobalShortcuts(appSettings) {
        this.remoteApp().setGlobalShortcuts(appSettings);
+    },
+    minimizeMainWindow() {
+        this.getMainWindow().minimize();
+    },
+    maximizeMainWindow() {
+        this.getMainWindow().maximize();
+    },
+    restoreMainWindow() {
+        this.getMainWindow().restore();
+    },
+    mainWindowMaximized() {
+        return this.getMainWindow().isMaximized();
    }
 };

@ -308,6 +331,8 @@ Events.on('launcher-exit-request', () => {
    setTimeout(() => Launcher.exit(), 0);