tabby-rdp 0.5.0 → 0.5.1

package/dist/help.js

@@ -36,12 +36,26 @@ exports.SETTINGS_TAB_ID = 'remote-desktop';
 exports.TROUBLESHOOTING = [
     {
         id: 'certificate',
-        title: 'The certificate has changed',
+        title: 'A certificate this computer can\'t verify, or one that has changed',
         match: /certificate/i,
-        body: `The first connection to a Windows or xrdp desktop remembers its certificate. When a later one differs, the
-            plugin stops before signing in, so nothing (no password) has been sent. Reinstalling the machine or renewing its
-            certificate changes it: then choose <b>Trust the new certificate</b>. If neither happened, something else is
-            answering at that address. A GNOME desktop only ever accepts the certificate the plugin made for it; a
+        body: `A desktop you connect to directly (a remote desktop profile, an imported file) and an RD Gateway connect
+            without asking when their certificate is valid for their name by this computer's certificate authorities, as
+            an organisation's own desktops and gateways often are. Any other is shown the first time, with why it can't
+            be verified (most often: it is the server's own, self-signed) and its fingerprint, before anything of your
+            sign-in is sent: check the fingerprint with whoever runs it, some other way than this connection (it is in the
+            desktop's log too, which <b>Copy log</b> under Open desktops below copies), then choose <b>Trust the
+            certificate</b>. The question also says whom the certificate says it was issued to and by, and when it is
+            valid: its own word, which nothing has checked, unless its chain leads to an authority this computer trusts
+            (another machine's certificate then shows that machine's name) and the TLS library didn't refuse it for a
+            reason of its own (a limit set on the authority, say). An issuer you wouldn't expect there (one
+            that inspects your network's connections, say) is worth asking about before you trust it, but the one you
+            would expect proves nothing: anyone can make a certificate that names it. Only the fingerprint, checked some
+            other way, does. A desktop behind an SSH host remembers its certificate on first use without asking, since
+            the way there runs inside SSH. When a remembered certificate differs later, the plugin stops before signing
+            in, so nothing of your sign-in has gone to that server; only a certificate an authority vouched for is
+            replaced without a question, by another it vouches for too. Reinstalling the machine or renewing its
+            certificate changes it: then choose <b>Trust the new certificate</b>. If neither happened, something else
+            is answering at that address. A GNOME desktop only ever accepts the certificate the plugin made for it; a
             different one there means another program listens on its port. Remembered certificates are listed above.`,
     },
     {
@@ -94,15 +108,21 @@ exports.TROUBLESHOOTING = [
         body: `Sound and microphone changes apply on the next connection. xrdp needs <code>pipewire-module-xrdp</code> or
             <code>pulseaudio-module-xrdp</code>. The microphone needs the system's permission here (macOS: System Settings ›
             Privacy &amp; Security › Microphone, then restart Tabby). On GNOME, apps record from "Remoteaudio Source"; on
-            Windows, the machine must allow audio recording redirection.`,
+            Windows, the machine must allow audio recording redirection. A desktop whose microphone was stopped (<b>Stop</b>
+            in the microphone's menu in Tabby's header, or <b>Send the microphone</b> unchecked in the desktop's menu) gets
+            none, its reconnects included, until <b>Send the microphone</b> is checked again in its menu or that Tabby window is closed.`,
     },
     {
         id: 'nested-ssh',
         title: 'I typed ssh to another machine in a terminal',
         body: `In an SSH tab (or a split pane) where you typed <code>ssh</code> on to another machine, <b>Desktop</b> opens that
-            machine's desktop, going through the first one, and <code>desk</code> works there too. The first machine has to
-            log in to the other by itself for this: with a key there, or agent forwarding, as <code>ssh -o BatchMode=yes</code>
-            would. Tabby's <b>Reconnect</b> belongs to the tab: it reconnects the first machine and ends the ssh typed in it.
+            machine's desktop, going through the first one, and <code>desk</code> works there too. Desktop asks which desktop
+            you mean, since which <code>ssh</code> runs there is the first machine's to say; pick the other machine's
+            "from now on" to have it open at once the next times. Desktops you set up behind a host open in a tab connected
+            to that host, not through another one.
+            The first machine has to log in to the other by itself for this: with a key there, or agent forwarding, as
+            <code>ssh -o BatchMode=yes</code> would. Tabby's <b>Reconnect</b> belongs to the tab: it reconnects the first
+            machine and ends the ssh typed in it.
             To have both desktops side by side, open the first machine's desktop in one pane, and ssh on in the other.`,
     },
     {
@@ -127,13 +147,15 @@ const esc = (s) => String(s ?? '').replace(/[&<>"']/g, c => `&#${c.charCodeAt(0)
 exports.esc = esc;
 function hotkeyLabel(binding) {
     const first = Array.isArray(binding) ? binding[0] : null;
-    const strokes = Array.isArray(first) ? first : typeof first === 'string' ? [first] : [];
+    // Text only: the config may hold anything, and this runs for the settings page and the first-connect tip.
+    const strokes = (Array.isArray(first) ? first : [first]).filter((s) => typeof s === 'string');
     if (!strokes.length) {
         return null;
     }
     const mac = process.platform === 'darwin';
-    const MAC = { Shift: '⇧', Alt: '⌥', Ctrl: '⌃', Meta: '⌘', Cmd: '⌘' };
-    return strokes.map(s => s.split('-').map(k => mac ? MAC[k] ?? k : k).join(mac ? '' : '+')).join(', ');
+    // A Map, not an object literal: a part named 'constructor' or 'toString' would find what objects inherit.
+    const MAC = new Map([['Shift', '⇧'], ['Alt', '⌥'], ['Ctrl', '⌃'], ['Meta', '⌘'], ['Cmd', '⌘']]);
+    return strokes.map(s => s.split('-').map(k => mac ? MAC.get(k) ?? k : k).join(mac ? '' : '+')).join(', ');
 }
 const TIP_STYLE = `
 .trd-tip { position: absolute; left: 50%; bottom: 16px; transform: translateX(-50%); z-index: 2; max-width: min(560px, 90%);
@@ -260,4 +282,3 @@ exports.RemoteDesktopHelp = RemoteDesktopHelp = __decorate([
     (0, core_1.Injectable)({ providedIn: 'root' }),
     __metadata("design:paramtypes", [tabby_core_1.AppService, tabby_core_1.ConfigService, core_1.NgZone])
 ], RemoteDesktopHelp);
-//# sourceMappingURL=help.js.map

package/dist/hyperv.js

@@ -1,16 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HYPERV_PORT = void 0;
+exports.MAX_VMS = exports.HYPERV_PORT = void 0;
 exports.vmId = vmId;
 exports.scanHyperV = scanHyperV;
 exports.hyperVState = hyperVState;
 exports.startHyperV = startHyperV;
 /** VMConnect's port on a Hyper-V host. */
 exports.HYPERV_PORT = 2179;
+/**
+ * How many VMs a host's scan lists at most (see vms.ts too). Each is a menu item, and an answer of the host's making
+ * could otherwise make thousands of them. A host can have more (a Hyper-V server can run 1,024): the first ones are
+ * listed, and the menu says that only so many are (see RemoteDesktopService.vmsCut).
+ */
+exports.MAX_VMS = 256;
 const GUID = /^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
 /** A VM id as Hyper-V prints it, or '' if this isn't one. */
 function vmId(value) {
-    const id = String(value ?? '').trim().replace(/^\{|\}$/g, '');
+    // Text only: String() of an object from the config runs its own conversions, which can throw.
+    const id = (typeof value === 'string' ? value : '').trim().replace(/^\{|\}$/g, '');
     return GUID.test(id) ? id.toLowerCase() : '';
 }
 /**
@@ -27,19 +34,63 @@ const SCAN = String.raw `
 $ErrorActionPreference = 'SilentlyContinue'
 if (Get-Command Get-VM) { Get-VM | ForEach-Object { 'TRD_HV ' + $_.Id + '|' + $_.State + '|' + $_.Name } }
 `;
-/** The host's Hyper-V VMs, running or not (one that is off is started when opened). Read-only. */
-async function scanHyperV(target) {
+/**
+ * A line of the scan's answer longer than this is none of its own: its id and state take some 50 characters, and
+ * Hyper-V keeps a VM's name to 100.
+ */
+const MAX_LINE = 1024;
+/**
+ * A line of the scan's answer, `TRD_HV <id>|<state>|<name>` (the name may hold bars), as a VM; null for any other line.
+ * Read by where its bars are, not with a pattern whose parts can take the same characters: a long line of the host's
+ * making could make that cost the square of its length.
+ */
+function scannedVM(raw) {
+    const line = raw.length > MAX_LINE ? '' : raw.trim();
+    const first = line.indexOf('|');
+    const second = first < 0 ? -1 : line.indexOf('|', first + 1);
+    if (!line.startsWith('TRD_HV ') || second < 0) {
+        return null;
+    }
+    const id = vmId(line.slice('TRD_HV '.length, first));
+    const name = line.slice(second + 1);
+    // A name on one line, as PowerShell prints it.
+    if (!id || !name || /[\r\u2028\u2029]/.test(name)) {
+        return null;
+    }
+    return { id, name, state: line.slice(first + 1, second) === 'Running' ? 'running' : 'off' };
+}
+/**
+ * The host's Hyper-V VMs, running or not (one that is off is started when opened), MAX_VMS at most; `listed.cut` says
+ * whether the host has more. Read-only.
+ */
+async function scanHyperV(target, listed = {}) {
     const out = await powershell(target, SCAN);
     const found = [];
+    listed.cut = false;
+    // Ids seen so far: looked up, not searched for, so that the time taken grows with the lines, not their square.
+    const ids = new Set();
     for (const line of out.split('\n')) {
-        const m = /^TRD_HV ([^|]+)\|([^|]*)\|(.+?)\s*$/.exec(line.trim());
-        const id = vmId(m?.[1]);
-        if (m && id && !found.some(f => f.id === id)) {
-            found.push({ id, name: m[3], state: m[2] === 'Running' ? 'running' : 'off' });
+        const vm = scannedVM(line);
+        if (vm && !ids.has(vm.id)) {
+            // One more than are listed: the list is cut short.
+            if (found.length === exports.MAX_VMS) {
+                listed.cut = true;
+                break;
+            }
+            ids.add(vm.id);
+            found.push(vm);
         }
     }
     return found;
 }
+/**
+ * What follows `prefix` on each line of the host's answer that starts with it, trimmed, and MAX_LINE characters of it
+ * at most (the host's reason for an error is shown as it is). Line by line: a pattern run over the whole answer can
+ * match across its lines, which a long answer of the host's making can make cost the square of its length.
+ */
+function linesAfter(out, prefix) {
+    return out.split('\n').map(line => line.trim()).filter(line => line.startsWith(prefix)).map(line => line.slice(prefix.length).trim().slice(0, MAX_LINE));
+}
 // TRD_HV_STATE <state>|<enhanced session mode state>, or TRD_HV_ERR <why>. The enhanced state is
 // Msvm_ComputerSystem's: 2 when the guest takes enhanced sessions right now (the host allows them, and the guest's
 // Remote Desktop Services answer on its bus), anything else when only the basic console is there.
@@ -53,9 +104,9 @@ try {
 /** How a VM is now: running or not, and whether it takes an enhanced session. Throws with the host's reason when it can't say. */
 async function hyperVState(target, id) {
     const out = await powershell(target, STATE.replace('@@ID@@', vmId(id)));
-    const state = /^TRD_HV_STATE ([^|]*)\|(\d*)\s*$/m.exec(out);
+    const state = linesAfter(out, 'TRD_HV_STATE ').map(line => /^([^|]*)\|(\d*)$/.exec(line)).find(Boolean);
     if (!state) {
-        throw new Error(/^TRD_HV_ERR (.*)$/m.exec(out)?.[1].trim() || 'the host didn\'t answer about the VM (is PowerShell\'s Hyper-V module there, and may this account use it?)');
+        throw new Error(linesAfter(out, 'TRD_HV_ERR ')[0] || 'the host didn\'t answer about the VM (is PowerShell\'s Hyper-V module there, and may this account use it?)');
     }
     return { running: state[1] === 'Running', enhanced: state[2] === '2' };
 }
@@ -70,10 +121,9 @@ try {
 /** Starts (or resumes) the VM. Resolves with what was done; throws with the host's reason when it couldn't. */
 async function startHyperV(target, id) {
     const out = await powershell(target, START.replace('@@ID@@', vmId(id)));
-    const ok = /^TRD_HV_OK (.*)$/m.exec(out);
-    if (!ok) {
-        throw new Error(/^TRD_HV_ERR (.*)$/m.exec(out)?.[1].trim() || 'the host didn\'t answer');
+    const ok = linesAfter(out, 'TRD_HV_OK ');
+    if (!ok.length) {
+        throw new Error(linesAfter(out, 'TRD_HV_ERR ')[0] || 'the host didn\'t answer');
     }
-    return ok[1].trim();
+    return ok[0];
 }
-//# sourceMappingURL=hyperv.js.map

package/dist/index.js

@@ -49,7 +49,8 @@ let RemoteDesktopModule = class RemoteDesktopModule {
             'remote-desktop-disconnect': pane => desktop.disconnect(pane),
         };
         hotkeys.hotkey$.subscribe((id) => {
-            const action = actions[id];
+            // Tabby fires any key bound under `hotkeys` in the config ('constructor' too): the table's own entries only.
+            const action = Object.prototype.hasOwnProperty.call(actions, id) ? actions[id] : undefined;
             const pane = action && (0, targets_1.desktopPaneOf)(app.activeTab);
             if (!action || !pane) {
                 return;
@@ -85,4 +86,3 @@ RemoteDesktopModule = __decorate([
     __metadata("design:paramtypes", [tabby_core_1.AppService, tabby_core_1.HotkeysService, desktop_service_1.RemoteDesktopService, header_1.HeaderControls, targets_1.RemoteTargets, keyboard_1.DesktopKeyboard, core_1.Injector])
 ], RemoteDesktopModule);
 exports.default = RemoteDesktopModule;
-//# sourceMappingURL=index.js.map

package/dist/keyboard.js

@@ -276,4 +276,3 @@ exports.DesktopKeyboard = DesktopKeyboard = __decorate([
         desktop_service_1.RemoteDesktopService,
         core_1.NgZone])
 ], DesktopKeyboard);
-//# sourceMappingURL=keyboard.js.map

package/dist/microphone.js

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Resampler = exports.Microphone = void 0;
 /**
- * Redirects the local microphone to a remote desktop (IronRDP's `audioInput` extension). The server asks for it
- * only while an application there records: IronRDP says `open` (with the format the server chose) and `close`, and
- * the microphone is captured only in between. The browser's capture runs at the audio device's rate; it is resampled
- * and converted to interleaved 16-bit PCM here, in blocks of about 20 ms.
+ * Redirects the local microphone to a remote desktop (IronRDP's `audioInput` extension). The server asks for it when it
+ * likes (by its own account, while an application there records): IronRDP says `open` (with the format the server
+ * chose) and `close`, and the microphone is captured only in between. The browser's capture runs at the audio device's
+ * rate; it is resampled and converted to interleaved 16-bit PCM here, in blocks of about 20 ms.
  *
  * It keeps capturing while the desktop layer is hidden: the remote application is still recording (a call, say), and
- * the console being in front doesn't mean the user stopped talking to it. The system shows its own microphone
- * indicator meanwhile.
+ * the console being in front doesn't mean the user stopped talking to it. What the remote does with it is out of
+ * sight then, so it shows elsewhere (see RemoteDesktopService.microphoneChanged): a red microphone in Tabby's header
+ * for as long as it lasts, and a note when a capture starts on a desktop that isn't showing. turnOff() stops it here,
+ * and turnOn() takes the remote's requests again.
  */
 class Microphone {
     /**
@@ -37,6 +39,8 @@ class Microphone {
         this.starting = false;
         this.resampler = null;
         this.reportedError = false;
+        /** Turned off here (see turnOff): the remote's requests are refused for the rest of the connection. */
+        this.off = false;
         /** The callback for IronRDP's audioInput extension. */
         this.callback = (message) => {
             try {
@@ -49,6 +53,10 @@ class Microphone {
                     }
                     this.format = { sampleRate, channels };
                     this.log(`microphone: the remote opened it (${sampleRate} Hz, ${channels === 1 ? 'mono' : 'stereo'})`);
+                    if (this.off) {
+                        this.log('microphone: not sent: turned off here');
+                        return;
+                    }
                     this.start().catch(e => this.failed(e));
                 }
                 else if (message?.type === 'close') {
@@ -74,8 +82,8 @@ class Microphone {
         finally {
             this.starting = false;
         }
-        // Closed and opened again while starting: that start was dropped, so start over.
-        if (!this.stream && this.format) {
+        // Closed and opened again while starting: that start was dropped, so start over (unless turned off meanwhile).
+        if (!this.stream && this.format && !this.off) {
             await this.start();
         }
     }
@@ -100,28 +108,42 @@ class Microphone {
         let capture;
         try {
             await context.audioWorklet.addModule(workletURL());
+            if (generation !== this.generation) {
+                return; // closed meanwhile: stop() released the stream and closed the context, which takes no new nodes
+            }
             const node = new AudioWorkletNode(context, 'trd-microphone', { numberOfInputs: 1, numberOfOutputs: 1, outputChannelCount: [1] });
-            node.port.onmessage = event => this.captured(event.data, context.sampleRate);
+            node.port.onmessage = event => {
+                // A block the worklet posted before the capture stopped can still arrive after it: dropped, not sent.
+                if (generation === this.generation) {
+                    this.captured(event.data, context.sampleRate);
+                }
+            };
             capture = node;
         }
         catch (e) {
+            if (generation !== this.generation) {
+                return; // closed meanwhile, which may be why the module was refused: as above, and not an error
+            }
             // No AudioWorklet (or its module was refused): the deprecated ScriptProcessor does the same on the main thread.
             this.log(`microphone: AudioWorklet unavailable (${e?.message ?? e}), using ScriptProcessor`);
             const node = context.createScriptProcessor(1024, 2, 1);
             node.onaudioprocess = event => {
+                if (generation !== this.generation) {
+                    return; // stopped: as above
+                }
                 const input = event.inputBuffer;
                 this.captured(Array.from({ length: input.numberOfChannels }, (_, i) => input.getChannelData(i).slice()), context.sampleRate);
             };
             capture = node;
         }
-        if (generation !== this.generation) {
-            return; // closed meanwhile: stop() released the stream and the context
-        }
         source.connect(capture);
         capture.connect(mute);
         this.nodes = [source, capture, mute];
         if (context.state === 'suspended') {
             await context.resume().catch(() => null);
+            if (generation !== this.generation) {
+                return; // closed or turned off while resuming: stop() released everything, and it isn't capturing
+            }
         }
         const track = stream.getAudioTracks()[0];
         this.log(`microphone: capturing from ${track?.label || 'the default input'} at ${context.sampleRate} Hz`);
@@ -188,6 +210,29 @@ class Microphone {
             this.changed();
         }
     }
+    /**
+     * Turned off here (the setting, or Stop for this desktop): stops capturing at once, also a capture still starting,
+     * and refuses the remote's later requests on this connection. Whether the next connection gets the microphone is
+     * the service's to say (see RemoteDesktopService.stopMicrophone).
+     */
+    turnOff() {
+        if (!this.off) {
+            this.off = true;
+            this.log('microphone: turned off here');
+        }
+        this.stop();
+    }
+    /** Turned on again here (the desktop's menu): the remote's requests are taken again, one open now included. */
+    turnOn() {
+        if (!this.off) {
+            return;
+        }
+        this.off = false;
+        this.log('microphone: turned on again here');
+        if (this.format) {
+            this.start().catch(e => this.failed(e));
+        }
+    }
     /** The connection ended. */
     close() {
         this.format = null;
@@ -292,4 +337,3 @@ function workletURL() {
     workletBlobURL ??= URL.createObjectURL(new Blob([WORKLET], { type: 'application/javascript' }));
     return workletBlobURL;
 }
-//# sourceMappingURL=microphone.js.map

package/dist/ntlm.js

@@ -223,4 +223,3 @@ function authenticateMessage(negotiate, challenge, account) {
     }
     return message;
 }
-//# sourceMappingURL=ntlm.js.map

package/dist/osd.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OSD_STYLE = exports.OSD_DEFAULTS = exports.OSD_POSITIONS = exports.OSD_SIZES = exports.OSD_FONTS = void 0;
+exports.osdColor = osdColor;
+exports.configNumber = configNumber;
 exports.osdSettings = osdSettings;
 exports.renderOsd = renderOsd;
 /** Font stacks: macOS's, then Windows' (Bahnschrift) and common Linux ones, then any sans-serif. */
@@ -15,16 +17,35 @@ exports.OSD_FONTS = {
 exports.OSD_SIZES = { small: 28, medium: 44, large: 60, huge: 80 };
 exports.OSD_POSITIONS = ['top-left', 'top-center', 'top-right', 'middle', 'bottom-left', 'bottom-center', 'bottom-right'];
 exports.OSD_DEFAULTS = { show: 'auto', font: 'condensed', size: 'medium', position: 'top-right', color: '', seconds: 2.5 };
+/** Whether `key` is one of the table's own entries: 'constructor' or '__proto__' from the config are no font or size. */
+function isOwn(table, key) {
+    return typeof key === 'string' && Object.prototype.hasOwnProperty.call(table, key);
+}
+/**
+ * A color from the config, or '' for the default. Only plain colors: a name, #hex, or a color function of numbers.
+ * CSS.supports alone isn't enough: a value with var() passes it whatever follows (`var(--x, red)"><img …>`).
+ */
+function osdColor(value) {
+    const plain = typeof value === 'string' && /^(#[0-9a-f]{3,8}|[a-z]+|(rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\([\w\s.,%/+-]*\))$/i.test(value);
+    return plain && CSS.supports('color', value) ? value : '';
+}
+/**
+ * A number from the config, or NaN: only from a number or a string. Number() of an object calls its own conversions,
+ * and a config can hold an object whose `valueOf` and `toString` aren't functions, which makes it throw.
+ */
+function configNumber(value) {
+    return typeof value === 'number' || typeof value === 'string' ? Number(value) : NaN;
+}
 /** The config value, with anything missing or unknown replaced by the default. */
 function osdSettings(value) {
     const v = value && typeof value === 'object' ? value : {};
-    const seconds = Number(v.seconds);
+    const seconds = configNumber(v.seconds);
     return {
         show: ['auto', 'always', 'off'].includes(v.show) ? v.show : exports.OSD_DEFAULTS.show,
-        font: v.font in exports.OSD_FONTS ? v.font : exports.OSD_DEFAULTS.font,
-        size: v.size in exports.OSD_SIZES ? v.size : exports.OSD_DEFAULTS.size,
+        font: isOwn(exports.OSD_FONTS, v.font) ? v.font : exports.OSD_DEFAULTS.font,
+        size: isOwn(exports.OSD_SIZES, v.size) ? v.size : exports.OSD_DEFAULTS.size,
         position: exports.OSD_POSITIONS.includes(v.position) ? v.position : exports.OSD_DEFAULTS.position,
-        color: typeof v.color === 'string' && CSS.supports('color', v.color) ? v.color : '',
+        color: osdColor(v.color),
         seconds: Number.isFinite(seconds) && seconds >= 0.5 && seconds <= 30 ? seconds : exports.OSD_DEFAULTS.seconds,
     };
 }
@@ -57,23 +78,43 @@ function place(position) {
     ].join('; ');
     return { box, glow, align: h === 'left' ? 'flex-start' : h === 'right' ? 'flex-end' : 'center' };
 }
-/** Fills `el` (a .trd-osd) with `name` and an optional second line, as the settings say. */
+/**
+ * Fills `el` (a .trd-osd) with `name` and an optional second line, as the settings say. The settings are checked
+ * again, whoever passes them, and the overlay is built node by node with its styles set through the CSSOM: nothing
+ * from the config is ever parsed as markup, which in Tabby's window (Node integration) would run as code.
+ */
 function renderOsd(el, name, sub, settings) {
-    const font = exports.OSD_FONTS[settings.font];
-    const { box, glow, align } = place(settings.position);
+    const checked = osdSettings(settings);
+    const font = exports.OSD_FONTS[checked.font];
+    const { box, glow, align } = place(checked.position);
     // Smaller in a narrow pane: a name should fit in about two thirds of it.
     const width = el.offsetWidth || 800; // layout width: the settings preview is a scaled-down desktop
-    const size = Math.max(18, Math.min(exports.OSD_SIZES[settings.size], width / Math.max(4, name.length) * 1.1));
-    el.innerHTML = `<div class="trd-osd-glow" style="${glow}"></div>
-        <div class="trd-osd-box" style="${box}; align-items: ${align}; font-family: ${font.family.replace(/"/g, '&quot;')};
-            font-weight: ${font.weight}; font-stretch: ${font.stretch}; font-size: ${size}px${settings.color ? `; color: ${settings.color}` : ''}">
-            <div class="trd-osd-name"></div><div class="trd-osd-sub"></div></div>`;
-    el.querySelector('.trd-osd-name').textContent = name;
-    const subEl = el.querySelector('.trd-osd-sub');
+    const size = Math.max(18, Math.min(exports.OSD_SIZES[checked.size], width / Math.max(4, name.length) * 1.1));
+    const part = (className) => {
+        const div = document.createElement('div');
+        div.className = className;
+        return div;
+    };
+    const glowEl = part('trd-osd-glow');
+    glowEl.style.cssText = glow;
+    const boxEl = part('trd-osd-box');
+    boxEl.style.cssText = box;
+    boxEl.style.setProperty('align-items', align);
+    boxEl.style.setProperty('font-family', font.family);
+    boxEl.style.setProperty('font-weight', String(font.weight));
+    boxEl.style.setProperty('font-stretch', font.stretch);
+    boxEl.style.setProperty('font-size', `${size}px`);
+    if (checked.color) {
+        boxEl.style.setProperty('color', checked.color);
+    }
+    const nameEl = part('trd-osd-name');
+    nameEl.textContent = name;
+    const subEl = part('trd-osd-sub');
     if (sub) {
         const bar = document.createElement('span');
         bar.className = 'trd-osd-bar';
         subEl.append(bar, document.createTextNode(sub));
     }
+    boxEl.append(nameEl, subEl);
+    el.replaceChildren(glowEl, boxEl);
 }
-//# sourceMappingURL=osd.js.map

package/dist/probe.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PROBES = void 0;
 exports.probeArrived = probeArrived;
 exports.probesIn = probesIn;
 /**
@@ -8,15 +9,27 @@ exports.probesIn = probesIn;
  * in, so nothing shows). Exact where a split's panes share a host, and even their size.
  */
 const listeners = new Set();
+/**
+ * How many probes probesIn keeps at most. A pane gets one for each `ssh` in the foreground of its terminal there (two
+ * with a jump host's); the host, which is given the prefix, could print any number more while its command runs (up to
+ * a minute), each one kept until then.
+ */
+exports.MAX_PROBES = 64;
+/** What follows a probe's prefix and its dash: the number the script gives each `ssh` it finds, from 1. */
+const PROBE_NUMBER = /^[1-9][0-9]{0,2}$/;
 /** Called by desk.ts for each probe in a pane's output. */
 function probeArrived(id, pane) {
     listeners.forEach(f => f(id, pane));
 }
-/** Collects the probes (ids starting with `prefix`) that arrive in `pane` while `during` runs, and briefly after. */
+/**
+ * Collects the probes that arrive in `pane` while `during` runs, and briefly after: ids of the form `<prefix>-<n>`, n
+ * from 1 to 999, the first MAX_PROBES of them.
+ */
 async function probesIn(pane, prefix, during, settleMs = 400) {
     const ids = new Set();
+    const start = `${prefix}-`;
     const listener = (id, where) => {
-        if (where === pane && id.startsWith(prefix)) {
+        if (where === pane && ids.size < exports.MAX_PROBES && id.startsWith(start) && PROBE_NUMBER.test(id.slice(start.length))) {
             ids.add(id);
         }
     };
@@ -30,4 +43,3 @@ async function probesIn(pane, prefix, during, settleMs = 400) {
         listeners.delete(listener);
     }
 }
-//# sourceMappingURL=probe.js.map