tabby-rdp 0.4.1 → 0.5.1

package/dist/desktopForm.js

@@ -5,10 +5,15 @@ exports.formatAddress = formatAddress;
 exports.askDesktop = askDesktop;
 const accounts_1 = require("./accounts");
 const accountForm_1 = require("./accountForm");
+const clipboard_1 = require("./clipboard");
+const desktops_1 = require("./desktops");
+const gateway_1 = require("./gateway");
+const osd_1 = require("./osd");
 const wake_1 = require("./wake");
 /** host:port, [v6]:port, or a bare host (RDP's 3389); null if it doesn't look like an address. */
 function parseAddress(text) {
-    const m = /^\[([^\]]+)\](?::(\d+))?$|^([^:\s]+)(?::(\d+))?$/.exec(text.trim());
+    // No '#' in a host: session and trust keys are split on it (see keyParts).
+    const m = /^\[([^\]#]+)\](?::(\d+))?$|^([^:\s#]+)(?::(\d+))?$/.exec(text.trim());
     const host = m?.[1] ?? m?.[3];
     const port = Number(m?.[2] ?? m?.[4] ?? 3389);
     return host && Number.isInteger(port) && port >= 1 && port <= 65535 ? { host, port } : null;
@@ -19,7 +24,7 @@ function formatAddress(host, port) {
 }
 /** An entry's `wake` as the form's field shows it: the VM's name, or the MAC address. */
 function wakeTextOf(entry) {
-    return entry.wake?.vm ?? entry.wake?.mac ?? '';
+    return (0, desktops_1.configText)(entry.wake?.vm) || (0, desktops_1.configText)(entry.wake?.mac);
 }
 /**
  * "Add a desktop behind <host>" and "Edit": a form over the pane (plain DOM, like the sign-in form; uses its styles).
@@ -47,7 +52,10 @@ function askDesktop(pane, options) {
                 <select class="form-control" name="account" title="Saved accounts are added in Settings › Remote Desktop › Accounts"></select>
                 <input class="form-control" name="username" placeholder="User name (optional; asked when connecting)" spellcheck="false">
                 <input class="form-control" name="domain" placeholder="Domain (optional)" spellcheck="false">
+                <input class="form-control" name="gateway" placeholder="RD Gateway (optional), as seen from the host, e.g. rdgw.example.com" title="A Remote Desktop Gateway to reach the desktop through (HTTPS, port 443 unless given); the address above is then as the gateway sees it" spellcheck="false">
+                <select class="form-control" name="gatewayAccount" title="A gateway that takes another account than the desktop: a saved account for it"></select>
                 <input class="form-control" name="wake" placeholder="Start it when off (optional): libvirt VM name, or MAC address" title="A libvirt VM on the host, started with virsh; or a MAC address to wake over the network from the host" spellcheck="false">
+                <select class="form-control" name="clipboard" title="Which ways text, pictures and files copied on either side go between this computer and the desktop. Applies on the next connection"></select>
                 <div class="trd-signin-buttons">
                     <button type="button" class="btn btn-secondary" name="cancel">Cancel</button>
                     <button type="submit" class="btn btn-primary"></button>
@@ -60,24 +68,36 @@ function askDesktop(pane, options) {
     form.querySelector('button[type=submit]').textContent = options.action;
     const error = form.querySelector('.trd-signin-error');
     const initial = options.entry;
-    field('name').value = initial.name ?? '';
+    // Each field as text whatever the entry holds (see configText): a field makes text of what it is given, and a value
+    // that can't be made text (a hand edit's, config sync's) would keep the form from opening, and the entry from being
+    // put right here.
+    field('name').value = (0, desktops_1.configText)(initial.name);
     const via = field('via');
-    via.value = initial.via ?? '';
+    via.value = (0, desktops_1.configText)(initial.via);
     via.hidden = !options.hosts;
     form.querySelector('datalist').append(...(options.hosts ?? []).map(h => new Option(h)));
-    field('address').value = formatAddress(initial.host ?? '127.0.0.1', Number(initial.port ?? 3389));
+    field('address').value = formatAddress((0, desktops_1.configText)(initial.host ?? '127.0.0.1'), (0, osd_1.configNumber)(initial.port ?? 3389));
     field('kind').value = initial.kind === 'gnome' || initial.kind === 'xrdp' ? initial.kind : 'windows';
-    field('username').value = initial.username ?? '';
-    field('domain').value = initial.domain ?? '';
+    // A VM saved from the host's list is xrdp on the host's word (see xrdpFromHost), which is a choice of its own here:
+    // kept as long as it is chosen, so that the desktop still asks before signing in without NLA. Any kind picked is
+    // the user's, xrdp included.
+    if ((0, desktops_1.xrdpFromHost)(initial)) {
+        const kind = field('kind');
+        kind.prepend(new Option(`xrdp, as ${(0, desktops_1.configText)(initial.via) || 'the host'} reported (asks before signing in without NLA)`, ''));
+        kind.value = '';
+    }
+    field('username').value = (0, desktops_1.configText)(initial.username);
+    field('domain').value = (0, desktops_1.configText)(initial.domain);
     field('wake').value = wakeTextOf(initial);
     // A saved account in place of a user name and domain of its own. Without any saved, the choice isn't shown.
     const account = field('account');
     const accounts = options.accounts ?? [];
     account.append(new Option('Ask for the account when connecting', ''), ...accounts.map(a => new Option(`Sign in with ${a.name} (${(0, accounts_1.signInName)(a)})`, a.id)));
-    if (initial.account && !accounts.some(a => a.id === initial.account)) {
-        account.append(new Option('(a saved account that no longer exists)', initial.account));
+    const initialAccount = (0, desktops_1.configText)(initial.account);
+    if (initialAccount && !accounts.some(a => a.id === initialAccount)) {
+        account.append(new Option('(a saved account that no longer exists)', initialAccount));
     }
-    account.value = initial.account ?? '';
+    account.value = initialAccount;
     const ownAccount = () => {
         field('username').hidden = field('domain').hidden = !!account.value && account.value !== '__new__';
     };
@@ -89,6 +109,26 @@ 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.
+    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)));
+    const initialGatewayAccount = (0, desktops_1.configText)(initial.gatewayAccount);
+    if (initialGatewayAccount && !accounts.some(a => a.id === initialGatewayAccount)) {
+        gatewayAccount.append(new Option('(a saved account that no longer exists)', initialGatewayAccount));
+    }
+    gatewayAccount.value = initialGatewayAccount;
+    const gatewayChanged = () => {
+        gatewayAccount.hidden = !gateway.value.trim() || gatewayAccount.options.length < 2;
+    };
+    gateway.addEventListener('input', gatewayChanged);
+    gatewayChanged();
+    // Its own clipboard sharing, or the setting's (named, as it is now).
+    const clipboard = field('clipboard');
+    const lower = (mode) => clipboard_1.CLIPBOARD_LABELS[mode].toLowerCase();
+    clipboard.append(new Option(`Clipboard: as in Settings (${lower(options.clipboard)})`, ''), ...Object.keys(clipboard_1.CLIPBOARD_LABELS).map(mode => new Option(`Clipboard: ${lower(mode)}`, mode)));
+    clipboard.value = (0, clipboard_1.ownClipboard)(initial.clipboard) ?? '';
     if (getComputedStyle(pane).position === 'static') {
         pane.style.position = 'relative';
     }
@@ -129,6 +169,12 @@ function askDesktop(pane, options) {
                 field('address').focus();
                 return;
             }
+            const gatewayText = gateway.value.trim();
+            if (gatewayText && !(0, gateway_1.parseGateway)(gatewayText)) {
+                error.textContent = 'The gateway should be a name or address, with :port if it isn\'t 443.';
+                gateway.focus();
+                return;
+            }
             if (options.hosts && !via.value.trim()) {
                 error.textContent = 'Which SSH host is it behind?';
                 via.focus();
@@ -137,6 +183,8 @@ function askDesktop(pane, options) {
             const username = field('username').value.trim();
             const domain = field('domain').value.trim();
             const kind = field('kind').value;
+            // '': the kind the host reported, still its word (see above).
+            const picked = kind !== '';
             const wakeText = field('wake').value.trim();
             // An unchanged wake keeps what the field doesn't show (a Wake-on-LAN broadcast address and port).
             const wake = wakeText && wakeText === wakeTextOf(initial) ? initial.wake : (0, wake_1.wakeFromText)(wakeText);
@@ -147,17 +195,29 @@ function askDesktop(pane, options) {
                 name,
                 host: address.host,
                 port: address.port,
-                kind: kind === 'gnome' || kind === 'xrdp' ? kind : 'windows',
+                kind: !picked ? initial.kind : kind === 'gnome' || kind === 'xrdp' ? kind : 'windows',
                 username: username || undefined,
                 domain: domain || undefined,
                 account: account.value && account.value !== '__new__' ? account.value : undefined,
                 wake,
+                gateway: gatewayText || undefined,
+                gatewayAccount: gatewayText && gatewayAccount.value || undefined,
+                clipboard: clipboard.value || undefined,
             };
-            for (const key of ['username', 'domain', 'account', 'wake']) {
+            for (const key of ['username', 'domain', 'account', 'wake', 'gateway', 'gatewayAccount', 'clipboard']) {
                 if (entry[key] === undefined) {
                     delete entry[key];
                 }
             }
+            // A kind left as the host reported it stays marked so; one picked is the user's, and is marked so only where
+            // the entry would otherwise be taken for a VM saved before the mark existed (see xrdpFromHost).
+            delete entry.kindFromHost;
+            if (!picked) {
+                entry.kindFromHost = true;
+            }
+            else if ((0, desktops_1.xrdpFromHost)(entry)) {
+                entry.kindFromHost = false;
+            }
             const refused = options.check?.(entry);
             if (refused) {
                 error.textContent = refused;
@@ -174,4 +234,3 @@ function askDesktop(pane, options) {
         });
     });
 }
-//# sourceMappingURL=desktopForm.js.map

package/dist/desktops.js

@@ -2,59 +2,140 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DIRECT_KEY = exports.OWN_DESKTOP = void 0;
 exports.viaMatches = viaMatches;
+exports.configText = configText;
 exports.specOf = specOf;
+exports.xrdpFromHost = xrdpFromHost;
+exports.hyperVSpec = hyperVSpec;
 exports.desktopsFor = desktopsFor;
 exports.desktopIdOf = desktopIdOf;
+exports.isDesktopEntry = isDesktopEntry;
+exports.entryText = entryText;
 exports.sessionKey = sessionKey;
+exports.xrdpUnasked = xrdpUnasked;
+exports.keyFromConfig = keyFromConfig;
+exports.isTargetKey = isTargetKey;
+exports.legacyKeyFromConfig = legacyKeyFromConfig;
+exports.keyFields = keyFields;
+exports.nestedKey = nestedKey;
+exports.shownKey = shownKey;
+exports.keyUser = keyUser;
+exports.keyParts = keyParts;
+exports.rekeyed = rekeyed;
+const clipboard_1 = require("./clipboard");
+const hyperv_1 = require("./hyperv");
+const osd_1 = require("./osd");
 const wake_1 = require("./wake");
 exports.OWN_DESKTOP = 'own';
-/** Whether a `via` value names this SSH target: its alias (label), hostname, user@hostname, or full key. */
+/**
+ * Whether a `via` value names this SSH target: its alias (label), hostname, user@hostname, or user@hostname:port, as ssh
+ * resolved them (or the key itself). Never a machine reached with ssh typed in a host's console: its name, its user and
+ * its hostname there are that host's word, which could name any host the user configured desktops behind (and with them
+ * their saved accounts). Only its own desktop opens through that host.
+ */
 function viaMatches(via, target) {
-    const v = via.trim().toLowerCase();
-    const key = target.key.toLowerCase(); // user@hostname:port
-    const userHost = key.replace(/:\d+$/, '');
-    const hostname = userHost.replace(/^[^@]*@/, '');
-    return !!v && [key, userHost, hostname, target.label.toLowerCase()].includes(v);
+    const v = configText(via).trim().toLowerCase();
+    if (!v || target.via !== undefined) {
+        return false;
+    }
+    const { user, host, port } = keyFields(target.key);
+    // Also what the add form wrote up to 0.5.0 for a user name with an `@` (alice@corp.example): all after the first.
+    const written = `${user}@${host}`.replace(/^[^@]*@/, '');
+    return [target.key, `${user}@${host}:${port}`, `${user}@${host}`, host, written, target.label].some(name => name.toLowerCase() === v);
+}
+/**
+ * A config value as text: a string as it is, a number written out. Anything else is none: String() of an object (a
+ * hand edit, config sync) runs its own conversions, which can throw, and every desktop listed with it would fail, as
+ * would every menu or list that shows it.
+ */
+function configText(value) {
+    return typeof value === 'string' ? value : typeof value === 'number' && Number.isFinite(value) ? String(value) : '';
 }
 /** The desktop an entry describes (a `remoteDesktop.desktops` entry, or an RDP profile's options), or null if unusable. */
 function specOf(extra) {
-    const port = Number(extra?.port || 3389);
+    // Its own clipboard sharing, or none (the setting's).
+    const clipboard = (0, clipboard_1.ownClipboard)(extra?.clipboard);
+    const own = clipboard ? { clipboard } : {};
+    const hyperv = (0, hyperv_1.vmId)(extra?.hyperv);
+    if (hyperv) {
+        return hyperVSpec(hyperv, configText(extra.name) || hyperv, {
+            username: configText(extra.username) || undefined,
+            domain: configText(extra.domain) || undefined,
+            account: configText(extra.account) || undefined,
+            ...own,
+        });
+    }
+    // From a number or text only: Number() of an object from the config runs its conversions, and can throw.
+    const port = (0, osd_1.configNumber)(extra?.port || 3389);
     if (!Number.isInteger(port) || port <= 0 || port > 65535) {
         return null;
     }
-    const host = String(extra.host || '127.0.0.1');
+    const host = extra.host ? configText(extra.host) : '127.0.0.1';
+    // No '#' in a host: it is part of the session and trust keys, which are split on '#' (see keyParts).
+    if (!host || host.includes('#')) {
+        return null;
+    }
+    const gateway = typeof extra.gateway === 'string' ? extra.gateway.trim() : '';
     return {
         id: `${host}:${port}`,
-        name: extra.name ? String(extra.name) : `${host}:${port}`,
+        name: configText(extra.name) || `${host}:${port}`,
         kind: extra.kind === 'gnome' || extra.kind === 'xrdp' ? extra.kind : 'windows',
+        kindTrusted: !xrdpFromHost(extra),
         host,
         port,
-        username: extra.username ? String(extra.username) : undefined,
-        domain: extra.domain ? String(extra.domain) : undefined,
-        account: extra.account ? String(extra.account) : undefined,
+        username: configText(extra.username) || undefined,
+        domain: configText(extra.domain) || undefined,
+        account: configText(extra.account) || undefined,
         wake: (0, wake_1.parseWake)(extra.wake),
+        ...gateway ? { gateway, gatewayAccount: configText(extra.gatewayAccount) || undefined } : {},
+        ...own,
     };
 }
+/**
+ * Whether an entry is of the xrdp kind on a host's word rather than the user's (see DesktopSpec.kindTrusted): a VM
+ * saved from the host's list as the host reported it (`kindFromHost`). Up to 0.5.0 those were saved without the mark,
+ * and one then looks like this: xrdp, started by its name when it is off (`wake.vm`, which the save always set). Such
+ * an entry is taken for the host's word too, unless the user has picked its kind in the form since (`kindFromHost:
+ * false`); a desktop of the user's that looks the same asks once before signing in without NLA.
+ */
+function xrdpFromHost(extra) {
+    return extra.kind === 'xrdp' && (extra.kindFromHost === true || extra.kindFromHost === undefined && !!extra.wake?.vm);
+}
+/** A Hyper-V VM's console as a desktop of its host: the host's VMConnect port, the VM's id, started when it's off. */
+function hyperVSpec(id, name, more = {}) {
+    return { id: `hyperv:${id}`, name, kind: 'windows', host: '127.0.0.1', port: hyperv_1.HYPERV_PORT, hyperv: id, wake: { hyperv: id }, ...more };
+}
 /**
  * The SSH host's own desktop, then the configured desktops behind it, then `more` (RDP profiles going through this
  * host). `found`: what the setup found there the last time (none yet: GNOME, as the setup will try first). A host
  * with only xrdp has it as its own desktop; one with both GNOME and xrdp also offers xrdp, as a desktop at its
  * loopback port. A Windows host's own desktop is its RDP server, signed in to with the Windows account (the SSH user,
- * to start with).
+ * to start with). `clipboard`: the setting, which desktops without their own follow.
  */
-function desktopsFor(target, extras, found, more = []) {
+function desktopsFor(target, extras, found, more = [], clipboard = 'both') {
     const own = found?.kind === 'xrdp'
         ? { id: exports.OWN_DESKTOP, name: `${target.label} desktop`, kind: 'xrdp', host: '127.0.0.1', port: found.xrdpPort ?? 3389, username: found.xrdpUser }
         : found?.kind === 'windows'
-            ? { id: exports.OWN_DESKTOP, name: `${target.label} desktop`, kind: 'windows', host: '127.0.0.1', port: 3389, username: target.key.replace(/@[^@]*$/, '') || undefined }
+            ? { id: exports.OWN_DESKTOP, name: `${target.label} desktop`, kind: 'windows', host: '127.0.0.1', port: 3389, username: keyUser(target.key) || undefined }
             : { id: exports.OWN_DESKTOP, name: `${target.label} desktop`, kind: 'gnome', host: '127.0.0.1', port: 0 };
+    // What the setup found, the own desktop's kind and the xrdp besides GNOME below, is the host's word about itself,
+    // never trusted (see DesktopSpec.kindTrusted).
     const specs = [own];
     const behind = (Array.isArray(extras) ? extras : []).filter(extra => extra?.via && viaMatches(extra.via, target));
     for (const extra of [...behind, ...more]) {
         const spec = specOf(extra);
-        if (spec && !specs.some(s => s.id === spec.id)) {
+        const kept = spec && specs.find(s => s.id === spec.id);
+        if (spec && !kept) {
             specs.push(spec);
         }
+        else if (spec && kept) {
+            // The same desktop configured twice (an entry and an RDP profile through this host, say): the first is the
+            // one that opens, and its clipboard goes no further than the other's would. Left following the setting
+            // where the other lets as much through.
+            const narrower = (0, clipboard_1.narrowest)(kept.clipboard ?? clipboard, spec.clipboard ?? clipboard);
+            if (narrower !== (kept.clipboard ?? clipboard)) {
+                kept.clipboard = narrower;
+            }
+        }
     }
     // Configured entries come first: one for the same port keeps its name.
     if (found?.kind === 'gnome' && found.xrdpPort && !specs.some(s => s.id === `127.0.0.1:${found.xrdpPort}`)) {
@@ -71,9 +152,29 @@ function desktopsFor(target, extras, found, more = []) {
 }
 /** The target key of direct connections (remote desktop tabs); their session keys are `rdp#<address>`. */
 exports.DIRECT_KEY = 'rdp';
-/** The id of a configured desktop (`host:port`), as its DesktopSpec and session keys have it. */
+/**
+ * The id of a configured desktop (`host:port`), as its DesktopSpec and session keys have it (see specOf), whatever the
+ * entry holds: a host or port that is neither text nor a number makes an id that no desktop has, and nothing is kept
+ * under it.
+ */
 function desktopIdOf(extra) {
-    return `${extra.host || '127.0.0.1'}:${extra.port || 3389}`;
+    const hyperv = (0, hyperv_1.vmId)(extra?.hyperv);
+    return hyperv ? `hyperv:${hyperv}` : `${extra?.host ? configText(extra.host) : '127.0.0.1'}:${(0, osd_1.configNumber)(extra?.port || 3389)}`;
+}
+/** Whether an item of `remoteDesktop.desktops` is an entry (a map) at all: anything else describes no desktop. */
+function isDesktopEntry(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * A configured desktop's entry as menus and lists show it: its name, else its address (see desktopIdOf), and the host
+ * it is behind ('' for none), each as text whatever the entry holds. A hand edit or config sync can put anything there,
+ * and an entry that can't be shown must not take with it the menus and lists that show the others. `hyperv`: whether
+ * it is a Hyper-V VM, told as specOf tells one, by its VM's id: not by its address, which a desktop at a host named
+ * hyperv starts the same way.
+ */
+function entryText(extra) {
+    const address = desktopIdOf(extra);
+    return { name: configText(extra?.name) || address, address, via: configText(extra?.via), hyperv: !!(0, hyperv_1.vmId)(extra?.hyperv) };
 }
 /**
  * One desktop per key: the remote account for its own desktop, plus the RDP server for one behind it (`rdp#<address>`
@@ -82,4 +183,127 @@ function desktopIdOf(extra) {
 function sessionKey(target, spec) {
     return spec.id === exports.OWN_DESKTOP ? target.key : `${target.key}#${spec.id}`;
 }
-//# sourceMappingURL=desktops.js.map
+/**
+ * Whether a desktop signs in without Network Level Authentication without being asked about it first, as xrdp does by
+ * design: an xrdp desktop whose kind is trusted (see DesktopSpec.kindTrusted). Every other desktop stops before the
+ * password goes as it is to a server that doesn't use it.
+ */
+function xrdpUnasked(spec) {
+    return spec.kind === 'xrdp' && spec.kindTrusted === true;
+}
+/** What keyField writes as `%` and two hex digits, in a key's user, host name and port. */
+const ESCAPED_USER = /[%#>\x00-\x1f\x7f]/g;
+const ESCAPED_HOST = /[%#>@\x00-\x1f\x7f]/g;
+const ESCAPED_PORT = /[%#>@:\x00-\x1f\x7f]/g;
+/**
+ * A field of `ssh -G` output, fit for a key, so that whatever ssh replies a key keeps its shape and no two targets get
+ * the same one: `%` (the escape itself), `#` (it joins a target's key and a desktop's address, see sessionKey), `>` (an
+ * SSH tab's key and a machine reached from there, see nestedKey) and control characters are written as `%25`, `%23`,
+ * `%3E`, …; so are an `@` in a host name and an `@` or `:` in a port, which would move where the user or the host name
+ * ends (see keyFields). A user's own `@` (alice@corp.example), spaces and an IPv6 address's colons stay as they are.
+ */
+function keyField(value, escaped) {
+    return value.replace(escaped, c => `%${c.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`);
+}
+/** A field of `ssh -G` output, from the line that names it. */
+function configField(out, name) {
+    return new RegExp(`^${name} (.+)$`, 'm').exec(out)?.[1]?.trim();
+}
+/** A target's key: `user@hostname:port` from `ssh -G` output (config aliases and defaults resolved; see keyOf). */
+function keyFromConfig(out, destination) {
+    return keyOf({ user: configField(out, 'user') ?? '', host: configField(out, 'hostname') ?? destination, port: configField(out, 'port') ?? '22' });
+}
+/** The key of a target with this user, host name and port (see keyField; keyFields takes it apart again). */
+function keyOf(fields) {
+    return `${keyField(fields.user, ESCAPED_USER)}@${keyField(fields.host.toLowerCase(), ESCAPED_HOST)}:${keyField(fields.port, ESCAPED_PORT)}`;
+}
+/**
+ * Whether some target could have this key now, reached directly or with ssh typed in a tab's console (see nestedKey):
+ * it reads the same taken apart and put back together. A key as the plugin made it up to 0.5.0 (see
+ * legacyKeyFromConfig) that does could be another target's now (a user name `alice%23ops` then, `alice#ops`'s now).
+ */
+function isTargetKey(key) {
+    const parts = key.split('>');
+    return parts.length <= 2 && parts.every(part => keyOf(keyFields(part)) === part);
+}
+/**
+ * A target's key as the plugin made it up to 0.5.0: the fields as ssh printed them. It reads as keyFromConfig's does
+ * unless a field has a character keyField now writes as `%xx`; what was kept for the target before is under this one
+ * (see RemoteTargets.keyChanged, which moves it).
+ */
+function legacyKeyFromConfig(out, destination) {
+    return `${configField(out, 'user') ?? ''}@${(configField(out, 'hostname') ?? destination).toLowerCase()}:${configField(out, 'port') ?? '22'}`;
+}
+/**
+ * The user, host name and port in a target's key (for a machine reached through a host, see nestedKey, that machine's)
+ * as ssh resolved them: the user is what comes before the last `@` and the port what comes after the last `:`, since
+ * keyField leaves neither in a host name or a port, and every `%` in a field is one keyField wrote.
+ */
+function keyFields(key) {
+    const fields = key.slice(key.lastIndexOf('>') + 1);
+    const at = fields.lastIndexOf('@');
+    const colon = fields.lastIndexOf(':');
+    const end = colon > at ? colon : fields.length;
+    const unescape = (field) => field.replace(/%([0-9A-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    return { user: unescape(fields.slice(0, Math.max(at, 0))), host: unescape(fields.slice(at + 1, end)), port: unescape(fields.slice(end + 1)) };
+}
+/**
+ * The key of a machine reached with `ssh` typed in an SSH tab's console: the tab's key, `>`, and the machine's own as
+ * the host there resolves it (`ssh -G`, run there). Everything about that machine comes from that host, which can make
+ * it out to be any machine: under the host's own key, what it names is one of its own desktops, never the key (and with
+ * it the saved account, the remembered certificate, or the permission to sign in without NLA) of a desktop reached
+ * another way.
+ */
+function nestedKey(outerKey, configOut, destination) {
+    return `${outerKey}>${keyFromConfig(configOut, destination)}`;
+}
+/**
+ * A target's key as it reads, for a list of what is kept by it (Settings › Remote Desktop › Certificates): `%`, `#`,
+ * `>`, `@` and `:` as they are rather than as keyField writes them (control characters stay written so), and a machine
+ * reached through a host (see nestedKey) named first, through that host.
+ */
+function shownKey(key) {
+    const fields = (part) => part.replace(/%(25|23|3E|40|3A)/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    const [outer, inner] = key.split('>');
+    return inner === undefined ? fields(outer) : `${fields(inner)}, through ${fields(outer)}`;
+}
+/**
+ * The user in a target's key, as ssh resolved it (not as the key writes it, see keyField): for a machine reached through
+ * a host (see nestedKey), that machine's.
+ */
+function keyUser(key) {
+    return keyFields(key).user;
+}
+/**
+ * A session, trust or credential key split into the target it belongs to and the desktop id after it, so matching is
+ * anchored on whole parts rather than an `endsWith('#'+id)` that a different key could also satisfy. A key is
+ * `<target>#<id>`: the target is `rdp` for a direct desktop, `gateway` for a gateway certificate, or `user@host:port`
+ * for a desktop behind an SSH host (`<tab's key>><user@host:port>` for a machine reached through one, see nestedKey;
+ * no target's key has a `#`, see keyField); the own desktop's key is the bare target, with no id. A credential key
+ * may carry a gateway suffix (`…@gateway#<host:port>`), which names where a password is sent rather than the desktop,
+ * and is returned separately so the id still compares equal.
+ */
+function keyParts(key) {
+    const hash = key.indexOf('#');
+    if (hash < 0) {
+        return { target: key, desktopId: '', gateway: '' };
+    }
+    const rest = key.slice(hash + 1);
+    const at = rest.indexOf('@gateway#');
+    return at < 0
+        ? { target: key.slice(0, hash), desktopId: rest, gateway: '' }
+        : { target: key.slice(0, hash), desktopId: rest.slice(0, at), gateway: rest.slice(at) };
+}
+/**
+ * A session, trust or credential key of the target `from`, as the same key of `to` (see RemoteTargets.keyChanged,
+ * which moves what was kept under a target's former key): `from` itself (its own desktop), or `from#<id>`, with a
+ * gateway suffix on a saved password's key. Null for any other key. Desktop ids have no `#` (see specOf), so a key that
+ * has more of them isn't one of `from`'s desktops, whatever it starts with.
+ */
+function rekeyed(key, from, to) {
+    if (key === from) {
+        return to;
+    }
+    const rest = key.startsWith(`${from}#`) ? key.slice(from.length + 1) : null;
+    return rest !== null && /^[^#]*(@gateway#[^#]*)?$/.test(rest) ? `${to}#${rest}` : null;
+}