tabby-rdp 0.5.0 → 0.5.2

package/dist/ui.js

@@ -17,9 +17,12 @@ exports.settingsMenu = settingsMenu;
 const core_1 = require("@angular/core");
 const tabby_core_1 = require("tabby-core");
 const tabby_terminal_1 = require("tabby-terminal");
+const clipboard_1 = require("./clipboard");
 const desktop_service_1 = require("./desktop.service");
+const desktops_1 = require("./desktops");
 const help_1 = require("./help");
 Object.defineProperty(exports, "TOGGLE_HOTKEY", { enumerable: true, get: function () { return help_1.TOGGLE_HOTKEY; } });
+const hyperv_1 = require("./hyperv");
 const keyboard_1 = require("./keyboard");
 const updates_1 = require("./updates");
 const ssh_1 = require("./ssh");
@@ -48,6 +51,9 @@ let RemoteDesktopConfig = class RemoteDesktopConfig extends tabby_core_1.ConfigP
                 sharpness: 'standard',
                 // `desk`: installs a login hook on remotes (applied the next time a desktop opens there).
                 desk: false,
+                // The keys `desk` sends on each host, as that host's setup reported them: [{ desktop: <host account>,
+                // sha256 }] (a digest, not the key). Requests without the host's key are ignored (see openConsole).
+                deskKeys: [],
                 // macOS: ⌘ acts as Ctrl on the remote desktop (false: ⌘ is the Windows/Super key).
                 macShortcuts: true,
                 // Send the characters typed (Unicode) rather than key positions: dead keys, layouts the remote lacks.
@@ -60,8 +66,12 @@ let RemoteDesktopConfig = class RemoteDesktopConfig extends tabby_core_1.ConfigP
                 zoom: 'fit',
                 // A small indicator on the desktop: throughput, frames per second, SSH round trip, connection path.
                 connectionStatus: false,
-                // Send the microphone to the remote desktop while an application there records (applies on the next connect).
+                // Send the microphone to a remote desktop that asks for it, as one does while an app there records
+                // (applies on the next connect).
                 microphone: false,
+                // Which ways the clipboard (text, pictures, files) goes, unless a desktop has its own: 'both' | 'fromRemote'
+                // (only from the remote desktop to this computer) | 'off' (applies on the next connect; see clipboard.ts).
+                clipboard: 'both',
                 // More desktops behind SSH hosts (e.g. a Windows VM whose RDP port the host forwards); see desktops.ts.
                 desktops: [],
                 // Saved accounts desktops can sign in with: [{ id, name, username, domain }]; passwords are in the keychain
@@ -71,8 +81,17 @@ let RemoteDesktopConfig = class RemoteDesktopConfig extends tabby_core_1.ConfigP
                 desktopSharpness: [],
                 // Folders shared with remote desktops as drives (\\tsclient\<name>): [{ path, name, readOnly }]; see drives.ts.
                 sharedFolders: [],
-                // Certificates of desktops behind hosts, trusted on first use: [{ desktop: <session key>, sha256 }].
+                // Certificates remembered for desktops and RD Gateways: [{ desktop: <session key, or gateway#host:port>, sha256,
+                // authority }]; `authority` true where a certificate authority vouched for it, false where the user trusted
+                // it, none where it was trusted on first use (desktops behind hosts). See RemoteDesktopService.checkTrusted.
                 trustedCertificates: [],
+                // Desktops allowed to sign in without Network Level Authentication ("Send the password anyway"), each with
+                // the certificate it was allowed with: [{ desktop: <session key>, sha256 }]. Tabby saves only keys named
+                // here (test/unit/config-defaults.ts).
+                withoutNla: [],
+                // Machines reached with ssh typed in an SSH tab whose desktop was chosen there "from now on" (see remoteFor):
+                // [{ via: <that tab's key>, destination }]. Desktop opens such a one at once; others are asked about first.
+                nestedSSH: [],
                 // The on-screen display naming a desktop for a moment (see osd.ts).
                 osd: { show: 'auto', font: 'condensed', size: 'medium', position: 'top-right', color: '', seconds: 2.5 },
                 // Look for VMs with a desktop on SSH hosts (libvirt) and offer them in the menus (see vms.ts).
@@ -85,6 +104,10 @@ let RemoteDesktopConfig = class RemoteDesktopConfig extends tabby_core_1.ConfigP
                 updateNoted: '',
                 // The tip shown the first time a desktop connects (see help.ts) has been shown.
                 tipShown: false,
+                // The passwords 0.5.0 saved for desktops reached through an RD Gateway, under keys that are now those of the
+                // same addresses without one, have been forgotten from the Vault (see
+                // RemoteDesktopService.gatewayPasswords; each computer's keychain keeps a mark of its own).
+                gatewayPasswordsMigrated: false,
             },
         };
         this.platformDefaults = {
@@ -114,30 +137,38 @@ function toggleLabel(desktop, pane) {
     return desktop.isOpenElsewhere(pane) ? `Switch to ${what} (open in another tab)` : `Open ${what}`;
 }
 /**
- * The host's other desktops (besides the one the toggle acts on): open one here, replacing the current one.
- * Then "Add a desktop behind <host>…".
+ * The host's other desktops (besides the one the toggle acts on, see RemoteDesktopService.choicesOf): open one here,
+ * replacing the current one, a machine's reached through the host included. Then "Add a desktop behind <host>…".
  */
 function desktopChoices(desktop, pane, targetLabel) {
-    const { specs, current } = desktop.choicesOf(pane);
-    const items = specs.filter(spec => spec.id !== current?.id).map(spec => ({
+    const { specs, chosen } = desktop.choicesOf(pane);
+    const items = specs.filter(spec => !chosen(spec)).map(spec => ({
         label: desktop.isOpenElsewhere(pane, spec) ? `Switch to ${spec.name} (open in another tab)`
             // Found on the host (see vms.ts): say so, and that opening one that's off starts it.
             : spec.found === 'off' ? `Start and open ${spec.name} (VM, shut off)` : spec.found ? `Open ${spec.name} (VM)` : `Open ${spec.name}`,
         click: () => desktop.showDesktop(pane, spec.id),
     }));
+    // A host with more VMs than a menu lists: the rest are left out, and that is said rather than hidden.
+    if (desktop.vmsCut(pane)) {
+        items.push({ label: `Only the first ${hyperv_1.MAX_VMS} VMs found are listed`, enabled: false });
+    }
     // Not in a remote desktop tab: it isn't an SSH host.
     if (targetLabel && desktop.hasConsole(pane)) {
         items.push({ label: `Add a desktop behind ${targetLabel}…`, click: () => desktop.addDesktop(pane) });
     }
     return items;
 }
-/** What can be done with the pane's connected desktop: send keys, view only, a screenshot. Shared by the menus. */
+/**
+ * What can be done with the pane's connected desktop: send keys, view only, its microphone, a screenshot. Shared by
+ * the menus.
+ */
 function desktopActions(desktop, keyboard, pane) {
     const spec = desktop.desktopOf(pane);
     if (!spec || !desktop.isConnected(pane)) {
         return [];
     }
     const viewOnly = desktop.isViewOnly(pane);
+    const microphoneStopped = desktop.microphoneStoppedFor(pane);
     return [
         {
             label: 'Send keys',
@@ -150,6 +181,14 @@ function desktopActions(desktop, keyboard, pane) {
             checked: viewOnly,
             click: () => desktop.setViewOnly(pane, !viewOnly),
         },
+        // With the setting on, every desktop gets the microphone when it asks for it; this one can be left out,
+        // reconnects included, and taken back in (see RemoteDesktopService.stopMicrophone).
+        ...desktop.settings().microphone ? [{
+                type: 'checkbox',
+                label: 'Send the microphone (when this desktop asks for it)',
+                checked: !microphoneStopped,
+                click: () => microphoneStopped ? desktop.resumeMicrophone(pane) : desktop.stopMicrophone(pane),
+            }] : [],
         { label: 'Save a screenshot (to Downloads and the clipboard)', click: () => desktop.saveScreenshot(pane) },
     ];
 }
@@ -197,19 +236,23 @@ let RemoteDesktopContextMenu = class RemoteDesktopContextMenu extends tabby_core
         if (this.desktop.isConnected(pane)) {
             items.push({ label: 'Send files…', click: () => this.desktop.sendFiles(pane) });
             items.push(...desktopActions(this.desktop, this.keyboard, pane));
-            // Several desktops in this tab: paste on all of them, or type into all of them.
+            // Several desktops showing in this tab: paste on all of them, or type into all of them. Typing into all, once
+            // on, stays here to be turned off while fewer of them show (those hidden get nothing: see
+            // RemoteDesktopService.takesAll).
             const all = this.desktop.desktopsInTab(pane);
             if (all > 1) {
                 items.push({ label: `Paste to all ${all} desktops in this tab`, click: () => this.desktop.pasteToAll(pane) });
+            }
+            if (all > 1 || this.desktop.isBroadcast(pane)) {
                 items.push({
                     type: 'checkbox',
-                    label: `Type into all ${all} desktops in this tab`,
+                    label: all > 1 ? `Type into all ${all} desktops in this tab` : 'Type into all desktops in this tab',
                     checked: this.desktop.isBroadcast(pane),
                     click: () => this.desktop.setBroadcast(pane, !this.desktop.isBroadcast(pane)),
                 });
             }
         }
-        if (this.desktop.desktopOf(pane)?.found) {
+        if (this.desktop.canSaveFoundDesktop(pane)) {
             items.push({ label: `Save ${this.desktop.desktopOf(pane).name} to this host's desktops`, click: () => this.desktop.saveFoundDesktop(pane) });
         }
         if (this.desktop.canSignInAgain(pane)) {
@@ -256,6 +299,11 @@ function settingsMenu(desktop, pane, help) {
     // The desktop open in this pane can have its own sharpness (for example, Retina for Windows only).
     const spec = pane ? desktop.desktopOf(pane) : null;
     const own = pane ? desktop.ownSharpness(pane) : null;
+    // Narrowed while it was open, by another way of opening it (see DesktopSession.clipboardCap): said only where that
+    // is narrower than what the desktop would have otherwise, its own setting or this one.
+    const capOf = pane ? desktop.clipboardCapOf(pane) : 'both';
+    const otherwise = spec?.clipboard ?? current.clipboard;
+    const cap = (0, clipboard_1.narrowest)(capOf, otherwise) !== otherwise ? (0, clipboard_1.narrowest)(capOf, otherwise) : 'both';
     const ownRadio = (value, label) => ({
         type: 'radio',
         label,
@@ -268,6 +316,12 @@ function settingsMenu(desktop, pane, help) {
         ownRadio('standard', 'Standard'),
         ownRadio('retina', 'Retina'),
     ] : [];
+    // The configured desktops, each with its place in the list (what editing and removing take); an item that is no
+    // entry describes no desktop, and isn't listed. Shown as text whatever an entry holds (see entryText): this menu is
+    // part of every SSH tab's, which Tabby builds from every plugin's items at once, so one entry that can't be shown
+    // would take Tabby's own items too.
+    const entries = desktop.configuredDesktops().flatMap((d, i) => (0, desktops_1.isDesktopEntry)(d) ? [{ index: i, ...(0, desktops_1.entryText)(d) }] : []);
+    const entryLabel = (e) => `${e.name}${e.via ? ` (behind ${e.via})` : ''}…`;
     return [
         ...help ? [
             { label: 'All settings, keys and help…', click: () => help.open() },
@@ -304,10 +358,25 @@ function settingsMenu(desktop, pane, help) {
         },
         {
             type: 'checkbox',
-            label: 'Send the microphone while an app on the remote desktop records (applies on the next connect)',
+            label: 'Send the microphone to remote desktops that ask for it (on applies on the next connect, off at once)',
             checked: current.microphone,
             click: () => desktop.updateSettings({ microphone: !current.microphone }),
         },
+        {
+            // A desktop's own (its profile, or its edit form) takes the place of this: the one open here says so.
+            label: 'Clipboard (applies on the next connect)',
+            submenu: [
+                // Its own: from its profile (or that profile's group's or type's defaults), or its entry behind a host.
+                ...spec?.clipboard ? [
+                    { label: `${spec.name} doesn't follow this: its profile or its own settings say ${clipboard_1.CLIPBOARD_LABELS[spec.clipboard].toLowerCase()}`, enabled: false },
+                ] : [],
+                ...cap !== 'both' ? [
+                    { label: `Clipboard sharing with ${spec?.name ?? 'this desktop'} is ${clipboard_1.CLIPBOARD_LABELS[cap].toLowerCase()} until it is closed, as another way of opening it asked`, enabled: false },
+                ] : [],
+                ...spec?.clipboard || cap !== 'both' ? [{ type: 'separator' }] : [],
+                ...Object.entries(clipboard_1.CLIPBOARD_LABELS).map(([mode, label]) => radio('clipboard', mode, label)),
+            ],
+        },
         {
             type: 'checkbox',
             label: 'Show connection status on the desktop (throughput, frames per second, round trip)',
@@ -331,18 +400,18 @@ function settingsMenu(desktop, pane, help) {
         {
             // The form shows over a console (a remote desktop tab edits its desktop in Tabby's profile settings).
             label: 'Edit a desktop',
-            enabled: !!pane && desktop.hasConsole(pane) && desktop.configuredDesktops().length > 0,
-            submenu: desktop.configuredDesktops().map((d, i) => ({
-                label: `${d.name ?? `${d.host}:${d.port}`} (behind ${d.via})…`,
-                click: () => pane && desktop.editDesktop(pane, i),
+            enabled: !!pane && desktop.hasConsole(pane) && entries.length > 0,
+            submenu: entries.map(e => ({
+                label: entryLabel(e),
+                click: () => pane && desktop.editDesktop(pane, e.index),
             })),
         },
         {
             label: 'Remove a desktop',
-            enabled: desktop.configuredDesktops().length > 0,
-            submenu: desktop.configuredDesktops().map((d, i) => ({
-                label: `${d.name ?? `${d.host}:${d.port}`} (behind ${d.via})…`,
-                click: () => desktop.confirmRemoveDesktop(i),
+            enabled: entries.length > 0,
+            submenu: entries.map(e => ({
+                label: entryLabel(e),
+                click: () => desktop.confirmRemoveDesktop(e.index),
             })),
         },
     ];
@@ -400,4 +469,3 @@ exports.RemoteDesktopToolbarButton = RemoteDesktopToolbarButton = __decorate([
     (0, core_1.Injectable)(),
     __metadata("design:paramtypes", [desktop_service_1.RemoteDesktopService, core_1.NgZone])
 ], RemoteDesktopToolbarButton);
-//# sourceMappingURL=ui.js.map

package/dist/unshowable.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNSHOWABLE = void 0;
+exports.withoutWordJoiners = withoutWordJoiners;
+exports.showable = showable;
+/**
+ * A character that can change how the text around it reads without showing itself, in a name someone else chose (an
+ * .rdp file's, see RemoteDesktopService.importRdp; an `ssh` destination a host reports, see RemoteTargets.nestedSSH;
+ * what a server's certificate says of itself): control and format characters (bidi overrides and isolates, zero-width
+ * ones, tags), the other default-ignorable ones (variation selectors, the combining grapheme joiner, Hangul fillers),
+ * line and paragraph separators, private-use and unpaired surrogate code points, and blanks other than the space
+ * (no-break and wide spaces, the braille blank).
+ */
+exports.UNSHOWABLE = /[\p{Cc}\p{Cf}\p{Co}\p{Cs}\p{Zl}\p{Zp}\p{Default_Ignorable_Code_Point}⠀]|(?! )\p{Zs}/u;
+/**
+ * A zero-width joiner or non-joiner between two letters of a script that writes words with them: Arabic (as Persian
+ * does) and the Indic scripts. There it can change how the letters join, and so show; between letters of other scripts
+ * (Latin, say) it shows nothing at all, and `ad\u200dmin` reads as `admin`.
+ */
+const WORD_JOINERS = new RegExp(['Arabic', 'Devanagari', 'Bengali', 'Gurmukhi', 'Gujarati', 'Oriya', 'Tamil', 'Telugu', 'Kannada', 'Malayalam', 'Sinhala']
+    .map(script => `(?<=[\\p{L}\\p{M}])(?<=\\p{scx=${script}})[\\u200c\\u200d](?=[\\p{L}\\p{M}])(?=\\p{scx=${script}})`).join('|'), 'gu');
+/** `text` without the joiners its scripts write words with (see WORD_JOINERS): what UNSHOWABLE then finds doesn't show. */
+function withoutWordJoiners(text) {
+    return text.replace(WORD_JOINERS, '');
+}
+/**
+ * Text someone else chose, as it is shown and logged: what could reorder or hide part of it (UNSHOWABLE) as U+FFFD, and
+ * at most `max` characters of it, an ellipsis saying where it was cut.
+ */
+function showable(text, max = Infinity) {
+    const shown = text.replace(new RegExp(exports.UNSHOWABLE.source, 'gu'), '�');
+    if (shown.length <= max) {
+        return shown;
+    }
+    // Not between the two halves of a character outside the BMP, which would leave half of one.
+    let end = Math.max(0, max - 1);
+    if (end > 0 && /[\ud800-\udbff]/.test(shown[end - 1])) {
+        end--;
+    }
+    return `${shown.slice(0, end)}…`;
+}

package/dist/updates.js

@@ -9,56 +9,95 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateCheck = void 0;
+exports.UpdateCheck = exports.newer = void 0;
 exports.installedVersion = installedVersion;
-exports.newer = newer;
+exports.latestVersion = latestVersion;
+const fs_1 = require("fs");
+const path_1 = require("path");
 const core_1 = require("@angular/core");
 const rxjs_1 = require("rxjs");
 const tabby_core_1 = require("tabby-core");
 const help_1 = require("./help");
 const targets_1 = require("./targets");
-const REGISTRY = 'https://registry.npmjs.org/tabby-rdp/latest';
-const RELEASES = 'https://github.com/meanaverage/tabby-rdp/releases';
+const hostCompat_1 = require("./hostCompat");
+const packageChangeDialog_1 = require("./packageChangeDialog");
+const releases_1 = require("./releases");
+var releases_2 = require("./releases");
+Object.defineProperty(exports, "newer", { enumerable: true, get: function () { return releases_2.newer; } });
 const DAY = 24 * 60 * 60 * 1000;
-/** This package's version. */
-function installedVersion() {
+// Capture the running package before an installer replaces its files on disk.
+const PACKAGE = require('../package.json');
+const RUNNING = PACKAGE.version;
+function installedVersion() { return RUNNING; }
+/** Kept for callers needing only npm's latest version, with the same response bounds. */
+async function latestVersion(url = 'https://registry.npmjs.org/tabby-rdp/latest', timeoutMs = 15000, maxBytes = 256 * 1024) {
+    return String((await (0, releases_1.registryJSON)(url, timeoutMs, maxBytes))?.version ?? '');
+}
+function localStore() {
     try {
-        return require('../package.json').version;
+        return window.localStorage;
     }
     catch {
-        return '0.0.0';
+        return undefined;
     }
 }
-/** Whether `a` is a later release than `b` (x.y.z; a version with a pre-release part is never offered). */
-function newer(a, b) {
-    const parse = (v) => /^(\d+)\.(\d+)\.(\d+)$/.exec(v.trim())?.slice(1).map(Number);
-    const x = parse(a), y = parse(b);
-    if (!x || !y) {
-        return false;
+function hasPreferences(storage) {
+    try {
+        return typeof JSON.parse(storage?.getItem(releases_1.RELEASE_STATE_KEY) ?? 'null')?.paused === 'boolean';
     }
-    for (let i = 0; i < 3; i++) {
-        if (x[i] !== y[i]) {
-            return x[i] > y[i];
-        }
+    catch {
+        return false;
     }
-    return false;
 }
-/**
- * Tells about a newer tabby-rdp: Tabby only shows plugin upgrades while its Plugins page is open, and never on its own.
- * Once a day (and a little after Tabby starts) it asks npm for the latest version, and nothing else: no identifier,
- * no usage. A newer one gets a note, once per version, over the active pane; an "Update available" item in the
- * menus and a line on the settings page until it's installed. `remoteDesktop.checkUpdates` turns it off.
- */
-let UpdateCheck = class UpdateCheck {
-    constructor(config, app, help, platform, zone) {
+/** Daily, opt-out update notes; explicit package changes are handled by ReleaseManager. */
+let UpdateCheck = class UpdateCheck extends releases_1.ReleaseManager {
+    constructor(config, app, help, platform, zone, compat) {
+        const storage = localStore();
+        const migratePreferences = !hasPreferences(storage);
+        const dialog = new packageChangeDialog_1.PackageChangeDialog();
+        super({ running: RUNNING, policy: PACKAGE.tabbyRdp, tabby: compat.info.version ?? '', node: process.versions.node,
+            os: process.platform, cpu: process.arch, storage, fetchCatalog: releases_1.publishedVersions,
+            withLock: async (run) => {
+                if (!navigator.locks) {
+                    throw new Error('This Tabby cannot coordinate version changes between windows. Use Tabby Plugins.');
+                }
+                await navigator.locks.request('tabby-rdp.package-change', run);
+            },
+            diskVersion: () => {
+                try {
+                    return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '..', 'package.json'), 'utf8')).version;
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT') {
+                        return null;
+                    }
+                    throw error;
+                }
+            },
+            install: (name, version) => platform.installPlugin(name, version), uninstall: name => platform.uninstallPlugin(name),
+            confirm: (message, detail, action) => dialog.confirm(message, detail, action),
+            progress: state => dialog.update(state), }, !config.store || config.store.remoteDesktop?.checkUpdates === false);
         this.config = config;
         this.app = app;
         this.help = help;
         this.platform = platform;
         this.zone = zone;
-        /** The newer version, once one is known. */
-        this.available = null;
-        this.changed$ = new rxjs_1.Subject();
+        // Tabby can construct providers before ConfigService has loaded its store.
+        // Keep checks paused until ready, and migrate the old switch only without a saved local preference.
+        if (migratePreferences) {
+            const migrate = () => { void this.setPaused(config.store?.remoteDesktop?.checkUpdates === false); };
+            if (config.store) {
+                migrate();
+            }
+            else {
+                config.ready$.pipe((0, rxjs_1.take)(1)).subscribe(migrate);
+            }
+        }
+        window.addEventListener('storage', event => {
+            if (event.key === releases_1.RELEASE_STATE_KEY) {
+                this.zone.run(() => this.syncFromStorage());
+            }
+        });
     }
     start() {
         this.zone.runOutsideAngular(() => {
@@ -66,41 +105,26 @@ let UpdateCheck = class UpdateCheck {
             this.timer = setInterval(() => this.check().catch(() => null), DAY);
         });
     }
-    get enabled() {
-        return this.config.store.remoteDesktop?.checkUpdates !== false;
-    }
-    /** Asks npm for the latest version (or takes `latest`, for tests), and tells about it if it's newer. */
-    async check(latest) {
-        if (!this.enabled && latest === undefined) {
+    async check() {
+        if (this.state.paused) {
             return null;
         }
-        const version = latest ?? String((await (await fetch(REGISTRY, { cache: 'no-store' })).json())?.version ?? '');
+        await this.refreshCatalog();
         this.zone.run(() => {
-            this.available = newer(version, installedVersion()) ? version : null;
-            this.changed$.next();
             if (this.available) {
                 this.noteOnce(this.available);
             }
         });
         return this.available;
     }
-    /**
-     * Asks again now, when a version is known already: the settings page is where it's shown, and a Tabby left open for
-     * days would otherwise offer the version it found first, not the latest (meanaverage/tabby-rdp#17).
-     */
-    refresh() {
-        if (this.available && this.enabled) {
-            this.check().catch(() => null);
+    /** Opening Updates loads published versions even when ordinary prompts are paused. */
+    refresh() { void this.refreshCatalog(); }
+    upgrade() { this.help.open('updates'); }
+    whatsNew(version = this.available ?? this.running) {
+        if ((0, releases_1.releaseVersion)(version)) {
+            this.platform.openExternal(`${releases_1.RELEASES}/tag/v${version}`);
         }
     }
-    /** Settings › Plugins, where Tabby's Upgrade button is. */
-    upgrade() {
-        this.help.openSettings('plugins');
-    }
-    /** The release notes of the newer version. */
-    whatsNew() {
-        this.platform.openExternal(`${RELEASES}/tag/v${this.available ?? ''}`);
-    }
     /** A note over the active pane, once per version (then the menus and the settings page keep saying it). */
     noteOnce(version) {
         const store = this.config.store.remoteDesktop;
@@ -127,6 +151,5 @@ let UpdateCheck = class UpdateCheck {
 exports.UpdateCheck = UpdateCheck;
 exports.UpdateCheck = UpdateCheck = __decorate([
     (0, core_1.Injectable)({ providedIn: 'root' }),
-    __metadata("design:paramtypes", [tabby_core_1.ConfigService, tabby_core_1.AppService, help_1.RemoteDesktopHelp, tabby_core_1.PlatformService, core_1.NgZone])
+    __metadata("design:paramtypes", [tabby_core_1.ConfigService, tabby_core_1.AppService, help_1.RemoteDesktopHelp, tabby_core_1.PlatformService, core_1.NgZone, hostCompat_1.HostCompatibility])
 ], UpdateCheck);
-//# sourceMappingURL=updates.js.map

package/dist/vms.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanVMs = scanVMs;
 exports.vmSpec = vmSpec;
+const net_1 = require("net");
 const desktops_1 = require("./desktops");
 const hyperv_1 = require("./hyperv");
 /**
@@ -62,17 +63,21 @@ done
  * The host's VMs that have (or, being off, may have) a desktop: libvirt's running ones whose RDP answers, and Windows
  * ones that are off; on a Windows host, Hyper-V's. `host.windows` says the host is known to run Windows, and is set
  * when the scan finds out: such a host isn't asked for libvirt again (its shell takes a while to say it has no sh).
+ * `host.cut` says whether the list stopped at MAX_VMS (each VM is a menu item) with more there, so that the menu can
+ * say only so many are listed.
  */
 async function scanVMs(target, host = {}) {
     const out = host.windows ? '' : await target.exec('sh -s', SCAN_SCRIPT);
     // No sh answered: a Windows host (cmd.exe or PowerShell as its SSH shell), which is where Hyper-V is. Asked only
     // then, so that a Linux host costs nothing extra.
     if (!/^TRD_SH$/m.test(out)) {
-        const vms = await (0, hyperv_1.scanHyperV)(target);
+        const vms = await (0, hyperv_1.scanHyperV)(target, host);
         host.windows = true;
         return vms.map(vm => ({ hyperv: vm.id, name: vm.name, state: vm.state, windows: true, address: '', rdp: false }));
     }
     const found = [];
+    // Names seen so far: looked up, not searched for, so that the time taken grows with the lines, not their square.
+    const names = new Set();
     for (const line of out.split('\n')) {
         const m = /^TRD_VM ([^|]+)\|([^|]*)\|([^|]*)\|([^|]*)\|(\d*)\s*$/.exec(line.trim());
         if (!m) {
@@ -83,10 +88,20 @@ async function scanVMs(target, host = {}) {
         // Windows: RDP answering, or off (started when opened). Others: only xrdp (see XRDP_LIKE).
         const rdp = windows ? protocol !== '' : protocol === XRDP_LIKE;
         const vm = { name, state: state === 'running' ? 'running' : 'off', windows, address, rdp };
-        if (vm.address && (vm.rdp || vm.state === 'off' && vm.windows) && !found.some(f => f.name === vm.name)) {
+        // An IPv4 address, as the scan only ever finds: the address is part of the VM's session key, which is also the
+        // key its saved password is kept under. Anything else (`10.0.0.5:3389@gateway#gw.example`) could make that the
+        // key of a desktop configured behind this host, a password saved for its gateway included (see keyParts).
+        if ((0, net_1.isIPv4)(vm.address) && (vm.rdp || vm.state === 'off' && vm.windows) && !names.has(vm.name)) {
+            // One more than are listed: the list is cut short.
+            if (found.length === hyperv_1.MAX_VMS) {
+                host.cut = true;
+                return found;
+            }
+            names.add(vm.name);
             found.push(vm);
         }
     }
+    host.cut = false;
     return found;
 }
 /** A found VM as a desktop behind its host: started by name when it's off (see wake.ts). */
@@ -104,4 +119,3 @@ function vmSpec(vm) {
         found: vm.state,
     };
 }
-//# sourceMappingURL=vms.js.map

package/dist/wake.js

@@ -9,6 +9,7 @@ exports.wakeDesktop = wakeDesktop;
 exports.waitForRdp = waitForRdp;
 const deskScript_1 = require("./deskScript");
 const hyperv_1 = require("./hyperv");
+const osd_1 = require("./osd");
 const MAC = /^[0-9a-f]{2}([:-]?)[0-9a-f]{2}(\1[0-9a-f]{2}){4}$/i;
 const IPV4 = /^\d{1,3}(\.\d{1,3}){3}$/;
 /** A `wake` config value, checked; undefined when absent or unusable. */
@@ -21,7 +22,7 @@ function parseWake(raw) {
     }
     const mac = typeof raw?.mac === 'string' ? raw.mac.trim() : '';
     if (MAC.test(mac)) {
-        const port = Number(raw.port ?? 9);
+        const port = (0, osd_1.configNumber)(raw.port ?? 9);
         return {
             mac,
             ...typeof raw.broadcast === 'string' && IPV4.test(raw.broadcast.trim()) ? { broadcast: raw.broadcast.trim() } : {},
@@ -98,11 +99,13 @@ const IDLE_SCRIPT = String.raw `
 command -v virsh >/dev/null 2>&1 || { echo "RD_ERR virsh is not installed on the SSH host"; exit 0; }
 command -v ss >/dev/null 2>&1 || { echo "RD_ERR ss (iproute2) is not installed on the SSH host"; exit 0; }
 # The pid file: with the plugin's other files, or where the home folder isn't writable, in a folder of its own in /tmp.
+# Private either way, as the desktop's setup keeps it (this may be the first to make it).
 D="$HOME/.local/share/tabby-rdp"
-if ! mkdir -p "$D" 2>/dev/null; then
+if ! { mkdir -p "$D" && chmod 700 "$D"; } 2>/dev/null; then
     D="/tmp/tabby-rdp-$(id -u)"
     mkdir -p -m 700 "$D" 2>/dev/null
-    [ -d "$D" ] && [ -O "$D" ] && [ ! -L "$D" ] || { echo "RD_ERR could not create a folder for the watcher's pid file"; exit 0; }
+    # One that was there already keeps its mode (mkdir -m only sets one it makes): made private here, or not used.
+    [ -d "$D" ] && [ -O "$D" ] && [ ! -L "$D" ] && chmod 700 "$D" 2>/dev/null || { echo "RD_ERR could not create a folder for the watcher's pid file"; exit 0; }
 fi
 PIDF="$D/idle-$(printf %s "$VM" | tr -c 'A-Za-z0-9._-' _).pid"
 if [ -s "$PIDF" ] && kill -0 "$(cat "$PIDF")" 2>/dev/null; then
@@ -114,8 +117,11 @@ for u in qemu:///system qemu:///session; do
 done
 [ -n "$URI" ] || { echo "RD_ERR $VM is not running"; exit 0; }
 A=$(getent ahostsv4 "$H" 2>/dev/null | awk 'NR == 1 { print $1 }')
+# The watcher writes its pid file anew (umask 077): one left by an earlier version keeps its mode otherwise.
+rm -f "$PIDF"
 nohup setsid sh -c '
 VM=$1 URI=$2 A=$3 P=$4 IDLE=$5 PIDF=$6
+umask 077
 echo $$ > "$PIDF"
 trap "rm -f \"$PIDF\"" EXIT
 idle=0 asked=0
@@ -143,11 +149,12 @@ echo "RD_OK $VM shuts down after $((IDLE / 60)) min without a desktop open ($URI
  */
 async function shutDownWhenIdle(target, vm, host, port, idleSeconds) {
     const out = await target.exec('sh -s', `VM=${(0, deskScript_1.shq)(vm)}\nH=${(0, deskScript_1.shq)(host)}\nP=${port}\nIDLE=${Math.max(1, Math.round(idleSeconds / 30)) * 30}\n${IDLE_SCRIPT}`);
-    const err = /^RD_ERR (.*)$/m.exec(out);
+    // The host's words, as much of them as the log shows: the host decides how long its lines are.
+    const err = /^RD_ERR (.{0,1000})/m.exec(out);
     if (err) {
         throw new Error(err[1].trim());
     }
-    return /^RD_OK (.*)$/m.exec(out)?.[1] ?? 'no result';
+    return /^RD_OK (.{0,1000})/m.exec(out)?.[1] ?? 'no result';
 }
 /** Whether the RDP server at host:port answers, as seen from the SSH host. */
 async function rdpAnswers(target, host, port) {
@@ -167,11 +174,12 @@ async function wakeDesktop(target, wake) {
         ? `VM=${(0, deskScript_1.shq)(wake.vm)}\n${VM_SCRIPT}`
         : `MAC=${(0, deskScript_1.shq)(wake.mac)}\nBCAST=${(0, deskScript_1.shq)(wake.broadcast ?? '255.255.255.255')}\nPORT=${wake.port ?? 9}\n${WOL_SCRIPT}`;
     const out = await target.exec('sh -s', script);
-    const err = /^RD_ERR (.*)$/m.exec(out);
+    // The host's words, as much of them as a status line shows (see shutDownWhenIdle).
+    const err = /^RD_ERR (.{0,1000})/m.exec(out);
     if (err) {
         throw new Error(err[1].trim());
     }
-    return /^RD_OK (.*)$/m.exec(out)?.[1] ?? 'no result';
+    return /^RD_OK (.{0,1000})/m.exec(out)?.[1] ?? 'no result';
 }
 /**
  * Probes until the desktop is up (true; see desktopUp), the time is up or `stopped()` (false). At most one probe
@@ -194,4 +202,3 @@ async function waitForRdp(target, host, port, timeoutMs, stopped, progress, wake
         clearInterval(ticker);
     }
 }
-//# sourceMappingURL=wake.js.map