tabby-rdp 0.5.0 → 0.5.1

package/dist/gateway.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GatewaySignInError = void 0;
 exports.parseGateway = parseGateway;
+exports.formatGateway = formatGateway;
 exports.handshakeRequest = handshakeRequest;
 exports.tunnelCreate = tunnelCreate;
 exports.tunnelAuth = tunnelAuth;
@@ -10,18 +11,55 @@ exports.dataPacket = dataPacket;
 exports.gatewayError = gatewayError;
 exports.packetReader = packetReader;
 exports.wsFrame = wsFrame;
+exports.pongs = pongs;
 exports.wsReader = wsReader;
 exports.endPointBinding = endPointBinding;
 exports.openThroughGateway = openThroughGateway;
 const crypto_1 = require("crypto");
+const net_1 = require("net");
 const stream_1 = require("stream");
 const tls = require("tls");
+const url_1 = require("url");
+const authorities_1 = require("./authorities");
+const byteQueue_1 = require("./byteQueue");
 const ntlm_1 = require("./ntlm");
-/** A `host` or `host:port` setting as a gateway (443 by default), or null if it isn't one. */
+/**
+ * A gateway's host in one canonical form, so its trust key, its credential scope, its SNI and the way it is shown all
+ * agree on it and an alternate spelling of the same gateway isn't taken for another one: an IPv6 literal compressed
+ * (so `[0:0::1]` and `[::1]` are one), any other host as the name it resolves to (lower case, international letters as
+ * punycode, one trailing dot dropped). Null for what names no host: an IPv6 literal that isn't one, an empty label
+ * (`gw..example`, or a second trailing dot), a label over 63 characters or a name over 253, and a name with a
+ * character no host name has (`#`, `?`, `@`, `%`, quotes, …), which the URL parser behind domainToASCII would otherwise
+ * read as the end of the name or decode (`gw.example#x` as `gw.example`, `a%41` as `aa`) rather than refuse.
+ */
+function canonicalGatewayHost(bracketed, bare) {
+    if (bracketed !== undefined) {
+        try {
+            return new URL(`http://[${bracketed}]`).hostname.replace(/^\[|\]$/g, '');
+        }
+        catch {
+            return null;
+        }
+    }
+    // Letters of any script go to IDNA, which refuses what isn't a name; of ASCII, only what a host name is made of.
+    if (/[^A-Za-z0-9._-]/.test((bare ?? '').replace(/[^\x00-\x7f]/g, ''))) {
+        return null;
+    }
+    const host = (0, url_1.domainToASCII)((bare ?? '').replace(/\.$/, ''));
+    return host && host.length <= 253 && host.split('.').every(label => label.length > 0 && label.length <= 63) ? host : null;
+}
+/** A `host` or `host:port` setting as a gateway (443 by default), or null if it isn't one. The host is canonical. */
 function parseGateway(value) {
-    const m = /^\s*(?:\[([0-9a-f:.]+)\]|([^\s:/]+))(?::(\d{1,5}))?\s*$/i.exec(String(value ?? ''));
+    // Text only, as specOf reads a gateway: String() of an object from the config runs its own conversions, which can throw.
+    const m = /^\s*(?:\[([0-9a-f:.]+)\]|([^\s:/]+))(?::(\d{1,5}))?\s*$/i.exec(typeof value === 'string' ? value : '');
     const port = Number(m?.[3] ?? 443);
-    return m && port > 0 && port < 65536 ? { host: m[1] ?? m[2], port } : null;
+    const host = m && canonicalGatewayHost(m[1], m[2]);
+    return host && port > 0 && port < 65536 ? { host, port } : null;
+}
+/** A gateway as a setting writes it: `host`, or `host:port` when that isn't 443 (an IPv6 address in brackets). */
+function formatGateway(gateway) {
+    const host = gateway.host.includes(':') ? `[${gateway.host}]` : gateway.host;
+    return gateway.port === 443 ? host : `${host}:${gateway.port}`;
 }
 /** The gateway refused the account (its HTTP sign-in, or its connection authorization policy). */
 class GatewaySignInError extends Error {
@@ -47,6 +85,11 @@ const CAPABILITY_MESSAGING_CONSENT_SIGN = 0x4;
 const MAX_DATA = 32 * 1024;
 /** What an incoming packet may be at most (a data packet's 64 KiB, and room for a certificate in the tunnel response). */
 const MAX_PACKET = 256 * 1024;
+/**
+ * How many of the gateway's administrator's messages are logged: it decides how many it sends, and when, for as long
+ * as the connection lasts. An administrator has one to show, as the connection starts.
+ */
+const MAX_SERVICE_MESSAGES = 10;
 function packet(type, body) {
     const header = Buffer.alloc(8);
     header.writeUInt16LE(type, 0);
@@ -100,23 +143,32 @@ function gatewayError(code, target) {
         default: return `the gateway refused the connection (0x${(code >>> 0).toString(16)})`;
     }
 }
+/**
+ * The start of a gateway's service message (a length, then UTF-16 text), for the log: up to its terminator, 300
+ * characters at most. Only that much is read: the gateway decides how long it is, up to a packet's size, and looking
+ * through all of it for where it ends could take the square of that.
+ */
+function serviceMessage(body) {
+    const text = body.subarray(body.length >= 2 ? 2 : 0).subarray(0, 600).toString('utf16le');
+    const nul = text.indexOf('\0');
+    return nul < 0 ? text : text.slice(0, nul);
+}
 /** Splits a byte stream into the gateway's packets (8 bytes of header: type, reserved, total length). */
 function packetReader(onPacket) {
-    let pending = Buffer.alloc(0);
+    const pending = new byteQueue_1.ByteQueue();
     return chunk => {
-        pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+        pending.push(chunk);
         while (pending.length >= 8) {
-            const length = pending.readUInt32LE(4);
+            const length = pending.peek(8).readUInt32LE(4);
             if (length < 8 || length > MAX_PACKET) {
                 throw new Error(`a gateway packet of ${length} bytes`);
             }
             if (pending.length < length) {
                 break;
             }
-            onPacket(pending.readUInt16LE(0), pending.subarray(8, length));
-            pending = pending.subarray(length);
+            const packet = pending.take(length);
+            onPacket(packet.readUInt16LE(0), packet.subarray(8));
         }
-        pending = Buffer.from(pending);
     };
 }
 // ---- WebSocket frames (RFC 6455), client side -----------------------------------------------------
@@ -143,37 +195,67 @@ function wsFrame(payload, opcode = 0x2) {
     }
     return Buffer.concat([header, mask, masked]);
 }
+/**
+ * Answers pings with pongs: one waiting to go out at a time, for the latest ping, as RFC 6455 allows (5.5.3). A gateway
+ * that sends pings and doesn't read what comes back would otherwise have the pongs pile up here as fast as it sends.
+ */
+function pongs(socket, ended) {
+    let waiting = false;
+    let latest = null;
+    const pong = (payload) => {
+        if (waiting) {
+            latest = Buffer.from(payload);
+            return;
+        }
+        waiting = true;
+        socket.write(wsFrame(payload, 0xa), () => {
+            waiting = false;
+            const next = latest;
+            latest = null;
+            if (next && !ended()) {
+                pong(next);
+            }
+        });
+    };
+    return pong;
+}
 /** Splits the server's bytes into frames: data frames' payloads (fragments as they come), pings, and a close. */
 function wsReader(on) {
-    let pending = Buffer.alloc(0);
+    const pending = new byteQueue_1.ByteQueue();
     return chunk => {
-        pending = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+        pending.push(chunk);
         for (;;) {
-            if (pending.length < 2) {
+            // The header: 2 bytes, then up to 8 of length (and 4 of mask, read with the frame).
+            const head = pending.peek(10);
+            if (head.length < 2) {
                 break;
             }
-            const opcode = pending[0] & 0x0f;
-            const masked = (pending[1] & 0x80) !== 0;
-            let length = pending[1] & 0x7f;
+            const opcode = head[0] & 0x0f;
+            const masked = (head[1] & 0x80) !== 0;
+            let length = head[1] & 0x7f;
             let at = 2;
             if (length === 126) {
-                if (pending.length < 4) {
+                if (head.length < 4) {
                     break;
                 }
-                length = pending.readUInt16BE(2);
+                length = head.readUInt16BE(2);
                 at = 4;
             }
             else if (length === 127) {
-                if (pending.length < 10) {
+                if (head.length < 10) {
                     break;
                 }
-                const long = pending.readBigUInt64BE(2);
+                const long = head.readBigUInt64BE(2);
                 if (long > BigInt(MAX_PACKET * 4)) {
                     throw new Error('a WebSocket frame too large to be the gateway\'s');
                 }
                 length = Number(long);
                 at = 10;
             }
+            // Close, ping and pong carry 125 bytes at most (RFC 6455, 5.5): each ping is answered with as much.
+            if (opcode >= 0x8 && length > 125) {
+                throw new Error('a WebSocket control frame too large to be the gateway\'s');
+            }
             const maskAt = at;
             if (masked) {
                 at += 4;
@@ -181,14 +263,14 @@ function wsReader(on) {
             if (pending.length < at + length) {
                 break;
             }
-            let payload = pending.subarray(at, at + length);
+            const frame = pending.take(at + length);
+            let payload = frame.subarray(at);
             if (masked) {
                 payload = Buffer.from(payload);
                 for (let i = 0; i < length; i++) {
-                    payload[i] ^= pending[maskAt + (i & 3)];
+                    payload[i] ^= frame[maskAt + (i & 3)];
                 }
             }
-            pending = pending.subarray(at + length);
             if (opcode === 0x8) {
                 on.close();
             }
@@ -200,60 +282,92 @@ function wsReader(on) {
                 on.data(payload);
             }
         }
-        pending = Buffer.from(pending);
     };
 }
 // ---- the HTTP upgrade, with NTLM --------------------------------------------------------------------
-/** One HTTP response's status and headers, read from the stream; its body (a 401's page) is read and dropped. */
+/** What a response's status line and headers may be at most. */
+const MAX_HEAD = 64 * 1024;
+/** What its body may be at most: a 401's page, a kilobyte or so, which isn't kept anyway. */
+const MAX_BODY = 256 * 1024;
+/** A header's name: an HTTP token (RFC 9110, 5.6.2). */
+const HEADER_NAME = /^[!#$%&'*+.^_`|~0-9a-z-]+$/;
+/**
+ * One HTTP response's status and headers, read from the stream. A 401's body (its page) is counted off as it comes, not
+ * kept; a length (Content-Length) that isn't a number, or is over MAX_BODY, is refused. What follows is left for the
+ * next reader.
+ */
 function readResponse(stream, timeoutMs) {
     return new Promise((resolve, reject) => {
-        let pending = Buffer.alloc(0);
-        let head = null;
-        const done = (error, value) => {
+        // The status line and headers, copied in as they come.
+        const head = Buffer.alloc(MAX_HEAD);
+        let filled = 0;
+        let response = null;
+        // How much of the body is still to come, and what came after it.
+        let body = 0;
+        let rest = null;
+        const done = (error) => {
             clearTimeout(timer);
             stream.off('data', onData);
             stream.off('error', onError);
             stream.off('close', onClose);
             // Paused before anything left over goes back, so that it waits for whoever reads next.
             stream.pause();
-            if (pending.length) {
-                stream.unshift(pending);
+            if (rest?.length) {
+                stream.unshift(rest);
             }
-            error ? reject(error) : resolve(value);
+            error ? reject(error) : resolve(response);
         };
         const onError = (e) => done(e);
         const onClose = () => done(new Error('the gateway closed the connection'));
         const timer = setTimeout(() => done(new Error('the gateway didn\'t answer in time')), timeoutMs);
         const onData = (chunk) => {
-            pending = Buffer.concat([pending, chunk]);
-            if (!head) {
-                const end = pending.indexOf('\r\n\r\n');
+            if (!response) {
+                // Only what is new is searched, from three bytes back: the blank line can straddle two pieces.
+                const from = Math.max(0, filled - 3);
+                const start = filled;
+                filled += chunk.copy(head, filled);
+                const end = head.subarray(0, filled).indexOf('\r\n\r\n', from);
                 if (end < 0) {
-                    if (pending.length > 64 * 1024) {
+                    if (filled === MAX_HEAD) {
                         done(new Error('the gateway\'s answer isn\'t HTTP'));
                     }
                     return;
                 }
-                const lines = pending.subarray(0, end).toString('latin1').split('\r\n');
+                const lines = head.subarray(0, end).toString('latin1').split('\r\n');
                 const status = Number(/^HTTP\/1\.[01] (\d{3})/.exec(lines[0])?.[1]);
-                if (!status) {
+                // A CR or LF that doesn't end a line is no HTTP a gateway sends.
+                if (!status || lines.some(line => line.includes('\r') || line.includes('\n'))) {
                     return done(new Error('the gateway\'s answer isn\'t HTTP'));
                 }
                 const headers = new Map();
                 for (const line of lines.slice(1)) {
-                    const m = /^([^:]+):\s*(.*)$/.exec(line);
-                    if (m) {
-                        headers.set(m[1].toLowerCase(), [...headers.get(m[1].toLowerCase()) ?? [], m[2]]);
+                    // Split at the first colon, the value trimmed: no pattern whose parts can take the same characters,
+                    // which a long line can make cost the square of its length.
+                    const colon = line.indexOf(':');
+                    const name = colon > 0 ? line.slice(0, colon).toLowerCase() : '';
+                    if (HEADER_NAME.test(name)) {
+                        const values = headers.get(name) ?? [];
+                        values.push(line.slice(colon + 1).trim());
+                        headers.set(name, values);
                     }
                 }
-                pending = pending.subarray(end + 4);
-                // A switch of protocols has no body; other answers say how long theirs is.
-                head = { status, headers, body: status === 101 ? 0 : Number(headers.get('content-length')?.[0] ?? 0) };
+                // Only a 401's page has to be got past: a sign-in round follows it on the same connection. Any other
+                // answer ends the sign-in, connection and all (and a switch of protocols has no body).
+                const length = status === 401 ? (headers.get('content-length')?.[0] ?? '0').trim() : '0';
+                if (!/^\d{1,9}$/.test(length) || Number(length) > MAX_BODY) {
+                    return done(new Error('the gateway\'s answer is malformed or too large'));
+                }
+                response = { status, headers };
+                body = Number(length);
+                // What this piece has after the blank line.
+                chunk = chunk.subarray(end + 4 - start);
             }
-            if (pending.length >= head.body) {
-                pending = pending.subarray(head.body);
-                done(null, { status: head.status, headers: head.headers });
+            if (chunk.length < body) {
+                body -= chunk.length;
+                return;
             }
+            rest = chunk.subarray(body);
+            done(null);
         };
         stream.on('data', onData);
         stream.on('error', onError);
@@ -295,7 +409,7 @@ function endPointBinding(certificate) {
     return Buffer.concat([Buffer.from('tls-server-end-point:', 'latin1'), (0, crypto_1.createHash)(hash).update(certificate).digest()]);
 }
 /** Upgrades the connection to the gateway's WebSocket, signing in with NTLM on the way. */
-async function upgrade(stream, gateway, account, certificate, timeoutMs) {
+async function upgrade(stream, gateway, account, certificate, timeoutMs, proceed = () => { }) {
     const key = (0, crypto_1.randomBytes)(16).toString('base64');
     const connection = `{${(0, crypto_1.randomUUID)().toUpperCase()}}`;
     const request = (authorization) => [
@@ -310,6 +424,7 @@ async function upgrade(stream, gateway, account, certificate, timeoutMs) {
         '', '',
     ].join('\r\n');
     const negotiate = (0, ntlm_1.negotiateMessage)();
+    proceed();
     stream.write(request(negotiate));
     const first = await readResponse(stream, timeoutMs);
     if (first.status !== 401) {
@@ -323,6 +438,7 @@ async function upgrade(stream, gateway, account, certificate, timeoutMs) {
             : `the gateway doesn't offer an NTLM sign-in (it offers: ${offered.map(v => v.split(' ')[0]).join(', ') || 'nothing'})`);
     }
     const challengeMessage = Buffer.from(challenge, 'base64');
+    proceed();
     stream.write(request((0, ntlm_1.authenticateMessage)(negotiate, challengeMessage, {
         ...account, channelBinding: endPointBinding(certificate), targetName: `HTTP/${gateway.host}`,
     })));
@@ -344,36 +460,63 @@ async function upgrade(stream, gateway, account, certificate, timeoutMs) {
 /**
  * Opens a stream to target.host:target.port through the gateway. `open` gives a TCP stream to the gateway (directly, or
  * through an SSH host). `checkCertificate` decides on the gateway's certificate before the account is used: it gets
- * the SHA-256 fingerprint (`AB:CD:…`) and whether the certificate is valid for the gateway's name by this computer's
- * certificate authorities, and throws to refuse.
+ * the SHA-256 fingerprint (`AB:CD:…`), whether the certificate is valid for the gateway's name by this computer's
+ * certificate authorities (see certificateAuthorities), why not (Node's code for it, '' when it is), and what the
+ * certificate says of itself (see CertificateDetails), and throws to refuse.
  */
 async function openThroughGateway(open, gateway, account, target, checkCertificate, options = {}) {
     const log = options.log ?? (() => null);
     const timeoutMs = options.timeoutMs ?? 20000;
     const targetName = `${target.host}:${target.port}`;
+    const signal = options.signal;
+    // Nothing more goes to the gateway once what it is for has gone: checked before each step and message of the
+    // sign-in, and the connection ends then, which also ends what waits on it (the TLS handshake, an answer).
+    const proceed = () => {
+        if (signal?.aborted) {
+            throw new Error('the desktop was closed meanwhile');
+        }
+    };
+    proceed();
     const raw = await open();
     let secure = null;
+    const abort = () => {
+        secure?.destroy();
+        raw.destroy();
+    };
+    signal?.addEventListener('abort', abort, { once: true });
     try {
+        proceed();
         // A name is sent (SNI), an address isn't; either is what the certificate is checked for.
-        const named = !/^[\d.]+$|:/.test(gateway.host);
-        const socket = tls.connect({ socket: raw, host: gateway.host, rejectUnauthorized: false, ...named ? { servername: gateway.host } : {}, ...options.tls });
+        const named = !(0, net_1.isIP)(gateway.host);
+        const socket = tls.connect({
+            socket: raw, host: gateway.host, rejectUnauthorized: false, ca: (0, authorities_1.certificateAuthorities)(),
+            ...named ? { servername: gateway.host } : {}, ...options.tls,
+        });
         secure = socket;
+        // A step like the others: a gateway that takes the connection and never answers TLS would keep it for good.
+        let timer;
         await new Promise((resolve, reject) => {
+            timer = setTimeout(() => reject(new Error('the gateway didn\'t answer in time (TLS)')), timeoutMs);
             socket.once('secureConnect', resolve);
             socket.once('error', reject);
             socket.once('close', () => reject(new Error('the gateway closed the connection during TLS')));
-        });
-        const certificate = socket.getPeerCertificate();
+        }).finally(() => clearTimeout(timer));
+        const certificate = socket.getPeerCertificate(true);
         if (!certificate?.fingerprint256) {
             throw new Error('the gateway sent no certificate');
         }
-        await checkCertificate(certificate.fingerprint256, socket.authorized);
-        await upgrade(socket, gateway, account, certificate.raw, timeoutMs);
+        // Where its chain stands and whether it is for the gateway's name, which Node's code for why it isn't valid can
+        // hide (see certificateDetails).
+        const reason = socket.authorized ? '' : String(socket.authorizationError ?? '');
+        const checked = socket.authorized ? undefined : { name: gateway.host, authorities: options.tls?.ca ?? (0, authorities_1.certificateAuthorities)(), reason };
+        await checkCertificate(certificate.fingerprint256, socket.authorized, reason, (0, authorities_1.certificateDetails)(certificate, checked));
+        await upgrade(socket, gateway, account, certificate.raw, timeoutMs, proceed);
         log(`gateway: signed in to ${gateway.host}`);
         // From here on: WebSocket frames, the gateway's packets inside.
         let expecting = null;
         let stream = null;
         let ended = false;
+        let messages = 0;
         const end = (error) => {
             if (ended) {
                 return;
@@ -395,7 +538,12 @@ async function openThroughGateway(open, gateway, account, target, checkCertifica
                 // nothing to answer: the gateway only checks the line
             }
             else if (type === PKT_SERVICE_MESSAGE) {
-                log(`gateway: its administrator's message: ${body.subarray(body.length >= 2 ? 2 : 0).toString('utf16le').replace(/\0+$/, '').slice(0, 300)}`);
+                if (++messages <= MAX_SERVICE_MESSAGES) {
+                    log(`gateway: its administrator's message: ${serviceMessage(body)}`);
+                }
+                else if (messages === MAX_SERVICE_MESSAGES + 1) {
+                    log(`gateway: more messages from its administrator; past ${MAX_SERVICE_MESSAGES}, they aren't logged`);
+                }
             }
             else if (type === PKT_CLOSE_CHANNEL) {
                 socket.write(wsFrame(packet(PKT_CLOSE_CHANNEL_RESPONSE, Buffer.alloc(8))));
@@ -409,7 +557,7 @@ async function openThroughGateway(open, gateway, account, target, checkCertifica
         });
         const frames = wsReader({
             data: payload => packets(payload),
-            ping: payload => socket.write(wsFrame(payload, 0xa)),
+            ping: pongs(socket, () => ended),
             close: () => end(),
         });
         socket.on('data', (chunk) => {
@@ -434,6 +582,14 @@ async function openThroughGateway(open, gateway, account, target, checkCertifica
                 resolve: body => { clearTimeout(timer); resolve(body); },
                 reject: e => { clearTimeout(timer); reject(e); },
             };
+            try {
+                proceed();
+            }
+            catch (e) {
+                expecting = null;
+                clearTimeout(timer);
+                return reject(e);
+            }
             socket.write(wsFrame(send));
         });
         const refused = (code, step) => {
@@ -488,5 +644,8 @@ async function openThroughGateway(open, gateway, account, target, checkCertifica
         raw.destroy();
         throw e;
     }
+    finally {
+        // Only for the sign-in and the tunnel's setup: the tunnel itself ends with the client's connection (see track).
+        signal?.removeEventListener('abort', abort);
+    }
 }
-//# sourceMappingURL=gateway.js.map

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