tabby-rdp 0.5.0 → 0.5.2

package/dist/help.js

@@ -9,7 +9,7 @@ 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.RemoteDesktopHelp = exports.esc = exports.TROUBLESHOOTING = exports.SETTINGS_TAB_ID = exports.HOTKEYS = exports.TOGGLE_HOTKEY = void 0;
+exports.RemoteDesktopHelp = exports.esc = exports.TROUBLESHOOTING = exports.TROUBLESHOOTING_URL = exports.SETTINGS_TAB_ID = exports.HOTKEYS = exports.TOGGLE_HOTKEY = void 0;
 exports.entryFor = entryFor;
 exports.hotkeyLabel = hotkeyLabel;
 const core_1 = require("@angular/core");
@@ -33,88 +33,50 @@ exports.HOTKEYS = [
 ];
 /** The plugin's page in Tabby's settings (see settingsPage.ts). */
 exports.SETTINGS_TAB_ID = 'remote-desktop';
+exports.TROUBLESHOOTING_URL = 'https://github.com/meanaverage/tabby-rdp/blob/main/TROUBLESHOOTING.md';
 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
-            different one there means another program listens on its port. Remembered certificates are listed above.`,
     },
     {
         id: 'sign-in',
         title: 'Wrong user name or password',
         match: /sign-in|sign in|password|user name/i,
-        body: `Windows and xrdp desktops sign in with an account on that machine (<code>DOMAIN\\user</code> works). A saved
-            password that no longer works is asked for again; <b>Sign in again…</b> in the tab's menu replaces it on
-            purpose. xrdp doesn't refuse a wrong password: it shows its own login window instead. GNOME desktops never
-            ask: the plugin manages their sign-in.`,
     },
     {
         id: 'no-desktop',
         title: 'No desktop found on a Linux host',
         match: /GNOME|xrdp|grdctl|headless/i,
-        body: `The plugin uses GNOME Remote Desktop 46 or newer (Ubuntu 24.04, for example), with no root and no login
-            screen. For KDE, XFCE, MATE and others, install xrdp and a desktop for its sessions: on Debian and Ubuntu,
-            <code>sudo apt install xrdp xfce4</code>. A GNOME session already shared from the machine's own screen (GNOME's
-            Desktop Sharing) has to be turned off first.`,
     },
     {
         id: 'unreachable',
         title: 'Can\'t reach a Windows desktop',
         match: /refused|timed out|timeout|unreachable|ECONN|EHOST|no route|could not connect|couldn't connect/i,
-        body: `Windows needs Remote Desktop turned on (Settings › System › Remote Desktop; Pro, Enterprise or Server).
-            Behind an SSH host, the address is as that host sees it: from there, <code>nc -z &lt;address&gt; 3389</code>
-            should succeed. For a VM or machine that may be off, give the desktop a VM name or MAC address in its edit form
-            and it is started when opened.`,
     },
     {
         id: 'reconnecting',
         title: 'It keeps reconnecting',
         match: /reconnect|connection lost/i,
-        body: `After sleep or a network change the desktop reconnects by itself, with growing pauses, and waits while the
-            SSH connection is down (<b>Reconnect SSH</b> hurries that along). It stops after a few tries or on
-            <b>Stop</b>. If it drops again right after connecting, check the host's free memory and that the desktop's
-            session is still running there.`,
     },
     {
         id: 'picture',
         title: 'The picture is blurry or slow',
         match: /H\.264|decod|video/i,
-        body: `<b>Sharpness › Retina</b> renders at your screen's device pixels, with the remote's scale set to match. Video
-            (H.264) is used when the remote sends it: Windows does, GNOME only with a hardware encoder (VA-API or NVENC).
-            <b>Show connection status</b> shows the frame rate, the round trip and how the picture comes.`,
     },
     {
         id: 'sound',
         title: 'No sound, or the microphone isn\'t heard',
-        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.`,
     },
     {
         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.
-            To have both desktops side by side, open the first machine's desktop in one pane, and ssh on in the other.`,
     },
     {
         id: 'extra-monitor',
         title: 'The desktop is open somewhere else',
         match: /open somewhere else|opened somewhere else/,
-        body: `GNOME Remote Desktop's headless mode gives each connection a screen of its own: a second computer, or another
-            Tabby window, connected to the same account gets an empty extra screen rather than the same one. So when the
-            desktop is open somewhere else already, you choose. <b>Take it over</b> disconnects the other connection, as
-            Windows does; the session and its apps carry on, on this screen. <b>Open a second screen</b> keeps both, each
-            with a screen of its own. A desktop taken over from here doesn't take itself back: it says so, and offers
-            the same two choices.`,
     },
 ];
 /** The troubleshooting entry that explains a message, if one does. */
@@ -127,13 +89,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%);
@@ -151,10 +115,11 @@ const TIP_STYLE = `
  * connects. Nothing else pops up.
  */
 let RemoteDesktopHelp = class RemoteDesktopHelp {
-    constructor(app, config, zone) {
+    constructor(app, config, zone, platform) {
         this.app = app;
         this.config = config;
         this.zone = zone;
+        this.platform = platform;
         /** A section to show; the open settings page follows it (see settingsPage.ts). */
         this.show$ = new rxjs_1.Subject();
         /** For a settings page not yet made: where to scroll once it is. */
@@ -165,6 +130,11 @@ let RemoteDesktopHelp = class RemoteDesktopHelp {
     }
     /** Opens Tabby's settings at the plugin's page, at `topic` (and a troubleshooting entry). */
     open(topic = 'start', entry) {
+        if (topic === 'troubleshooting') {
+            const anchor = exports.TROUBLESHOOTING.some(e => e.id === entry) ? `#${entry}` : '';
+            this.platform.openExternal(exports.TROUBLESHOOTING_URL + anchor);
+            return;
+        }
         this.zone.run(() => {
             this.pending = { topic, entry };
             this.openSettings(exports.SETTINGS_TAB_ID);
@@ -258,6 +228,5 @@ let RemoteDesktopHelp = class RemoteDesktopHelp {
 exports.RemoteDesktopHelp = RemoteDesktopHelp;
 exports.RemoteDesktopHelp = RemoteDesktopHelp = __decorate([
     (0, core_1.Injectable)({ providedIn: 'root' }),
-    __metadata("design:paramtypes", [tabby_core_1.AppService, tabby_core_1.ConfigService, core_1.NgZone])
+    __metadata("design:paramtypes", [tabby_core_1.AppService, tabby_core_1.ConfigService, core_1.NgZone, tabby_core_1.PlatformService])
 ], RemoteDesktopHelp);
-//# sourceMappingURL=help.js.map

package/dist/hostCompat.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostCompatibility = void 0;
+exports.terminalInputs = terminalInputs;
+exports.createHostCompatibility = createHostCompatibility;
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.replace(/[\x00-\x1f\x7f]/g, ' ').trim().slice(0, 256) || null : null;
+}
+function read(source) {
+    try {
+        return source?.();
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Ranges spanning multiple majors, URLs and workspace aliases cannot establish a single major. */
+function declaredMajor(declaration) {
+    const match = declaration?.match(/^[~^]?(\d+)(?:\.(?:\d+|x|\*)(?:\.(?:\d+|x|\*))?)?(?:-[\da-z.-]+)?(?:\+[\da-z.-]+)?$/i);
+    const major = match ? Number(match[1]) : NaN;
+    return Number.isSafeInteger(major) ? major : null;
+}
+/** Shared terminal DOM adapter; keep desktop layers and forms in agreement about the input they cover. */
+function terminalInputs(container) {
+    return Array.from(container.querySelectorAll('textarea.xterm-helper-textarea'));
+}
+/** An Angular factory provides one instance per plugin window; this module itself needs no Angular runtime. */
+class HostCompatibility {
+    constructor(sources) {
+        this.nativeModalDragRegion = null;
+        const xtermDeclaration = text(read(() => {
+            const terminal = sources.terminalPackage?.();
+            return text(terminal?.dependencies?.['@xterm/xterm']) ?? text(terminal?.devDependencies?.['@xterm/xterm']);
+        }));
+        this.info = Object.freeze({
+            name: text(read(sources.name)), version: text(read(sources.version)), platform: text(sources.platform),
+            electron: text(sources.electron), node: text(sources.node), xtermDeclaration,
+            xtermMajor: declaredMajor(xtermDeclaration),
+        });
+        this.modalStyle = sources.modalStyle ?? ((element, pseudo) => getComputedStyle(element, pseudo));
+    }
+    /** Probe each modal; themes and UI scale can change while the application is running. */
+    hasNativeModalDragRegion(modal) {
+        let supported = false;
+        try {
+            const style = this.modalStyle(modal, '::before');
+            supported = style.content !== 'none' && style.content !== 'normal' && style.display !== 'none' &&
+                style.getPropertyValue('-webkit-app-region') === 'drag' && parseFloat(style.height) > 0;
+        }
+        catch { }
+        this.nativeModalDragRegion = supported;
+        return supported;
+    }
+    snapshot(pane) {
+        return {
+            ...this.info,
+            capabilities: {
+                nativeModalDragRegion: this.nativeModalDragRegion,
+                terminalInput: pane ? terminalInputs(pane).length > 0 : null,
+            },
+        };
+    }
+    /** Local build information and observed capabilities only; no config, accounts, paths or connection details. */
+    diagnosticLines(pane) {
+        const info = this.snapshot(pane);
+        const { nativeModalDragRegion, terminalInput } = info.capabilities;
+        const drag = nativeModalDragRegion === null ? 'unobserved' : nativeModalDragRegion ? 'host' : 'plugin fallback';
+        const input = terminalInput === null ? 'unobserved' : terminalInput ? 'available' : 'unavailable';
+        return [
+            `Host: ${info.name ?? 'unknown'} ${info.version ?? 'unknown'} on ${info.platform ?? 'unknown'}`,
+            `Runtime: Electron ${info.electron ?? 'unknown'}, Node ${info.node ?? 'unknown'}`,
+            `Terminal: xterm ${info.xtermDeclaration ?? 'unknown'} (host declaration)`,
+            `Compatibility: modal drag region ${drag}; terminal input ${input}`,
+        ];
+    }
+}
+exports.HostCompatibility = HostCompatibility;
+/** Prefer Tabby's public version API; optional metadata reads never become requirements for operating a desktop. */
+function createHostCompatibility(platform) {
+    return new HostCompatibility({
+        name: () => require('@electron/remote').app.getName(),
+        version: () => platform.getAppVersion(),
+        platform: process.platform, electron: process.versions.electron, node: process.versions.node,
+        terminalPackage: () => require('tabby-terminal/package.json'),
+    });
+}

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

@@ -18,6 +18,7 @@ const desk_1 = require("./desk");
 const header_1 = require("./header");
 const keyboard_1 = require("./keyboard");
 const help_1 = require("./help");
+const hostCompat_1 = require("./hostCompat");
 const signin_1 = require("./signin");
 const rdpFile_1 = require("./rdpFile");
 const rdpProfile_1 = require("./rdpProfile");
@@ -28,7 +29,8 @@ const targets_1 = require("./targets");
 const ui_1 = require("./ui");
 let RemoteDesktopModule = class RemoteDesktopModule {
     constructor(app, hotkeys, desktop, header, targets, keyboard, injector) {
-        (0, desktop_service_1.installStyle)();
+        const compat = injector.get(hostCompat_1.HostCompatibility);
+        (0, desktop_service_1.installStyle)(compat);
         header.install();
         // Passwords go to Tabby's Vault while it is enabled (as Tabby's SSH passwords do), else to the system keychain.
         try {
@@ -49,7 +51,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;
@@ -61,12 +64,13 @@ let RemoteDesktopModule = class RemoteDesktopModule {
         });
         // Handle for tests and troubleshooting from DevTools.
         const w = window;
-        w.__remoteDesktop = { app, desktop, targets, desktopPaneOf: targets_1.desktopPaneOf, injector, execRemote: ssh_1.execRemote, parseRdpFile: rdpFile_1.parseRdpFile, help: injector.get(help_1.RemoteDesktopHelp), updates: injector.get(updates_1.UpdateCheck) };
+        w.__remoteDesktop = { app, desktop, targets, desktopPaneOf: targets_1.desktopPaneOf, injector, compat, execRemote: ssh_1.execRemote, parseRdpFile: rdpFile_1.parseRdpFile, help: injector.get(help_1.RemoteDesktopHelp), updates: injector.get(updates_1.UpdateCheck) };
     }
 };
 RemoteDesktopModule = __decorate([
     (0, core_1.NgModule)({
         providers: [
+            { provide: hostCompat_1.HostCompatibility, useFactory: hostCompat_1.createHostCompatibility, deps: [tabby_core_1.PlatformService] },
             { provide: tabby_core_1.HotkeyProvider, useClass: ui_1.RemoteDesktopHotkeys, multi: true },
             { provide: tabby_core_1.ConfigProvider, useClass: ui_1.RemoteDesktopConfig, multi: true },
             { provide: tabby_core_1.TabContextMenuItemProvider, useClass: ui_1.RemoteDesktopContextMenu, multi: true },
@@ -85,4 +89,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