tabby-rdp 0.5.0 → 0.5.2

package/dist/rdpProfile.js

@@ -18,9 +18,10 @@ const desktopForm_1 = require("./desktopForm");
 const help_1 = require("./help");
 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 signin_1 = require("./signin");
+const osd_1 = require("./osd");
 const ssh_1 = require("./ssh");
 const targets_1 = require("./targets");
 /** Input of an SSH tab opened for an RDP profile with `via`: the desktop to show once SSH is connected. */
@@ -134,7 +135,7 @@ let RDPProfileSettingsComponent = class RDPProfileSettingsComponent {
         const o = this.profile.options;
         const account = () => `${o.username ?? ''}\n${o.domain ?? ''}\n${o.account ?? ''}`;
         // No id for a new profile (no address yet): it has nothing saved to take along.
-        this.before = { id: o.host ? (0, desktops_1.desktopIdOf)(o) : '', account: account(), via: o.via ?? '' };
+        this.before = { id: o.host ? (0, desktops_1.desktopIdOf)(o) : '', account: account(), via: o.via ?? '', gateway: o.gateway ?? '' };
         const root = this.element.nativeElement;
         root.innerHTML = `
             <div class="mb-3">
@@ -179,6 +180,12 @@ let RDPProfileSettingsComponent = class RDPProfileSettingsComponent {
                 <label>Gateway account</label>
                 <select class="form-control" name="gatewayAccount"></select>
                 <div class="text-muted small">A gateway that takes another account than the desktop: a saved account for it.</div>
+            </div>
+            <div class="mb-3">
+                <label>Clipboard</label>
+                <select class="form-control" name="clipboard"></select>
+                <div class="text-muted small">Which ways text, pictures and files copied on either side go between this computer and the desktop.
+                    Applies on the next connection.</div>
             </div>`;
         const field = (name) => root.querySelector(`[name="${name}"]`);
         field('address').value = o.host ? (0, desktopForm_1.formatAddress)(o.host, o.port || 3389) : '';
@@ -240,6 +247,11 @@ let RDPProfileSettingsComponent = class RDPProfileSettingsComponent {
         });
         gatewayAccount.addEventListener('change', () => { o.gatewayAccount = gatewayAccount.value; });
         gatewayChanged();
+        // Its own clipboard sharing, or the setting's (named, as it is now).
+        const clipboard = field('clipboard');
+        clipboard.append(new Option(`As in Settings › Remote Desktop (${clipboard_1.CLIPBOARD_LABELS[desktop.settings().clipboard].toLowerCase()})`, ''), ...Object.entries(clipboard_1.CLIPBOARD_LABELS).map(([mode, text]) => new Option(text, mode)));
+        clipboard.value = (0, clipboard_1.ownClipboard)(o.clipboard) ?? '';
+        clipboard.addEventListener('change', () => { o.clipboard = clipboard.value; });
         const via = field('via');
         via.addEventListener('change', () => { o.via = via.value; });
         this.injector.get(tabby_core_1.ProfilesService).getProfiles().then(profiles => {
@@ -253,21 +265,22 @@ let RDPProfileSettingsComponent = class RDPProfileSettingsComponent {
     }
     save() {
         const o = this.profile.options;
-        const { id, account, via } = this.before;
+        const { id, account, via, gateway } = this.before;
         if (!id) {
             return;
         }
         if ((o.via ?? '') !== via) {
-            // Reached another way, it is another desktop. A direct one's saved account and certificate were its own; one
-            // behind a host shares them with that host's desktop at the same address, so they stay.
+            // Reached another way, it is another desktop. A direct one's saved passwords (through any gateway, the ones
+            // it had before included) and certificate were its own; one behind a host shares them with that host's
+            // desktop at the same address, so they stay.
             if (!via) {
-                (0, signin_1.forgetCredentials)(`${desktops_1.DIRECT_KEY}#${id}`);
-                this.injector.get(desktop_service_1.RemoteDesktopService).forgetCertificatesFor(id, true);
+                this.injector.get(desktop_service_1.RemoteDesktopService).forgetDesktop(id, true, `"${this.profile.name}"`).catch(() => null);
             }
             return;
         }
+        // Its saved password goes with its way there (see desktopEdited): another gateway is asked for again.
         const accountChanged = `${o.username ?? ''}\n${o.domain ?? ''}\n${o.account ?? ''}` !== account;
-        this.injector.get(desktop_service_1.RemoteDesktopService).desktopEdited(id, (0, desktops_1.desktopIdOf)(o), accountChanged, !via).catch(() => null);
+        this.injector.get(desktop_service_1.RemoteDesktopService).desktopEdited(id, (0, desktops_1.desktopIdOf)(o), accountChanged, !via, { from: gateway, to: o.gateway }).catch(() => null);
     }
 };
 exports.RDPProfileSettingsComponent = RDPProfileSettingsComponent;
@@ -289,11 +302,14 @@ let RDPProfilesService = class RDPProfilesService extends tabby_core_1.QuickConn
         this.name = 'Remote desktop (RDP)';
         this.settingsComponent = RDPProfileSettingsComponent;
         this.configDefaults = {
-            options: { host: '', port: 3389, kind: 'windows', username: '', domain: '', account: '', via: '', gateway: '', gatewayAccount: '' },
+            options: { host: '', port: 3389, kind: 'windows', username: '', domain: '', account: '', via: '', gateway: '', gatewayAccount: '', clipboard: '' },
             clearServiceMessagesOnConnect: false,
         };
     }
     async getBuiltinProfiles() {
+        // No clipboard here: a new profile is made from a copy of this, and a value saved with it (even '', the
+        // setting's) would hide the clipboard its group's or the type's defaults give it, which may well be narrower.
+        // Left out, the profile follows those defaults (configDefaults has the key) until it is given one of its own.
         return [{
                 id: `${targets_1.RDP_PROFILE_TYPE}:template`,
                 type: targets_1.RDP_PROFILE_TYPE,
@@ -323,13 +339,17 @@ let RDPProfilesService = class RDPProfilesService extends tabby_core_1.QuickConn
     }
     getDescription(profile) {
         const o = profile.options ?? {};
-        if (!o.host) {
+        // Each field as text whatever the config holds (see configText): Tabby asks this of every profile as it lists
+        // them in its profile selector, and one that throws keeps the selector from opening at all.
+        const host = (0, desktops_1.configText)(o.host);
+        if (!host) {
             return '';
         }
-        const address = (0, desktopForm_1.formatAddress)(o.host, o.port || 3389);
+        const address = (0, desktopForm_1.formatAddress)(host, (0, osd_1.configNumber)(o.port || 3389));
+        const gateway = (0, desktops_1.configText)(o.gateway);
         const via = [
-            ...o.gateway ? [`the gateway ${o.gateway}`] : [],
-            ...o.via ? [(this.config.store.profiles ?? []).find((p) => p.id === o.via)?.name ?? 'an SSH profile'] : [],
+            ...gateway ? [`the gateway ${gateway}`] : [],
+            ...o.via ? [(0, desktops_1.configText)((this.config.store.profiles ?? []).find((p) => p.id === o.via)?.name) || 'an SSH profile'] : [],
         ];
         return via.length ? `${address} via ${via.join(', via ')}` : address;
     }
@@ -348,16 +368,15 @@ let RDPProfilesService = class RDPProfilesService extends tabby_core_1.QuickConn
     }
     intoQuickConnectString(profile) {
         const o = profile.options;
-        return o.via ? null : `${o.username ? `${o.username}@` : ''}${(0, desktopForm_1.formatAddress)(o.host, o.port || 3389)}`;
+        // As text, as getDescription reads them: the profile selector asks this of every profile too.
+        const username = (0, desktops_1.configText)(o.username);
+        return o.via ? null : `${username ? `${username}@` : ''}${(0, desktopForm_1.formatAddress)((0, desktops_1.configText)(o.host), (0, osd_1.configNumber)(o.port || 3389))}`;
     }
     deleteProfile(profile) {
-        // A direct desktop's saved account and certificate are its own; one behind a host shares them with that host's
-        // desktop at the same address.
+        // A direct desktop's saved passwords (through any gateway: one it went through before too) and certificate are
+        // its own; one behind a host shares them with that host's desktop at the same address.
         if (!profile.options.via) {
-            const id = (0, desktops_1.desktopIdOf)(profile.options);
-            (0, signin_1.forgetCredentials)(`${desktops_1.DIRECT_KEY}#${id}`);
-            this.injector.get(desktop_service_1.RemoteDesktopService).forgetCertificatesFor(id, true);
-            this.config.save();
+            this.injector.get(desktop_service_1.RemoteDesktopService).forgetDesktop((0, desktops_1.desktopIdOf)(profile.options), true, `"${profile.name}"`).catch(() => null);
         }
     }
 };
@@ -427,4 +446,3 @@ exports.RDPProfileOpener = RDPProfileOpener = __decorate([
     (0, core_1.Injectable)(),
     __metadata("design:paramtypes", [desktop_service_1.RemoteDesktopService, core_1.NgZone])
 ], RDPProfileOpener);
-//# sourceMappingURL=rdpProfile.js.map

package/dist/releaseSettings.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderReleaseSettings = renderReleaseSettings;
+const help_1 = require("./help");
+/** Rebuilt from manager state; every package mutation stays behind the manager's confirmation and validation. */
+function renderReleaseSettings(root, releases, actions) {
+    const oldSelection = root.dataset.releaseChannel === releases.state.channel ? root.querySelector('[data-version]')?.value : undefined;
+    root.dataset.releaseChannel = releases.state.channel;
+    const selected = releases.versions.some(p => p.version === oldSelection) ? oldSelection : releases.recommended ?? '';
+    const blocked = releases.busy || releases.checking || !!releases.pending || releases.removed;
+    const disable = (condition) => condition ? 'disabled' : '';
+    const reason = selected ? releases.reason(selected) : null;
+    const stable = releases.catalog?.stable;
+    const previous = releases.state.previous;
+    const status = releases.checking ? 'Checking…' : releases.checkedAt !== null ? `Last checked ${new Date(releases.checkedAt).toLocaleString()}.` : 'Not checked';
+    root.innerHTML = `
+        <div class="trd-release-summary">
+            <div><span class="trd-sub">Running version</span><h4>tabby-rdp ${(0, help_1.esc)(releases.running)}</h4></div>
+            <button class="btn btn-link btn-sm" data-release-notes="${(0, help_1.esc)(releases.running)}">Release notes</button>
+        </div>
+        ${releases.pending ? `<div class="trd-release-notice" role="status"><b>Restart required to use ${(0, help_1.esc)(releases.pending)}.</b> Close remote desktops and restart Tabby.</div>` : ''}
+        ${releases.removed ? '<div class="trd-release-notice" role="status"><b>Plugin uninstalled.</b> Close remote desktops and restart Tabby.</div>' : ''}
+        ${releases.notice ? `<p role="status">${(0, help_1.esc)(releases.notice)}</p>` : ''}
+        ${releases.storageWarning ? `<p role="alert">${(0, help_1.esc)(releases.storageWarning)}</p>` : ''}
+        <div class="form-line">
+            <div class="header"><label class="title" for="trd-release-channel">Release channel</label><div class="description">Preview includes beta releases and release candidates.</div></div>
+            <select id="trd-release-channel" class="form-control" data-channel ${disable(blocked)}><option value="stable" ${releases.state.channel === 'stable' ? 'selected' : ''}>Stable</option><option value="preview" ${releases.state.channel === 'preview' ? 'selected' : ''}>Preview</option></select>
+        </div>
+        <label class="trd-release-pause"><input type="checkbox" data-pause ${disable(releases.busy)} ${!releases.state.paused ? 'checked' : ''}> Check for updates automatically</label>
+        <div class="trd-release-actions"><button class="btn btn-secondary btn-sm" data-check ${disable(releases.checking || releases.busy)}>Check now</button><span class="trd-sub" role="status">${(0, help_1.esc)(status)}</span></div>
+        ${releases.error ? `<p class="trd-release-error" role="alert">${(0, help_1.esc)(releases.error)}${releases.catalog ? ' Showing the last successful check.' : ''}</p>` : ''}
+        ${releases.state.channel === 'preview' && releases.catalog && !releases.catalog.preview ? '<p>No preview releases available.</p>' : ''}
+        ${releases.recommended ? `<p>Latest: <b>${(0, help_1.esc)(releases.recommended)}</b> <button class="btn btn-link btn-sm" data-release-notes="${(0, help_1.esc)(releases.recommended)}">Release notes</button></p>` : ''}
+        <h5><label for="trd-release-version">Version</label></h5>
+        <div class="trd-release-actions">
+            <select id="trd-release-version" class="form-control" data-version ${disable(blocked || !releases.versions.length)}>
+                ${!releases.versions.length ? '<option>No versions loaded</option>' : releases.versions.map(p => {
+        const why = releases.reason(p.version);
+        return `<option value="${(0, help_1.esc)(p.version)}" ${p.version === selected ? 'selected' : ''} ${disable(!!why)}>${(0, help_1.esc)(p.version)}${why ? ` — ${(0, help_1.esc)(why)}` : ''}</option>`;
+    }).join('')}
+            </select>
+            <button class="btn btn-primary btn-sm" data-install ${disable(blocked || !!releases.error || !selected || !!reason || selected === releases.running)}>Install selected version…</button>
+            <button class="btn btn-link btn-sm" data-selected-notes ${disable(!selected)}>Release notes</button>
+        </div>
+        <p class="trd-sub" data-version-reason ${reason ? '' : 'hidden'}>${(0, help_1.esc)(reason ?? '')}</p>
+        <div class="trd-release-actions">
+            ${stable && stable !== releases.running ? `<button class="btn btn-secondary btn-sm" data-stable ${disable(blocked || !!releases.error || !!releases.reason(stable))}>Return to stable ${(0, help_1.esc)(stable)}…</button>` : ''}
+            <button class="btn btn-secondary btn-sm" data-restore ${disable(blocked || !!releases.error || !previous || !!releases.reason(previous) || previous === releases.running)}>Restore previous version${previous ? ` (${(0, help_1.esc)(previous)})` : ''}…</button>
+        </div>
+        ${!previous ? '<p class="trd-sub">No previous version saved.</p>' : releases.reason(previous) ? `<p class="trd-sub">Previous version unavailable: ${(0, help_1.esc)(releases.reason(previous))}</p>` : ''}
+        <h5>Disable or uninstall</h5>
+        <p class="trd-sub">Saved connections, settings, passwords and remote setup are kept.</p>
+        <div class="trd-release-actions"><button class="btn btn-secondary btn-sm" data-plugins>Manage in Tabby…</button><button class="btn btn-outline-danger btn-sm" data-uninstall ${disable(blocked)}>Uninstall plugin…</button><a href="#" data-recovery>Cleanup instructions</a></div>`;
+    root.querySelector('[data-channel]').addEventListener('change', e => {
+        void releases.setChannel(e.target.value);
+    });
+    root.querySelector('[data-pause]').addEventListener('change', e => { void releases.setPaused(!e.target.checked); });
+    root.querySelector('[data-check]').addEventListener('click', () => { void releases.refreshCatalog(true); });
+    root.querySelector('[data-version]').addEventListener('change', () => renderReleaseSettings(root, releases, actions));
+    root.querySelector('[data-install]').addEventListener('click', () => { void releases.install(selected); });
+    root.querySelector('[data-stable]')?.addEventListener('click', () => { if (stable) {
+        void releases.install(stable, true);
+    } });
+    root.querySelector('[data-restore]').addEventListener('click', () => { if (previous) {
+        void releases.install(previous);
+    } });
+    root.querySelector('[data-uninstall]').addEventListener('click', () => { void releases.uninstall(); });
+    root.querySelector('[data-plugins]').addEventListener('click', actions.plugins);
+    root.querySelector('[data-recovery]').addEventListener('click', e => { e.preventDefault(); actions.link(`${help_1.TROUBLESHOOTING_URL}#recovery`); });
+    root.querySelector('[data-selected-notes]').addEventListener('click', () => actions.notes(selected));
+    root.querySelectorAll('[data-release-notes]').forEach(el => el.addEventListener('click', () => actions.notes(el.dataset.releaseNotes)));
+}

package/dist/releases.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseManager = exports.RELEASE_STATE_KEY = exports.RELEASES = exports.REGISTRY = void 0;
+exports.releaseVersion = releaseVersion;
+exports.newer = newer;
+exports.registryJSON = registryJSON;
+exports.parseCatalog = parseCatalog;
+exports.publishedVersions = publishedVersions;
+const semver = require("semver");
+const rxjs_1 = require("rxjs");
+exports.REGISTRY = 'https://registry.npmjs.org/tabby-rdp';
+exports.RELEASES = 'https://github.com/meanaverage/tabby-rdp/releases';
+exports.RELEASE_STATE_KEY = 'tabby-rdp.releases.v1';
+const BASELINE = '0.5.1';
+const CACHE_MS = 15 * 60 * 1000;
+/** Exact, canonical versions only: never an npm selector, alias, URL or tag. */
+function releaseVersion(value) {
+    return typeof value === 'string' && semver.valid(value) === value && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:beta|rc)\.(0|[1-9]\d*))?$/.test(value);
+}
+function newer(a, b) {
+    return releaseVersion(a) && releaseVersion(b) && semver.gt(a, b);
+}
+const greatest = (a, b) => semver.gt(a, b) ? a : b;
+function policy(value) {
+    return value && typeof value.minimumTabbyVersion === 'string' && semver.valid(value.minimumTabbyVersion) &&
+        releaseVersion(value.rollbackFloor) ? { minimumTabbyVersion: value.minimumTabbyVersion, rollbackFloor: value.rollbackFloor } : undefined;
+}
+/** Bound both the response body and elapsed time, including slow streaming responses. */
+async function registryJSON(url, timeoutMs = 15000, maxBytes = 4 * 1024 * 1024) {
+    const abort = new AbortController();
+    const timer = setTimeout(() => abort.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, { cache: 'no-store', signal: abort.signal });
+        if (!response.ok || !response.body) {
+            throw new Error(`The registry answered ${response.status}.`);
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            size += value.byteLength;
+            if (size > maxBytes) {
+                throw new Error('The registry\'s answer is too large.');
+            }
+            chunks.push(value);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    finally {
+        clearTimeout(timer);
+        abort.abort();
+    }
+}
+function parseCatalog(data) {
+    if (data?.name !== 'tabby-rdp' || !data.versions || typeof data.versions !== 'object' || Array.isArray(data.versions)) {
+        throw new Error('The registry returned an invalid version list.');
+    }
+    const entries = Object.entries(data.versions);
+    if (entries.length > 5000) {
+        throw new Error('The registry\'s version list is too large.');
+    }
+    const versions = [];
+    for (const [version, raw] of entries) {
+        const p = raw;
+        if (!releaseVersion(version) || p?.name !== 'tabby-rdp' || p.version !== version) {
+            continue;
+        }
+        // 0.5.1 predates this field. Its requirements and irreversible credential migration were reviewed explicitly.
+        let compatibility = policy(p.tabbyRdp) ?? (version === BASELINE ? { minimumTabbyVersion: '1.0.236', rollbackFloor: BASELINE } : undefined);
+        if (compatibility && semver.gt(compatibility.rollbackFloor, version)) {
+            compatibility = undefined;
+        }
+        versions.push({ version, policy: compatibility, node: typeof p.engines?.node === 'string' ? p.engines.node : undefined,
+            os: Array.isArray(p.os) ? p.os.filter((x) => typeof x === 'string') : undefined,
+            cpu: Array.isArray(p.cpu) ? p.cpu.filter((x) => typeof x === 'string') : undefined,
+            deprecated: !!p.deprecated });
+    }
+    versions.sort((a, b) => semver.rcompare(a.version, b.version));
+    const tag = (name, preview) => {
+        const v = data['dist-tags']?.[name];
+        return releaseVersion(v) && !!semver.prerelease(v) === preview && versions.some(p => p.version === v) ? v : null;
+    };
+    return { versions, stable: tag('latest', false), preview: tag('beta', true) };
+}
+async function publishedVersions() {
+    return parseCatalog(await registryJSON(exports.REGISTRY));
+}
+/** No config or credential backups: only local preferences and successful package-change history. */
+class ReleaseManager {
+    constructor(env, initiallyPaused = false) {
+        this.env = env;
+        this.changed$ = new rxjs_1.Subject();
+        this.catalog = null;
+        this.checking = false;
+        this.busy = false;
+        this.error = '';
+        this.catalogError = '';
+        this.notice = '';
+        this.storageWarning = '';
+        this.checkedAt = null;
+        this.lastAttempt = -Infinity;
+        this.running = env.running;
+        this.now = env.now ?? Date.now;
+        this.state = { channel: 'stable', paused: initiallyPaused, rollbackFloor: greatest(BASELINE, env.policy.rollbackFloor) };
+        this.syncFromStorage();
+        this.ready = this.lock(async () => {
+            this.syncFromStorage();
+            this.reconcileDisk();
+            this.persist();
+        }).catch(e => { this.error = this.message(e); }).finally(() => this.changed$.next());
+    }
+    message(error) { return error instanceof Error ? error.message : 'Use Tabby Plugins to manage this installation.'; }
+    async lock(run) {
+        if (this.env.withLock) {
+            await this.env.withLock(run);
+        }
+        else {
+            await run();
+        }
+    }
+    /** Storage events call this too. Reading never clears another window's successful package change. */
+    syncFromStorage() {
+        if (!this.env.storage) {
+            return;
+        }
+        try {
+            const saved = JSON.parse(this.env.storage.getItem(exports.RELEASE_STATE_KEY) ?? 'null');
+            if (!saved) {
+                return;
+            }
+            this.state.channel = saved.channel === 'preview' ? 'preview' : 'stable';
+            if (typeof saved.paused === 'boolean') {
+                this.state.paused = saved.paused;
+            }
+            this.state.previous = releaseVersion(saved.previous) ? saved.previous : undefined;
+            this.state.pending = releaseVersion(saved.pending) ? saved.pending : undefined;
+            this.state.removed = saved.removed === true;
+            if (releaseVersion(saved.rollbackFloor)) {
+                this.state.rollbackFloor = greatest(this.state.rollbackFloor, saved.rollbackFloor);
+            }
+        }
+        catch { /* Keep the known state if local storage is temporarily unavailable. */ }
+        this.changed$.next();
+    }
+    /** Under the shared lock, so a second window never observes our installer's intermediate files. */
+    reconcileDisk() {
+        if (!this.env.diskVersion) {
+            return;
+        }
+        const disk = this.env.diskVersion();
+        if (disk !== null && !releaseVersion(disk)) {
+            throw new Error('The installed package version cannot be verified. Use Tabby Plugins.');
+        }
+        if (disk === null) {
+            this.state.removed = true;
+        }
+        else {
+            if ((this.state.pending && this.state.pending !== disk) || this.state.removed) {
+                this.notice = `The package changed outside this page. Tabby is running ${this.running}; the package on disk is ${disk}.`;
+                this.state.previous = undefined;
+            }
+            this.state.pending = disk;
+            this.state.removed = false;
+        }
+    }
+    get pending() { return !this.removed && this.state.pending && this.state.pending !== this.running ? this.state.pending : null; }
+    get removed() { return this.state.removed === true; }
+    persist() {
+        try {
+            if (!this.env.storage) {
+                throw new Error('Local storage unavailable');
+            }
+            this.env.storage.setItem(exports.RELEASE_STATE_KEY, JSON.stringify(this.state));
+            this.storageWarning = '';
+        }
+        catch {
+            this.storageWarning = 'Version preferences could not be saved on this computer. They apply to this window only. Manage installations in Tabby Plugins.';
+        }
+    }
+    async preference(change) {
+        if (this.busy) {
+            return;
+        }
+        await this.ready;
+        try {
+            await this.lock(async () => {
+                this.syncFromStorage();
+                Object.assign(this.state, change);
+                this.persist();
+            });
+        }
+        catch (e) {
+            this.error = this.message(e);
+        }
+        this.changed$.next();
+    }
+    async setChannel(value) {
+        if (value === 'stable' || value === 'preview') {
+            await this.preference({ channel: value });
+        }
+    }
+    async setPaused(paused) { await this.preference({ paused }); }
+    get recommended() {
+        const stable = this.catalog?.stable ?? null;
+        const preview = this.state.channel === 'preview' ? this.catalog?.preview : null;
+        return preview && (!stable || newer(preview, stable)) ? preview : stable;
+    }
+    get available() {
+        const version = this.recommended;
+        return !this.state.paused && !this.catalogError && !this.pending && !this.removed && version && newer(version, this.running) && !this.reason(version) ? version : null;
+    }
+    get versions() {
+        return (this.catalog?.versions ?? []).filter(p => this.state.channel === 'preview' || !semver.prerelease(p.version));
+    }
+    /** A reason to refuse a version, independent of whether it is newer. Return-to-stable may downgrade. */
+    reason(version) {
+        if (!releaseVersion(version)) {
+            return 'Invalid version.';
+        }
+        const p = this.catalog?.versions.find(x => x.version === version);
+        if (!p) {
+            return 'This version is not in the published version list.';
+        }
+        if (p.deprecated) {
+            return 'This version has been withdrawn from recommendations.';
+        }
+        if (semver.lt(version, this.state.rollbackFloor)) {
+            return `Saved data requires version ${this.state.rollbackFloor} or newer.`;
+        }
+        if (!p.policy) {
+            return 'Compatibility has not been confirmed for this version.';
+        }
+        if (!semver.valid(this.env.tabby) || semver.lt(this.env.tabby, p.policy.minimumTabbyVersion)) {
+            return `Requires Tabby ${p.policy.minimumTabbyVersion} or newer.`;
+        }
+        if (p.node && (!semver.validRange(p.node) || !semver.satisfies(this.env.node, p.node, { includePrerelease: true }))) {
+            return 'Requires a different Node.js version. Update Tabby first.';
+        }
+        const supports = (list, value) => !list?.length ||
+            (!list.includes(`!${value}`) && (list.includes('any') || !list.some(x => !x.startsWith('!')) || list.includes(value)));
+        if (!supports(p.os, this.env.os) || !supports(p.cpu, this.env.cpu)) {
+            return 'Not available for this computer.';
+        }
+        return null;
+    }
+    /** One shared request; ordinary reads cache for 15 minutes, explicit checks retry at most every 10 seconds. */
+    async refreshCatalog(force = false) {
+        if (this.inFlight) {
+            return this.inFlight;
+        }
+        const elapsed = this.now() - this.lastAttempt;
+        if (elapsed < (force ? 10000 : CACHE_MS)) {
+            return;
+        }
+        this.lastAttempt = this.now();
+        this.checking = true;
+        this.error = '';
+        this.changed$.next();
+        this.inFlight = (async () => {
+            try {
+                this.catalog = await Promise.resolve().then(() => this.env.fetchCatalog());
+                this.catalogError = '';
+                this.checkedAt = this.now();
+            }
+            catch (e) {
+                this.error = this.catalogError = `Could not check published versions. ${e instanceof Error ? e.message : 'Try again later.'}`;
+            }
+            finally {
+                this.checking = false;
+                this.inFlight = undefined;
+                this.changed$.next();
+            }
+        })();
+        return this.inFlight;
+    }
+    async install(version, returnToStable = false) {
+        if (this.busy) {
+            return;
+        }
+        this.busy = true;
+        this.error = '';
+        this.changed$.next();
+        const progress = (phase, message) => this.env.progress?.({ action: 'install', phase, version, message });
+        try {
+            progress('preparing');
+            await this.ready;
+            await this.lock(async () => {
+                this.syncFromStorage();
+                this.reconcileDisk();
+                this.persist();
+                if (this.storageWarning) {
+                    throw new Error('Version history cannot be saved. Use Tabby Plugins to install.');
+                }
+                if (this.pending) {
+                    progress('success', `tabby-rdp ${this.pending} is already installed. Restart Tabby to use it.`);
+                    return;
+                }
+                if (this.removed) {
+                    throw new Error('The plugin has been uninstalled. Restart Tabby before changing versions.');
+                }
+                await this.refreshCatalog();
+                if (this.catalogError) {
+                    throw new Error('Check published versions successfully before installing.');
+                }
+                const reason = this.reason(version);
+                if (reason) {
+                    throw new Error(reason);
+                }
+                if (version === this.running) {
+                    progress('success', `tabby-rdp ${version} is already running.`);
+                    return;
+                }
+                if (semver.prerelease(version) && this.state.channel !== 'preview') {
+                    throw new Error('Choose Preview before installing a preview version.');
+                }
+                if (returnToStable && version !== this.catalog?.stable) {
+                    throw new Error('Check the current stable version again.');
+                }
+                const downgrade = semver.lt(version, this.running);
+                if (!await this.env.confirm(`Install tabby-rdp ${version}?`, `Currently running ${this.running}. ${downgrade ? 'This is a downgrade. ' : ''}Close remote desktops and restart Tabby after installation.`, 'Install')) {
+                    progress('cancelled');
+                    return;
+                }
+                progress('installing');
+                await this.env.install('tabby-rdp', version);
+                progress('verifying');
+                if (this.env.diskVersion) {
+                    const installed = this.env.diskVersion();
+                    if (installed !== version) {
+                        throw new Error(installed === null ? 'The installed plugin package is missing.' :
+                            `The installed version is ${installed}; expected ${version}.`);
+                    }
+                }
+                // History is committed only after the supported installer succeeds.
+                this.state.previous = this.running;
+                this.state.pending = version;
+                this.state.removed = false;
+                if (returnToStable) {
+                    this.state.channel = 'stable';
+                }
+                this.persist();
+                progress('success');
+            });
+        }
+        catch (e) {
+            this.error = `Installation did not complete. ${this.message(e)}`;
+            progress('error', this.error);
+        }
+        finally {
+            this.busy = false;
+            this.changed$.next();
+        }
+    }
+    async uninstall() {
+        if (this.busy) {
+            return;
+        }
+        this.busy = true;
+        this.error = '';
+        this.changed$.next();
+        const progress = (phase, message) => this.env.progress?.({ action: 'uninstall', phase, message });
+        try {
+            progress('preparing');
+            await this.ready;
+            await this.lock(async () => {
+                this.syncFromStorage();
+                this.reconcileDisk();
+                this.persist();
+                if (this.storageWarning) {
+                    throw new Error('Version history cannot be saved. Use Tabby Plugins to uninstall.');
+                }
+                if (this.pending) {
+                    throw new Error('A version change is pending. Restart Tabby before uninstalling.');
+                }
+                if (this.removed) {
+                    progress('success', 'tabby-rdp is already uninstalled. Restart Tabby to finish.');
+                    return;
+                }
+                if (!await this.env.confirm('Uninstall tabby-rdp?', 'Close remote desktops before uninstalling, then restart Tabby. Saved connections, settings, passwords and remote setup are kept.', 'Uninstall')) {
+                    progress('cancelled');
+                    return;
+                }
+                progress('uninstalling');
+                await this.env.uninstall('tabby-rdp');
+                progress('verifying');
+                if (this.env.diskVersion && this.env.diskVersion() !== null) {
+                    throw new Error('The plugin package is still installed.');
+                }
+                this.state.removed = true;
+                this.persist();
+                progress('success');
+            });
+        }
+        catch (e) {
+            this.error = `Uninstall did not complete. ${this.message(e)}`;
+            progress('error', this.error);
+        }
+        finally {
+            this.busy = false;
+            this.changed$.next();
+        }
+    }
+}
+exports.ReleaseManager = ReleaseManager;