tabby-rdp 0.3.4 → 0.4.1

package/dist/desktop.service.js

@@ -25,6 +25,8 @@ const audio_1 = require("./audio");
 const connectionStatus_1 = require("./connectionStatus");
 const microphone_1 = require("./microphone");
 const desktopForm_1 = require("./desktopForm");
+const accounts_1 = require("./accounts");
+const accountForm_1 = require("./accountForm");
 const fileTransfer_1 = require("./fileTransfer");
 const desktops_1 = require("./desktops");
 const help_1 = require("./help");
@@ -322,6 +324,11 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
          * long as Tabby runs; a Windows host is found out on the first connect there, which costs a failed setup.
          */
         this.ownDesktops = new Map();
+        /**
+         * Forgets the saved account of the pane's desktop and connects again, with the sign-in form. For xrdp above all:
+         * with a wrong password it shows its own login window rather than refusing, so the form never comes back.
+         */
+        this.askAgain = new WeakSet();
         /** VMs found on SSH hosts (see vms.ts), by target key: when, and as desktops. */
         this.vms = new Map();
         this.lastUsed = new Map();
@@ -389,14 +396,12 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
         const spec = this.sessions.get(pane)?.spec;
         return !!spec && this.signsIn(spec);
     }
-    /**
-     * Forgets the saved account of the pane's desktop and connects again, with the sign-in form. For xrdp above all:
-     * with a wrong password it shows its own login window rather than refusing, so the form never comes back.
-     */
     async signInAgain(pane) {
         const session = this.sessions.get(pane);
         if (session && this.signsIn(session.spec)) {
             await (0, signin_1.forgetCredentials)(session.key);
+            // With a saved account, the form asks for its password anew (the saved one stays until then).
+            this.askAgain.add(pane);
             await this.reopen(pane, session.spec);
         }
     }
@@ -408,9 +413,10 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
         if (target.direct) {
             return [target.direct];
         }
+        // With their group's defaults (an account for the whole group), as Tabby resolves a profile when opening it.
         const viaProfile = target.profileId
             ? (this.config.store.profiles ?? []).filter((p) => p?.type === targets_1.RDP_PROFILE_TYPE && p.options?.host && p.options.via === target.profileId)
-                .map((p) => ({ ...p.options, name: p.name }))
+                .map((p) => ({ ...this.profiles.getConfigProxyForProfile(p).options, name: p.name }))
             : [];
         const specs = (0, desktops_1.desktopsFor)(target, this.config.store.remoteDesktop?.desktops, this.ownDesktops.get(target.key), viaProfile);
         // Found VMs come last, and not where a configured desktop has the same address.
@@ -480,6 +486,129 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
     desktopOf(pane) {
         return this.sessions.get(pane)?.spec ?? null;
     }
+    /** `remoteDesktop.accounts`: the saved accounts desktops can sign in with (see accounts.ts). */
+    accounts() {
+        return (0, accounts_1.accountsOf)(this.config.store.remoteDesktop);
+    }
+    /**
+     * The desktops that sign in with a saved account: configured ones behind SSH hosts, and RDP profiles (their own
+     * choice, or their profile group's default when they make none). Each comes with what opens its editor.
+     */
+    accountUses(id) {
+        const desktops = this.configuredDesktops().flatMap((d, i) => d.account === id ? [{ name: String(d.name ?? (0, desktops_1.desktopIdOf)(d)), desktopIndex: i }] : []);
+        const groups = this.config.store.groups ?? [];
+        const inherited = (p) => p.options?.account === undefined && groups.find(g => g.id === p.group)?.defaults?.[targets_1.RDP_PROFILE_TYPE]?.options?.account === id;
+        const profiles = (this.config.store.profiles ?? [])
+            .filter((p) => p?.type === targets_1.RDP_PROFILE_TYPE && (p.options?.account === id || inherited(p)))
+            .map((p) => ({ name: String(p.name ?? p.options?.host ?? ''), profileId: p.id ? String(p.id) : undefined }));
+        return [...desktops, ...profiles];
+    }
+    /**
+     * Adds a saved account (no id) or changes one. `password`: the new one for the keychain; undefined keeps what is
+     * there. A new user name or domain without a new password drops the old password: it was for the old account.
+     * Returns the account's id, and the keychain's complaint if the password couldn't be saved.
+     */
+    async saveAccount(account, password) {
+        const list = this.accounts();
+        const old = list.find(a => a.id === account.id);
+        const entry = {
+            id: old?.id ?? (0, accounts_1.newAccountId)(list),
+            name: account.name.trim() || (0, accounts_1.signInName)(account),
+            username: account.username.trim(),
+            ...account.domain?.trim() ? { domain: account.domain.trim() } : {},
+        };
+        // The password first: a new user name must not be written while the old password (for the old name) stays, nor
+        // a new password reported as saved when the store refused it.
+        let keychainError;
+        if (password !== undefined && password !== '') {
+            await (0, signin_1.saveCredentials)((0, accounts_1.accountKey)(entry.id), { username: (0, accounts_1.signInName)(entry), password }, `saved account ${entry.name}`).catch(e => { keychainError = String(e?.message ?? e); });
+        }
+        else if (old && (0, accounts_1.signInName)(old) !== (0, accounts_1.signInName)(entry)) {
+            await (0, signin_1.forgetCredentialsOrFail)((0, accounts_1.accountKey)(entry.id)).catch(e => { keychainError = `the old password couldn't be removed: ${e?.message ?? e}`; });
+        }
+        if (keychainError && !old) {
+            // Not added at all: a retry would otherwise make a second account.
+            return { id: entry.id, keychainError: `${keychainError}. The account wasn't added` };
+        }
+        if (keychainError && old && (0, accounts_1.signInName)(old) !== (0, accounts_1.signInName)(entry)) {
+            // The sign-in name stays as it was; the account's name can still change.
+            entry.username = old.username;
+            if (old.domain) {
+                entry.domain = old.domain;
+            }
+            else {
+                delete entry.domain;
+            }
+        }
+        this.config.store.remoteDesktop.accounts = old ? list.map(a => a === old ? entry : a) : [...list, entry];
+        await this.config.save();
+        this.changed$.next();
+        return { id: entry.id, keychainError };
+    }
+    /** A desktop form's "New account…": saves it and hands it back for the form's list. */
+    async addAccountFromForm(input) {
+        const { id, keychainError } = await this.saveAccount({ name: input.name, username: input.username, domain: input.domain }, input.password);
+        if (keychainError) {
+            throw new Error(keychainError);
+        }
+        return this.accounts().find(a => a.id === id);
+    }
+    /** Whether a password is saved for the account; 'unknown' while the Vault is locked (it isn't unlocked for this). */
+    accountHasPassword(id) {
+        return (0, signin_1.hasCredentials)((0, accounts_1.accountKey)(id));
+    }
+    /** "Remove…" on a saved account: asks first, naming the desktops that use it. Resolves true when removed. */
+    async confirmRemoveAccount(id) {
+        const account = this.accounts().find(a => a.id === id);
+        if (!account) {
+            return false;
+        }
+        const uses = this.accountUses(id);
+        const { response } = await this.platform.showMessageBox({
+            type: 'warning',
+            message: `Remove the account "${account.name}"?`,
+            detail: `${(0, accounts_1.signInName)(account)}. Its saved password is removed too. ` + (uses.length
+                ? `${uses.length === 1 ? 'One desktop uses' : `${uses.length} desktops use`} it and will ask for an account when connecting: ${uses.map(u => u.name).join(', ')}.`
+                : 'No desktop uses it.'),
+            buttons: ['Remove', 'Keep'],
+            defaultId: 1,
+            cancelId: 1,
+        });
+        if (response !== 0) {
+            return false;
+        }
+        await this.removeAccount(id);
+        return true;
+    }
+    /** Removes a saved account and its password; desktops that used it go back to asking. */
+    async removeAccount(id) {
+        const store = this.config.store.remoteDesktop;
+        store.accounts = this.accounts().filter(a => a.id !== id);
+        if (this.configuredDesktops().some(d => d.account === id)) {
+            store.desktops = this.configuredDesktops().map(d => {
+                if (d.account !== id) {
+                    return d;
+                }
+                const { account: _account, ...rest } = d;
+                return rest;
+            });
+        }
+        for (const profile of this.config.store.profiles ?? []) {
+            if (profile?.type === targets_1.RDP_PROFILE_TYPE && profile.options?.account === id) {
+                profile.options.account = '';
+            }
+        }
+        // A profile group's default for remote desktop profiles, too.
+        for (const group of this.config.store.groups ?? []) {
+            const options = group?.defaults?.[targets_1.RDP_PROFILE_TYPE]?.options;
+            if (options?.account === id) {
+                options.account = '';
+            }
+        }
+        await this.config.save();
+        this.changed$.next();
+        await (0, signin_1.forgetCredentialsOrFail)((0, accounts_1.accountKey)(id)).catch(e => this.notifications.error(`The account is removed, but its password could not be: ${e?.message ?? e}`));
+    }
     /** `remoteDesktop.desktops`: the desktops configured behind SSH hosts. */
     configuredDesktops() {
         const list = this.config.store.remoteDesktop?.desktops;
@@ -500,6 +629,8 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
         const entry = await (0, desktopForm_1.askDesktop)(pane.element.nativeElement, {
             title: `Add a desktop reached through ${target.label}`,
             action: 'Add and open',
+            accounts: this.accounts(),
+            addAccount: input => this.addAccountFromForm(input),
             entry: { via: hostname, host: '127.0.0.1', port: 3389 },
             check: e => this.addressTaken(e, -1),
         });
@@ -524,20 +655,37 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
      * sharpness along; a new user name drops the saved account, which was for the old one. Open sessions keep running.
      */
     async editDesktop(pane, index) {
-        const old = this.configuredDesktops()[index];
-        if (!old) {
+        if (!this.configuredDesktops()[index]) {
             return;
         }
         if (this.isVisible(pane)) {
             this.showConsole(pane);
         }
-        const entry = await (0, desktopForm_1.askDesktop)(pane.element.nativeElement, {
-            title: `Edit ${old.name ?? (0, desktops_1.desktopIdOf)(old)} (behind ${old.via})`,
+        await this.editDesktopIn(pane.element.nativeElement, index);
+        pane.frontend?.focus();
+    }
+    /** What a desktop's `via` can name: the SSH profiles' names and hosts (see viaMatches), for the form to suggest. */
+    async sshHosts() {
+        const profiles = await this.profiles.getProfiles().catch(() => []);
+        const names = profiles.filter((p) => p.type === 'ssh' && !p.isTemplate)
+            .flatMap((p) => [p.name?.replace(/\s*\(\.ssh\/config\)$/, ''), p.options?.host].filter(Boolean));
+        return [...new Set(names)].sort((a, b) => a.localeCompare(b));
+    }
+    /** "Edit a desktop" with the form over any element (a pane, or the settings page). */
+    async editDesktopIn(host, index, askVia = false) {
+        const old = this.configuredDesktops()[index];
+        if (!old) {
+            return;
+        }
+        const entry = await (0, desktopForm_1.askDesktop)(host, {
+            title: `Edit ${old.name ?? (0, desktops_1.desktopIdOf)(old)}${askVia ? '' : ` (behind ${old.via})`}`,
             action: 'Save',
+            accounts: this.accounts(),
+            addAccount: input => this.addAccountFromForm(input),
+            hosts: askVia ? await this.sshHosts() : undefined,
             entry: old,
             check: e => this.addressTaken(e, index),
         });
-        pane.frontend?.focus();
         // Compared with the entry as it is now: the config can change while the form shows.
         const list = this.configuredDesktops();
         if (!entry || list[index] !== old) {
@@ -547,7 +695,7 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
         this.config.store.remoteDesktop.desktops = list;
         this.config.save();
         this.changed$.next();
-        const accountChanged = (old.username ?? '') !== (entry.username ?? '') || (old.domain ?? '') !== (entry.domain ?? '');
+        const accountChanged = (old.username ?? '') !== (entry.username ?? '') || (old.domain ?? '') !== (entry.domain ?? '') || (old.account ?? '') !== (entry.account ?? '');
         await this.desktopEdited((0, desktops_1.desktopIdOf)(old), (0, desktops_1.desktopIdOf)(entry), accountChanged, false);
     }
     /**
@@ -610,6 +758,21 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
             await this.importRdp(new Uint8Array(await file.arrayBuffer()), file.name);
         }
     }
+    /**
+     * The profile group for remote desktop profiles the plugin makes itself (an .rdp import, "New profile…" on the
+     * settings page): "Remote desktops", made the first time. Profiles made on Tabby's Profiles page go where the user
+     * puts them.
+     */
+    async remoteDesktopGroup() {
+        const groups = await this.profiles.getProfileGroups({ includeNonUserGroup: false });
+        const existing = groups.find(g => g.name === 'Remote desktops');
+        if (existing?.id) {
+            return existing.id;
+        }
+        const group = { name: 'Remote desktops', profiles: [] };
+        await this.profiles.newProfileGroup(group, { genId: true });
+        return group.id;
+    }
     /**
      * Adds a "Remote desktop (RDP)" profile from a .rdp file's contents (address, user name, domain; see rdpFile.ts)
      * and opens it; or opens the profile that already has that address and user. Returns the profile, or null.
@@ -631,6 +794,7 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
             type: targets_1.RDP_PROFILE_TYPE,
             name: fileName.replace(/^.*[\\/]/, '').replace(/\.rdp$/i, '') || parsed.host,
             icon: 'fas fa-desktop',
+            group: await this.remoteDesktopGroup(),
             options: { host: parsed.host, port: parsed.port, kind: 'windows', username: parsed.username ?? '', domain: parsed.domain ?? '', via: '' },
         };
         await this.profiles.newProfile(profile);
@@ -1437,23 +1601,43 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
             spec.port = endpoint.port;
             spec.username ??= endpoint.username;
         }
-        const saved = retryError ? null : await (0, signin_1.loadCredentials)(session.key);
+        // A saved account (Settings): its user name, and its password from the keychain. One that has none yet, or that
+        // this desktop just refused, is asked for here and saved for every desktop that uses the account.
+        const account = spec.account ? this.accounts().find(a => a.id === spec.account) : undefined;
+        if (spec.account && !account) {
+            session.log.push('sign-in: its saved account no longer exists; asking');
+        }
+        const again = this.askAgain.delete(pane);
+        // A desktop whose account is gone asks, rather than falling back to a login of its own saved earlier.
+        let saved = retryError || again || spec.account && !account ? null : await (0, signin_1.loadCredentials)(account ? (0, accounts_1.accountKey)(account.id) : session.key);
+        if (saved && account && saved.username !== (0, accounts_1.signInName)(account)) {
+            // Kept for an earlier user name of the account (its change didn't reach the store): not this one's.
+            session.log.push(`sign-in: the account's saved password is for ${saved.username}, not ${(0, accounts_1.signInName)(account)}; asking`);
+            saved = null;
+        }
         if (saved) {
-            return { host: spec.host, port: spec.port, credentials: saved, remember: false };
+            if (account) {
+                session.log.push(`sign-in: the saved account "${account.name}"`);
+            }
+            return { host: spec.host, port: spec.port, credentials: account ? { username: (0, accounts_1.signInName)(account), password: saved.password } : saved, remember: false, domain: account ? account.domain ?? '' : undefined };
         }
         session.status('');
         const asked = (0, signin_1.askCredentials)(session.overlay, {
             // The host's own desktops (its own, or its xrdp besides GNOME) and direct ones need no "via".
             title: spec.id === desktops_1.OWN_DESKTOP || target.direct || spec.kind === 'xrdp' && spec.host === '127.0.0.1' ? `Sign in to ${spec.name}` : `Sign in to ${spec.name} (via ${target.label})`,
-            username: spec.username,
+            username: account ? (0, accounts_1.signInName)(account) : spec.username,
             error: retryError,
             canRemember: true,
+            account: account?.name,
         }, session.disposed);
         if (session.visible) {
             setTimeout(() => session.visible && session.focusDesktop());
         }
         const entered = await asked;
-        return entered && { host: spec.host, port: spec.port, credentials: entered, remember: entered.remember };
+        return entered && {
+            host: spec.host, port: spec.port, credentials: entered, remember: entered.remember, domain: account ? account.domain ?? '' : undefined,
+            saveKey: account && (0, accounts_1.accountKey)(account.id), saveLabel: account && `saved account ${account.name}`, saveFor: account && (0, accounts_1.signInName)(account),
+        };
     }
     async connect(pane, target, spec, session) {
         const alive = () => this.sessions.get(pane) === session;
@@ -1505,6 +1689,8 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
                     return;
                 }
                 if (outcome.signInFailed && this.signsIn(spec) && attempt < 5 && alive()) {
+                    // The desktop's own saved account goes. A shared one stays until a new password is entered: this
+                    // desktop refusing it doesn't make it wrong for the others.
                     await (0, signin_1.forgetCredentials)(session.key);
                     retryError = outcome.signInFailed;
                     endpoint = null;
@@ -1762,7 +1948,7 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
             const size = remoteSizeFor(session.overlay.getBoundingClientRect(), settings);
             const { width, height } = size;
             // DOMAIN\user or user@domain go to the server as typed; only the former needs splitting.
-            const [domain, username] = /^([^\\]+)\\(.+)$/.exec(credentials.username)?.slice(1) ?? [spec.domain ?? '', credentials.username];
+            const [domain, username] = /^([^\\]+)\\(.+)$/.exec(credentials.username)?.slice(1) ?? [endpoint.domain ?? spec.domain ?? '', credentials.username];
             session.status(spec.id === desktops_1.OWN_DESKTOP ? `Connecting to ${target.label}…`
                 : target.direct ? `Connecting to ${spec.name}…` : `Connecting to ${spec.name} via ${target.label}…`);
             const config = session.ui.configBuilder()
@@ -1847,8 +2033,14 @@ let RemoteDesktopService = RemoteDesktopService_1 = class RemoteDesktopService {
             this.syncIndicator(session);
             this.changed$.next();
             this.reconnects.delete(pane); // connected again: a later drop starts over
-            if (endpoint.remember) {
-                (0, signin_1.saveCredentials)(session.key, credentials).then(() => session.log.push('sign-in: saved in the keychain'), e => session.log.push(`sign-in: keychain: ${e?.message ?? e}`));
+            // Under a saved account only while that account is still there with the same sign-in name: the prompt may
+            // have been open while it was removed or changed in Settings.
+            const accountNow = endpoint.saveKey ? this.accounts().find(a => (0, accounts_1.accountKey)(a.id) === endpoint.saveKey) : undefined;
+            if (endpoint.remember && endpoint.saveKey && (!accountNow || (0, accounts_1.signInName)(accountNow) !== endpoint.saveFor)) {
+                session.log.push(`sign-in: not saved: the account ${accountNow ? 'changed' : 'was removed'} meanwhile`);
+            }
+            else if (endpoint.remember) {
+                (0, signin_1.saveCredentials)(endpoint.saveKey ?? session.key, credentials, endpoint.saveLabel).then(() => session.log.push(`sign-in: saved ${endpoint.saveKey ? 'as the account\'s password ' : ''}in ${(0, signin_1.storeName)()}`), e => session.log.push(`sign-in: ${(0, signin_1.storeName)()}: ${e?.message ?? e}`));
             }
             if (session.visible) {
                 session.focusDesktop();
@@ -1901,7 +2093,38 @@ function installStyle() {
     }
     styleInstalled = true;
     const style = document.createElement('style');
-    style.textContent = STYLE + signin_1.STYLE + fileTransfer_1.STYLE + connectionStatus_1.STYLE + osd_1.OSD_STYLE;
+    style.textContent = STYLE + signin_1.STYLE + fileTransfer_1.STYLE + connectionStatus_1.STYLE + osd_1.OSD_STYLE + DRAGBAR_STYLE + accountForm_1.STYLE;
     document.head.appendChild(style);
+    keepWindowDraggable();
+}
+/** A strip the height of the tab bar that stays a window drag region over a dialog (the plugin's, and Tabby's). */
+const DRAGBAR_STYLE = `
+.trd-form-dragbar { display: none; }
+.modal > .trd-form-dragbar { display: block; position: fixed; left: 0; right: 0; top: 0; height: var(--tabs-height, 38px); -webkit-app-region: drag; }
+`;
+/**
+ * Tabby's dialogs (ng-bootstrap modals) cover the whole window, tab bar included, with nothing marked as a drag
+ * region, so the window can't be moved while one shows. Each gets a strip where the tab bar is; the dialog box itself
+ * is below it. The plugin's own dialogs do the same (see settingsPage.ts).
+ */
+function keepWindowDraggable() {
+    const strip = (modal) => {
+        if (!modal.querySelector(':scope > .trd-form-dragbar')) {
+            const bar = document.createElement('div');
+            bar.className = 'trd-form-dragbar';
+            modal.prepend(bar);
+        }
+    };
+    // ng-bootstrap appends each dialog (ngb-modal-window.modal) to the body itself: only the body's children are watched.
+    document.querySelectorAll('body > .modal').forEach(strip);
+    new MutationObserver(records => {
+        for (const record of records) {
+            record.addedNodes.forEach(node => {
+                if (node instanceof Element && node.classList.contains('modal')) {
+                    strip(node);
+                }
+            });
+        }
+    }).observe(document.body, { childList: true });
 }
 //# sourceMappingURL=desktop.service.js.map