tabby-rdp 0.5.1 → 0.5.3

package/dist/desktopForm.js

@@ -10,6 +10,7 @@ const desktops_1 = require("./desktops");
 const gateway_1 = require("./gateway");
 const osd_1 = require("./osd");
 const wake_1 = require("./wake");
+const hostCompat_1 = require("./hostCompat");
 /** host:port, [v6]:port, or a bare host (RDP's 3389); null if it doesn't look like an address. */
 function parseAddress(text) {
     // No '#' in a host: session and trust keys are split on it (see keyParts).
@@ -109,13 +110,13 @@ function askDesktop(pane, options) {
         account.hidden = account.options.length < 2;
     }
     ownAccount();
-    // The gateway's own account: offered once there is a gateway and a saved account to choose.
+    // The gateway's own account, including a separate prompt when no saved account is chosen.
     const gateway = field('gateway');
     const gatewayAccount = field('gatewayAccount');
     gateway.value = (0, desktops_1.configText)(initial.gateway);
-    gatewayAccount.append(new Option('Gateway account: the same as the desktop\'s', ''), ...accounts.map(a => new Option(`Gateway account: ${a.name} (${(0, accounts_1.signInName)(a)})`, a.id)));
+    gatewayAccount.append(new Option('Gateway account: the same as the desktop\'s', ''), new Option('Gateway account: ask when connecting', accounts_1.ASK_GATEWAY_ACCOUNT), ...accounts.map(a => new Option(`Gateway account: ${a.name} (${(0, accounts_1.signInName)(a)})`, a.id)));
     const initialGatewayAccount = (0, desktops_1.configText)(initial.gatewayAccount);
-    if (initialGatewayAccount && !accounts.some(a => a.id === initialGatewayAccount)) {
+    if (initialGatewayAccount && initialGatewayAccount !== accounts_1.ASK_GATEWAY_ACCOUNT && !accounts.some(a => a.id === initialGatewayAccount)) {
         gatewayAccount.append(new Option('(a saved account that no longer exists)', initialGatewayAccount));
     }
     gatewayAccount.value = initialGatewayAccount;
@@ -134,7 +135,7 @@ function askDesktop(pane, options) {
     }
     pane.appendChild(overlay);
     // Same as a desktop layer: the terminal underneath can't take the keyboard while the form shows.
-    const inputs = Array.from(pane.querySelectorAll('textarea.xterm-helper-textarea')).filter(t => !t.disabled);
+    const inputs = (0, hostCompat_1.terminalInputs)(pane).filter(t => !t.disabled);
     inputs.forEach(t => { t.disabled = true; });
     const focusForm = () => {
         if (!form.contains(document.activeElement)) {

package/dist/diskStorage.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskStorage = exports.DISK_PATH = exports.DownloadBudget = exports.MAX_DOWNLOAD_BYTES = void 0;
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+/** The provider's supported file-size limit. Files are streamed; this much memory is never reserved. */
+exports.MAX_DOWNLOAD_BYTES = 2 * 1024 * 1024 * 1024;
+const HANDLE_PENDING_BYTES = 16 * 1024 * 1024;
+const WINDOW_PENDING_BYTES = 64 * 1024 * 1024;
+const MIN_WRITE_COST = 64 * 1024;
+const MAX_HANDLES = 32;
+const INIT_TIMEOUT_MS = 15000; // earlier than the provider's 30-second initialization deadline
+/** Both bytes and tasks are bounded: tiny chunks must not make an arbitrarily long promise queue. */
+class DownloadBudget {
+    constructor(limit = WINDOW_PENDING_BYTES) {
+        this.limit = limit;
+        this.pending = 0;
+    }
+    reserve(bytes) {
+        const cost = Math.max(MIN_WRITE_COST, bytes);
+        if (cost > this.limit - this.pending) {
+            throw new Error('Too much download data is waiting to be saved.');
+        }
+        this.pending += cost;
+        let held = true;
+        return () => { if (held) {
+            held = false;
+            this.pending -= cost;
+        } };
+    }
+}
+exports.DownloadBudget = DownloadBudget;
+const windowBudget = new DownloadBudget();
+exports.DISK_PATH = Symbol('tabby-rdp download');
+class DownloadFile {
+    constructor(file, handle, expected, ownBudget, sharedBudget, ended) {
+        this.file = file;
+        this.handle = handle;
+        this.expected = expected;
+        this.ownBudget = ownBudget;
+        this.sharedBudget = sharedBudget;
+        this.ended = ended;
+        this.bytesWritten = 0;
+        this.accepted = 0;
+        this.state = 'open';
+        this.tail = Promise.resolve();
+    }
+    get cancelled() { return this.state === 'aborting' || this.state === 'aborted'; }
+    write(chunk) {
+        let releaseOwn;
+        let releaseShared;
+        let data;
+        try {
+            if (this.state !== 'open') {
+                throw new Error('The download is closed for writing.');
+            }
+            if (!(chunk instanceof Uint8Array) || !chunk.byteLength) {
+                throw new Error('A download write must contain bytes.');
+            }
+            if (chunk.byteLength > this.expected - this.accepted) {
+                throw new Error('The download exceeds its expected size.');
+            }
+            releaseOwn = this.ownBudget.reserve(chunk.byteLength);
+            releaseShared = this.sharedBudget.reserve(chunk.byteLength);
+            // Hold only the admitted bytes, not a small view retaining a much larger backing buffer.
+            data = Uint8Array.from(chunk);
+            this.accepted += data.byteLength;
+        }
+        catch (error) {
+            releaseOwn?.();
+            releaseShared?.();
+            if (this.state === 'open') {
+                this.fail(error);
+            }
+            return Promise.reject(error);
+        }
+        const writing = this.tail.then(async () => {
+            if (this.failure || this.cancelled) {
+                throw this.failure ?? new Error('The download was cancelled.');
+            }
+            await this.handle.appendFile(data);
+            this.bytesWritten += data.byteLength;
+            if (this.cancelled) {
+                throw new Error('The download was cancelled.');
+            }
+        }).finally(() => { releaseOwn(); releaseShared(); });
+        this.tail = writing.catch(error => { this.fail(error); });
+        return writing;
+    }
+    fail(error) {
+        this.failure ??= error instanceof Error ? error : new Error('The download could not be written.');
+        // Cleanup waits for already-started native I/O. The error is returned by write/finalize; dispose retries cleanup.
+        void this.abort().catch(() => null);
+    }
+    close() {
+        return this.closed ??= this.handle.close().finally(this.ended);
+    }
+    finalize() {
+        if (this.cancelled) {
+            return Promise.reject(this.failure ?? new Error('The download was cancelled.'));
+        }
+        if (this.finalized) {
+            return this.finalized;
+        }
+        if (this.state !== 'open') {
+            return Promise.reject(this.failure ?? new Error('The download is closed.'));
+        }
+        this.state = 'finalizing'; // no further admission; writes already accepted still finish in order
+        this.finalized = this.tail.then(async () => {
+            if (this.failure || this.state !== 'finalizing') {
+                throw this.failure ?? new Error('The download was cancelled.');
+            }
+            if (this.bytesWritten !== this.expected) {
+                throw new Error('The download ended before its expected size.');
+            }
+            await this.close();
+            if (this.state !== 'finalizing') {
+                throw new Error('The download was cancelled.');
+            }
+            this.state = 'finalized';
+            return Object.assign(new Blob([]), { [exports.DISK_PATH]: this.file });
+        }).catch(async (error) => { await this.abort().catch(() => null); throw error; });
+        return this.finalized;
+    }
+    abort() {
+        if (this.aborted) {
+            return this.aborted;
+        }
+        this.state = 'aborting';
+        this.aborted = this.tail.then(async () => {
+            try {
+                await this.close();
+            }
+            finally {
+                await fs.promises.rm(this.file, { force: true });
+            }
+            this.state = 'aborted';
+        });
+        return this.aborted;
+    }
+}
+/** Private temporary storage, bounded before asynchronous I/O, with ordered completion and cancellation. */
+class DiskStorage {
+    /** Smaller budgets/deadlines can be supplied by local filesystem tests without large allocations. */
+    constructor(options = {}) {
+        this.options = options;
+        this.name = 'disk';
+        this.dir = null;
+        this.count = 0;
+        this.disposed = false;
+        this.files = new Set();
+        this.creating = new Set();
+    }
+    createWriteHandle(_fileName, expectedSize) {
+        if (this.disposed) {
+            return Promise.reject(new Error('The download storage is closed.'));
+        }
+        if (!Number.isSafeInteger(expectedSize) || expectedSize < 0 || expectedSize > exports.MAX_DOWNLOAD_BYTES) {
+            return Promise.reject(new Error('The download has no supported expected size.'));
+        }
+        if (this.creating.size + this.files.size >= MAX_HANDLES) {
+            return Promise.reject(new Error('Too many downloads are open.'));
+        }
+        let expired = false;
+        let timer;
+        const making = (async () => {
+            this.dir ??= fs.promises.mkdtemp(path.join(os.tmpdir(), 'tabby-rdp-'));
+            const dir = await this.dir;
+            if (this.disposed || expired) {
+                throw new Error('Download initialization was cancelled.');
+            }
+            const file = path.join(dir, String(++this.count));
+            let handle;
+            try {
+                const opened = await fs.promises.open(file, 'wx', 0o600);
+                handle = new DownloadFile(file, opened, expectedSize, new DownloadBudget(this.options.pendingBytes ?? HANDLE_PENDING_BYTES), this.options.budget ?? windowBudget, () => this.files.delete(handle));
+                this.files.add(handle);
+                if (this.disposed || expired) {
+                    throw new Error('Download initialization was cancelled.');
+                }
+                return handle;
+            }
+            catch (error) {
+                await handle?.abort().catch(() => null);
+                await fs.promises.rm(file, { force: true }).catch(() => null);
+                throw error;
+            }
+        })();
+        this.creating.add(making);
+        void making.then(() => this.creating.delete(making), () => this.creating.delete(making));
+        const deadline = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => { expired = true; reject(new Error('Download storage did not open in time.')); }, this.options.initTimeoutMs ?? INIT_TIMEOUT_MS);
+        });
+        return Promise.race([making, deadline]).finally(() => clearTimeout(timer));
+    }
+    dispose() {
+        this.disposed = true; // also invalidates initialization still waiting on native filesystem work
+        this.disposing ??= (async () => {
+            // Abort before awaiting initialization: accepted writes stop taking more data immediately.
+            const aborting = [...this.files].map(file => file.abort());
+            await Promise.allSettled([...this.creating, ...aborting]);
+            if (this.dir) {
+                await this.dir.then(dir => fs.promises.rm(dir, { recursive: true, force: true }), () => null);
+            }
+        })();
+        // The provider does not await dispose(); callers that do still receive its actual cleanup result.
+        void this.disposing.catch(() => null);
+        return this.disposing;
+    }
+}
+exports.DiskStorage = DiskStorage;

package/dist/fileTransfer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileTransfer = exports.STYLE = exports.DiskStorage = exports.MIN_COST = exports.MAX_WAITING = exports.MAX_IN_FLIGHT = exports.MAX_RANGE = exports.MAX_LINKS = exports.MAX_LOOKED_AT = exports.MAX_ENTRIES = void 0;
+exports.FileTransfer = exports.STYLE = exports.MIN_COST = exports.MAX_WAITING = exports.MAX_IN_FLIGHT = exports.MAX_RANGE = exports.MAX_LINKS = exports.MAX_LOOKED_AT = exports.MAX_ENTRIES = exports.DiskStorage = void 0;
 exports.clipboardPaths = clipboardPaths;
 exports.entriesFor = entriesFor;
 exports.safeName = safeName;
@@ -14,6 +14,9 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 const child_process_1 = require("child_process");
+const diskStorage_1 = require("./diskStorage");
+var diskStorage_2 = require("./diskStorage");
+Object.defineProperty(exports, "DiskStorage", { enumerable: true, get: function () { return diskStorage_2.DiskStorage; } });
 /**
  * Limits for a folder copied here and pasted with ⌘V: entries offered, and how deep. (IronRDP walks dropped folders
  * itself, with limits of its own.)
@@ -400,56 +403,6 @@ function entriesFor(paths) {
     }
     return { entries, leftOut, cut };
 }
-/** On a download's result: the temporary file holding it (see DiskStorage). */
-const DISK_PATH = Symbol('tabby-rdp download');
-/**
- * Where downloads are kept while they arrive (IronRDP's FileStorageBackend): a file each in a private temporary
- * folder, written chunk by chunk, so a large file takes its size on disk rather than twice that in memory. The
- * result handed back is an empty Blob that names the file; saveAll moves it into place.
- */
-class DiskStorage {
-    constructor() {
-        this.name = 'disk';
-        this.dir = null;
-        this.count = 0;
-    }
-    async createWriteHandle(_fileName, _expectedSize) {
-        this.dir ??= fs.promises.mkdtemp(path.join(os.tmpdir(), 'tabby-rdp-')); // 0700, a name nobody could prepare
-        const file = path.join(await this.dir, String(++this.count));
-        const handle = await fs.promises.open(file, 'wx', 0o600);
-        let bytesWritten = 0;
-        let open = true;
-        const close = async () => {
-            if (open) {
-                open = false;
-                await handle.close();
-            }
-        };
-        return {
-            get bytesWritten() { return bytesWritten; },
-            async write(chunk) {
-                await handle.appendFile(chunk);
-                bytesWritten += chunk.length;
-            },
-            async finalize() {
-                await close();
-                return Object.assign(new Blob([]), { [DISK_PATH]: file });
-            },
-            async abort() {
-                await close().catch(() => null);
-                await fs.promises.rm(file, { force: true });
-            },
-        };
-    }
-    async dispose() {
-        const dir = this.dir;
-        this.dir = null;
-        if (dir) {
-            await dir.then(d => fs.promises.rm(d, { recursive: true, force: true }), () => null);
-        }
-    }
-}
-exports.DiskStorage = DiskStorage;
 exports.STYLE = `
 .trd-toast { position: absolute; top: 12px; right: 12px; z-index: 2; max-width: min(420px, calc(100% - 24px));
     display: flex; gap: 10px; align-items: center; padding: 8px 10px; border-radius: 6px;
@@ -534,7 +487,7 @@ class FileTransfer {
         this.overlapping = false;
         /** Whether an answer for a request that is no more was dropped (logged once: see the constructor). */
         this.stray = false;
-        this.provider = new rdp.RdpFileTransferProvider({ storageBackend: new DiskStorage() });
+        this.provider = new rdp.RdpFileTransferProvider({ storageBackend: new diskStorage_1.DiskStorage() });
         // The remote can ask again, later, for files offered from here: their contents go only while this computer's
         // clipboard goes there. The provider's extensions call the method on it, so this one takes its place.
         this.serve = this.provider.handleFileContentsRequest.bind(this.provider);
@@ -1263,7 +1216,7 @@ async function foldersInside(dir, folder, made = []) {
 async function place(dir, wanted, blob, made = []) {
     const folder = await foldersInside(dir, path.dirname(wanted), made);
     const { name, ext } = path.parse(wanted);
-    const temporary = blob[DISK_PATH];
+    const temporary = blob[diskStorage_1.DISK_PATH];
     // Writes the file at `target`, a name that was free just before: false if it has been taken since (EEXIST).
     const write = async (target) => {
         if (temporary) {

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,108 +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: 'A certificate this computer can\'t verify, or one that has changed',
         match: /certificate/i,
-        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.`,
     },
     {
         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. 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. 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.`,
     },
     {
         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. */
@@ -173,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. */
@@ -187,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);
@@ -280,5 +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);

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/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 {
@@ -62,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 },

package/dist/ironrdp.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IronRDPLoader = void 0;
+/** Loads and compiles once; every connection attempt gets fresh glue, classes, memory and allocator. */
+class IronRDPLoader {
+    constructor(load) {
+        this.load = load;
+        this.source = null;
+    }
+    async create(level) {
+        const pending = this.source ??= this.load();
+        let source;
+        try {
+            source = await pending;
+        }
+        catch (error) {
+            if (this.source === pending) {
+                this.source = null;
+            }
+            throw error;
+        }
+        // A failed/trapped instance does not invalidate shared compiled code or another desktop's instance.
+        return source.createBackend(source.module, level);
+    }
+}
+exports.IronRDPLoader = IronRDPLoader;

package/dist/keyboard.js

@@ -117,7 +117,18 @@ let DesktopKeyboard = class DesktopKeyboard {
     route(event) {
         const pane = this.startedOn.has(event) ? this.startedOn.get(event) : this.coveredPane();
         const focused = document.activeElement;
-        if (!pane || focused?.tagName !== 'IRON-REMOTE-DESKTOP' || !pane.element.nativeElement.contains(focused)) {
+        if (focused?.tagName !== 'IRON-REMOTE-DESKTOP') {
+            return;
+        }
+        if (!pane || !pane.element.nativeElement.contains(focused)) {
+            // A desktop has the focus though its pane isn't the one the user is in (see
+            // RemoteDesktopService.letGoUnlessInFront, which takes it back a moment after the pane is left): IronRDP,
+            // whose listener comes after this one and only looks at the focus, would send it the key, view only or not.
+            // It goes nowhere instead, a keyup too: IronRDP lets go of nothing as its canvas loses the focus (only as
+            // the window does, or as the pointer leaves the canvas), so the keys the desktop still holds on the remote
+            // are let go of as the focus is taken back, this one among them.
+            event.stopImmediatePropagation();
+            event.preventDefault();
             return;
         }
         this.routing = pane;