tabby-rdp 0.4.1 → 0.5.1

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,8 +51,13 @@ 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.
+                unicodeKeys: false,
                 // Play the remote desktop's sound (applies on the next connect).
                 sound: true,
                 // H.264 in the graphics pipeline, decoded by the browser, where it can (applies on the next connect).
@@ -58,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
@@ -67,8 +79,19 @@ let RemoteDesktopConfig = class RemoteDesktopConfig extends tabby_core_1.ConfigP
                 accounts: [],
                 // Sharpness for particular desktops, overriding `sharpness`: [{ desktop: <session key>, sharpness }].
                 desktopSharpness: [],
-                // Certificates of desktops behind hosts, trusted on first use: [{ desktop: <session key>, sha256 }].
+                // Folders shared with remote desktops as drives (\\tsclient\<name>): [{ path, name, readOnly }]; see drives.ts.
+                sharedFolders: [],
+                // 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).
@@ -81,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 = {
@@ -110,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',
@@ -146,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) },
     ];
 }
@@ -193,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)) {
@@ -252,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,
@@ -264,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() },
@@ -300,16 +358,37 @@ 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)',
             checked: current.connectionStatus,
             click: () => desktop.updateSettings({ connectionStatus: !current.connectionStatus }),
         },
+        {
+            type: 'checkbox',
+            label: 'Send text as typed (characters rather than key positions: dead keys, other layouts)',
+            checked: current.unicodeKeys,
+            click: () => desktop.updateSettings({ unicodeKeys: !current.unicodeKeys }),
+        },
         ...process.platform === 'darwin' ? [{
                 type: 'checkbox',
                 label: 'Mac shortcuts on the remote desktop (⌘C, ⌘V, ⌘Z… act as Ctrl+C, Ctrl+V…; off: ⌘ is the Windows key)',
@@ -321,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),
             })),
         },
     ];
@@ -390,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

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateCheck = void 0;
+exports.latestVersion = latestVersion;
 exports.installedVersion = installedVersion;
 exports.newer = newer;
 const core_1 = require("@angular/core");
@@ -20,6 +21,41 @@ const targets_1 = require("./targets");
 const REGISTRY = 'https://registry.npmjs.org/tabby-rdp/latest';
 const RELEASES = 'https://github.com/meanaverage/tabby-rdp/releases';
 const DAY = 24 * 60 * 60 * 1000;
+/**
+ * The latest version's number, as npm says, from an answer read for `timeoutMs` and up to `maxBytes` at most (it is
+ * that version's package.json, a few KB): whoever answers in npm's name (a proxy that inspects TLS, say) could
+ * otherwise keep the request waiting for good, or fill Tabby's memory.
+ */
+async function latestVersion(url = REGISTRY, timeoutMs = 15000, maxBytes = 256 * 1024) {
+    const abort = new AbortController();
+    const timer = setTimeout(() => abort.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, { cache: 'no-store', signal: abort.signal });
+        if (!response.body) {
+            throw new Error(`the registry answered ${response.status} with nothing`);
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            size += value.byteLength;
+            if (size > maxBytes) {
+                throw new Error('the registry\'s answer is too large');
+            }
+            chunks.push(value);
+        }
+        return String(JSON.parse(Buffer.concat(chunks).toString('utf8'))?.version ?? '');
+    }
+    finally {
+        clearTimeout(timer);
+        // Ends the request, if it is still going (an answer too large).
+        abort.abort();
+    }
+}
 /** This package's version. */
 function installedVersion() {
     try {
@@ -74,7 +110,7 @@ let UpdateCheck = class UpdateCheck {
         if (!this.enabled && latest === undefined) {
             return null;
         }
-        const version = latest ?? String((await (await fetch(REGISTRY, { cache: 'no-store' })).json())?.version ?? '');
+        const version = latest ?? await latestVersion();
         this.zone.run(() => {
             this.available = newer(version, installedVersion()) ? version : null;
             this.changed$.next();
@@ -129,4 +165,3 @@ 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])
 ], UpdateCheck);
-//# sourceMappingURL=updates.js.map

package/dist/vms.js

@@ -2,6 +2,9 @@
 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");
 /**
  * RDP security the server chose when offered TLS and NLA (RDP_NEG_RSP): Windows and GNOME Remote Desktop take NLA
  * (2), xrdp only TLS (1). A Linux VM that takes NLA is GNOME's, whose sign-in the plugin manages over SSH to that VM:
@@ -14,6 +17,7 @@ const XRDP_LIKE = '1';
 // wake.ts) within a second; the protocol the server chose, or 0 without a negotiation response ('' if none).
 // Read-only: starts nothing, changes nothing.
 const SCAN_SCRIPT = String.raw `
+echo TRD_SH
 command -v virsh >/dev/null 2>&1 || exit 0
 probe () {
     if command -v python3 >/dev/null 2>&1; then
@@ -55,10 +59,25 @@ for uri in qemu:///system qemu:///session; do
     done
 done
 `;
-/** The host's VMs that have (or, being off, may have) a desktop: running ones whose RDP answers, and Windows ones that are off. */
-async function scanVMs(target) {
-    const out = await target.exec('sh -s', SCAN_SCRIPT);
+/**
+ * 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, 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) {
@@ -69,14 +88,27 @@ async function scanVMs(target) {
         // 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). */
 function vmSpec(vm) {
+    if (vm.hyperv) {
+        return (0, desktops_1.hyperVSpec)(vm.hyperv, vm.name, { found: vm.state });
+    }
     return {
         id: `${vm.address}:3389`,
         name: vm.name,
@@ -87,4 +119,3 @@ function vmSpec(vm) {
         found: vm.state,
     };
 }
-//# sourceMappingURL=vms.js.map

package/dist/wake.js

@@ -4,19 +4,25 @@ exports.parseWake = parseWake;
 exports.wakeFromText = wakeFromText;
 exports.shutDownWhenIdle = shutDownWhenIdle;
 exports.rdpAnswers = rdpAnswers;
+exports.desktopUp = desktopUp;
 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. */
 function parseWake(raw) {
+    if ((0, hyperv_1.vmId)(raw?.hyperv)) {
+        return { hyperv: (0, hyperv_1.vmId)(raw.hyperv) };
+    }
     if (typeof raw?.vm === 'string' && raw.vm.trim()) {
         return { vm: raw.vm.trim() };
     }
     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() } : {},
@@ -93,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
@@ -109,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
@@ -138,40 +149,49 @@ 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) {
     const out = await target.exec('sh -s', `H=${(0, deskScript_1.shq)(host)}\nP=${port}\n${PROBE_SCRIPT}`);
     return /^RD_OPEN$/m.test(out);
 }
+/** Whether the desktop is up: its RDP server answers, or, for a Hyper-V VM (reached through its host), it runs. */
+async function desktopUp(target, host, port, wake) {
+    return wake && 'hyperv' in wake ? (await (0, hyperv_1.hyperVState)(target, wake.hyperv)).running : rdpAnswers(target, host, port);
+}
 /** Starts the desktop as `wake` says. Resolves with what was done; throws with the reason when it couldn't. */
 async function wakeDesktop(target, wake) {
+    if ('hyperv' in wake) {
+        return (0, hyperv_1.startHyperV)(target, wake.hyperv);
+    }
     const script = 'vm' in 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 RDP server answers (true), the time is up or `stopped()` (false). At most one probe every
- * 3 s; `progress` is called every 5 s.
+ * Probes until the desktop is up (true; see desktopUp), the time is up or `stopped()` (false). At most one probe
+ * every 3 s; `progress` is called every 5 s.
  */
-async function waitForRdp(target, host, port, timeoutMs, stopped, progress) {
+async function waitForRdp(target, host, port, timeoutMs, stopped, progress, wake) {
     const deadline = Date.now() + timeoutMs;
     const ticker = setInterval(() => stopped() || progress(), 5000);
     try {
         while (Date.now() < deadline && !stopped()) {
             const started = Date.now();
-            if (await rdpAnswers(target, host, port).catch(() => false)) {
+            if (await desktopUp(target, host, port, wake).catch(() => false)) {
                 return !stopped();
             }
             await new Promise(resolve => setTimeout(resolve, Math.max(0, 3000 - (Date.now() - started))));
@@ -182,4 +202,3 @@ async function waitForRdp(target, host, port, timeoutMs, stopped, progress) {
         clearInterval(ticker);
     }
 }
-//# sourceMappingURL=wake.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabby-rdp",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Remote desktops in Tabby's SSH tabs: Linux (GNOME) and Windows, through the SSH connection, with clipboard, files and sound. Built on IronRDP.",
   "keywords": [
     "tabby-plugin",
@@ -26,6 +26,7 @@
   "main": "dist/index.js",
   "files": [
     "dist",
+    "!dist/**/*.map",
     "vendor",
     "remote",
     "LICENSE",
@@ -36,7 +37,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "watch": "tsc -p tsconfig.json --watch",
+    "watch": "tsc -p tsconfig.json --watch --sourceMap",
     "typecheck": "tsc -p tsconfig.json --noEmit && npm run typecheck:test",
     "typecheck:test": "tsc -p tsconfig.test.json",
     "test": "tsx test/run.ts",
@@ -45,7 +46,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "ws": "^8.18.0"
+    "ws": "^8.21.1"
   },
   "devDependencies": {
     "@angular/core": "15.2.10",