tabby-rdp 0.4.1 → 0.5.1

package/dist/header.js

@@ -23,10 +23,28 @@ const ui_1 = require("./ui");
 const ICON_DESKTOP = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><path fill="currentColor" d="M64 0C28.7 0 0 28.7 0 64L0 352c0 35.3 28.7 64 64 64l176 0-10.7 32L160 448c-17.7 0-32 14.3-32 32s14.3 32 32 32l256 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-69.3 0L336 416l176 0c35.3 0 64-28.7 64-64l0-288c0-35.3-28.7-64-64-64L64 0zM512 64l0 224L64 288 64 64l448 0z"/></svg>';
 const ICON_TERMINAL = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><path fill="currentColor" d="M9.4 86.6C-3.1 74.1-3.1 53.9 9.4 41.4s32.8-12.5 45.3 0l192 192c12.5 12.5 12.5 32.8 0 45.3l-192 192c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3L178.7 256 9.4 86.6zM256 416l288 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l-288 0c-17.7 0-32-14.3-32-32s14.3-32 32-32z"/></svg>';
 const ICON_DISCONNECT = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><path fill="currentColor" d="M64 80c-8.8 0-16 7.2-16 16l0 320c0 8.8 7.2 16 16 16l384 0c8.8 0 16-7.2 16-16l0-320c0-8.8-7.2-16-16-16L64 80zM0 96C0 60.7 28.7 32 64 32l384 0c35.3 0 64 28.7 64 64l0 320c0 35.3-28.7 64-64 64L64 480c-35.3 0-64-28.7-64-64L0 96zm175 79c9.4-9.4 24.6-9.4 33.9 0l47 47 47-47c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-47 47 47 47c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0l-47-47-47 47c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9l47-47-47-47c-9.4-9.4-9.4-24.6 0-33.9z"/></svg>';
+/** What the microphone indicator says about the desktops sent the microphone. */
+function microphoneTitle(users) {
+    const names = users.map(u => u.name);
+    const which = names.length > 1 ? `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]} are` : `${names[0]} is`;
+    return `Microphone in use: ${which} receiving it. Click to show the desktop, or to stop sending the microphone there.`;
+}
+/**
+ * The microphone over the window (see HeaderControls.float): like the dot on a desktop, but one that can be clicked, so
+ * it takes the clicks on what it covers of the desktop in view. At the top in the middle, where a maximized window's
+ * title bar has its title (GNOME) or only room to drag it by (Windows), and GNOME's top bar its clock, all wider than
+ * it, rather than in the corner, where they have their close button and system menu. Windows' own Remote Desktop
+ * client puts its bar there in full screen too.
+ */
+const FLOATING_MICROPHONE_STYLE = 'position: fixed; top: 8px; left: 50%; transform: translateX(-50%); z-index: 1040; width: 26px; height: 26px; padding: 0; ' +
+    'border: none; border-radius: 50%; display: flex; align-items: center; justify-content: center; ' +
+    'background: rgba(220, 38, 38, 0.9); color: #fff; font-size: 12px; cursor: pointer; box-shadow: 0 1px 4px rgba(0, 0, 0, 0.4);';
 /**
  * Desktop/console switch and Disconnect in Tabby's header, left of the settings gear, for the active
  * tab's SSH pane. Tabby builds its own header buttons once at startup, so these are plain DOM kept in
- * sync with the active tab and the desktop state.
+ * sync with the active tab and the desktop state. Also a red microphone while any desktop is sent the
+ * microphone, whatever tab is in front: the dot on a desktop is out of sight while it is hidden. Without
+ * a header (full screen hides Tabby's tab bar), that one shows over the window instead, at its top in the middle.
  */
 let HeaderControls = class HeaderControls {
     constructor(app, desktop, targets, platform, keyboard, zone, help) {
@@ -38,6 +56,8 @@ let HeaderControls = class HeaderControls {
         this.zone = zone;
         this.help = help;
         this.group = null;
+        /** The microphone over the window, while it shows (see float). */
+        this.floatingMicrophone = null;
         this.scheduled = false;
     }
     // All watching and DOM syncing runs outside Angular's zone: inside it, every observer callback and
@@ -137,21 +157,33 @@ let HeaderControls = class HeaderControls {
         });
         this.disconnectButton.title = 'Disconnect remote desktop';
         this.disconnectButton.innerHTML = ICON_DISCONNECT;
-        this.group.append(this.toggleButton, this.disconnectButton);
+        this.microphoneButton = button('trd-header-mic', () => this.microphoneMenu());
+        this.microphoneButton.innerHTML = '<i class="fas fa-microphone"></i>';
+        // Inline: Tabby's header button color is scoped to its component and would win over a plugin style.
+        this.microphoneButton.style.color = 'rgb(220, 38, 38)';
+        this.group.append(this.microphoneButton, this.toggleButton, this.disconnectButton);
         right.insertBefore(this.group, right.firstChild);
         return true;
     }
     refresh() {
-        if (!this.ensureGroup()) {
+        const users = this.desktop.microphoneUsers();
+        const inHeader = this.ensureGroup();
+        this.float(inHeader ? [] : users.filter(u => !u.inView));
+        if (!inHeader) {
             return;
         }
+        this.microphoneButton.style.display = users.length ? '' : 'none';
+        this.microphoneButton.title = users.length ? microphoneTitle(users) : '';
         let pane = (0, targets_1.desktopPaneOf)(this.app.activeTab);
         // SSH tabs always qualify; local terminals only while they run ssh (see detect()).
         if (pane && !(0, ssh_1.isSSHTab)(pane) && !this.desktop.has(pane) && !this.targets.cached(pane)) {
             pane = null;
         }
-        this.group.style.display = pane ? 'flex' : 'none';
+        // The microphone shows from any tab, also one with nothing to switch.
+        this.group.style.display = pane || users.length ? 'flex' : 'none';
         if (!pane) {
+            this.toggleButton.style.display = 'none';
+            this.disconnectButton.style.display = 'none';
             return;
         }
         const visible = this.desktop.isVisible(pane);
@@ -164,6 +196,46 @@ let HeaderControls = class HeaderControls {
         }
         this.disconnectButton.style.display = this.desktop.has(pane) ? '' : 'none';
     }
+    /**
+     * The microphone over the window, for desktops sent it that aren't in view (`users`), while there is no header to
+     * show it in: Tabby leaves its tab bar out in full screen unless Appearance › Show tabs in fullscreen mode is on. A
+     * desktop in view has its dot. Gone again once the header is back or nothing out of view gets the microphone.
+     */
+    float(users) {
+        // The note on desktops that typing goes into all of them, at their top in the middle, moves clear of it meanwhile
+        // (see the service's STYLE).
+        document.body.classList.toggle('trd-floating-mic-on', users.length > 0);
+        if (!users.length) {
+            this.floatingMicrophone?.remove();
+            this.floatingMicrophone = null;
+            return;
+        }
+        if (!this.floatingMicrophone?.isConnected) {
+            const button = document.createElement('button');
+            button.className = 'trd-floating-mic';
+            button.style.cssText = FLOATING_MICROPHONE_STYLE;
+            button.innerHTML = '<i class="fas fa-microphone"></i>';
+            button.addEventListener('click', () => this.zone.run(() => this.microphoneMenu()));
+            document.body.appendChild(button);
+            this.floatingMicrophone = button;
+        }
+        const title = microphoneTitle(users);
+        if (this.floatingMicrophone.title !== title) {
+            this.floatingMicrophone.title = title;
+        }
+    }
+    /** The microphone's menu: for each desktop sent it, show that desktop, or stop sending the microphone there. */
+    microphoneMenu() {
+        const users = this.desktop.microphoneUsers();
+        if (!users.length) {
+            return; // stopped meanwhile
+        }
+        const items = [{ label: 'Microphone in use', enabled: false }];
+        for (const { pane, name } of users) {
+            items.push({ type: 'separator' }, { label: `Show ${name}`, click: () => this.desktop.bringForward(pane) }, { label: `Stop sending the microphone to ${name}`, click: () => this.desktop.stopMicrophone(pane) });
+        }
+        this.platform.popupContextMenu(items);
+    }
 };
 exports.HeaderControls = HeaderControls;
 exports.HeaderControls = HeaderControls = __decorate([
@@ -176,4 +248,3 @@ exports.HeaderControls = HeaderControls = __decorate([
         core_1.NgZone,
         help_1.RemoteDesktopHelp])
 ], HeaderControls);
-//# sourceMappingURL=header.js.map

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+    // 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() : '';
+}
+/**
+ * Runs a PowerShell script on the host and returns what it printed. As -EncodedCommand, which reads the same whether
+ * the host's SSH shell is cmd.exe or PowerShell, and needs no quoting. Windows PowerShell 5.1 is on every Windows.
+ */
+async function powershell(target, script) {
+    const encoded = Buffer.from(`$ProgressPreference = 'SilentlyContinue'\n${script}`, 'utf16le').toString('base64');
+    return target.exec(`powershell -NoProfile -NonInteractive -EncodedCommand ${encoded}`, '');
+}
+// One line per VM: TRD_HV <id>|<state>|<name>. Nothing where Hyper-V isn't installed or the account may not list
+// VMs (which takes an administrator of the host, in practice).
+const SCAN = String.raw `
+$ErrorActionPreference = 'SilentlyContinue'
+if (Get-Command Get-VM) { Get-VM | ForEach-Object { 'TRD_HV ' + $_.Id + '|' + $_.State + '|' + $_.Name } }
+`;
+/**
+ * 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 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.
+const STATE = String.raw `
+try {
+    $vm = Get-VM -Id '@@ID@@' -ErrorAction Stop
+    $enhanced = (Get-CimInstance -Namespace root\virtualization\v2 -ClassName Msvm_ComputerSystem -Filter "Name='$($vm.Id.ToString().ToUpper())'" -ErrorAction SilentlyContinue).EnhancedSessionModeState
+    'TRD_HV_STATE ' + $vm.State + '|' + $enhanced
+} catch { 'TRD_HV_ERR ' + ($_.Exception.Message -replace '\s+', ' ') }
+`;
+/** 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 = linesAfter(out, 'TRD_HV_STATE ').map(line => /^([^|]*)\|(\d*)$/.exec(line)).find(Boolean);
+    if (!state) {
+        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' };
+}
+const START = String.raw `
+try {
+    $vm = Get-VM -Id '@@ID@@' -ErrorAction Stop
+    if ($vm.State -eq 'Running') { 'TRD_HV_OK ' + $vm.Name + ' is already running' }
+    elseif ($vm.State -eq 'Paused') { Resume-VM -VM $vm -ErrorAction Stop; 'TRD_HV_OK ' + $vm.Name + ' resumed' }
+    else { Start-VM -VM $vm -ErrorAction Stop; 'TRD_HV_OK ' + $vm.Name + ' started' }
+} catch { 'TRD_HV_ERR ' + ($_.Exception.Message -replace '\s+', ' ') }
+`;
+/** 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 = linesAfter(out, 'TRD_HV_OK ');
+    if (!ok.length) {
+        throw new Error(linesAfter(out, 'TRD_HV_ERR ')[0] || 'the host didn\'t answer');
+    }
+    return ok[0];
+}

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