tabby-rdp 0.5.1 → 0.5.2

package/dist/packageChangeDialog.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageChangeDialog = void 0;
+const STYLE = `
+.trd-package-dialog { width: min(460px, calc(100vw - 40px)); padding: 24px; border-radius: 8px; outline: none;
+    border: 1px solid rgba(128,128,128,.35); background: var(--bs-body-bg, #1b1b1b); color: var(--bs-body-color, #ddd);
+    box-shadow: 0 16px 60px rgba(0,0,0,.45); }
+.trd-package-dialog::backdrop { background: rgba(0,0,0,.55); }
+.trd-package-dialog h4 { font-size: 18px; margin: 0 0 16px; }
+.trd-package-dialog p { white-space: pre-line; overflow-wrap: anywhere; }
+.trd-package-dialog [data-detail] { font-size: 13px; opacity: .8; }
+.trd-package-dialog p:empty { display: none; }
+.trd-package-dialog progress { display: block; width: 100%; height: 8px; margin: 18px 0 8px; accent-color: #589cf0; }
+.trd-package-dialog [hidden] { display: none !important; }
+.trd-package-dialog [data-elapsed] { font-size: 12px; opacity: .7; }
+.trd-package-dialog [data-phase=error] { color: var(--bs-danger, #f08080); }
+.trd-package-dialog [data-phase=success] { color: var(--bs-success, #79c99b); }
+.trd-package-dialog .trd-package-actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 22px; }
+`;
+/** One modal remains open from confirmation through the installer's verified result. */
+class PackageChangeDialog {
+    constructor() {
+        this.dialog = null;
+        this.previousFocus = null;
+        this.started = 0;
+    }
+    update(state) {
+        if (state.phase === 'cancelled') {
+            this.close();
+            return;
+        }
+        this.open();
+        this.field('[data-title]').textContent = state.action === 'install'
+            ? `Install tabby-rdp ${state.version}` : 'Uninstall tabby-rdp';
+        const result = this.field('[data-result]');
+        result.dataset.phase = state.phase;
+        result.setAttribute('role', state.phase === 'error' ? 'alert' : 'status');
+        const complete = state.phase === 'success' || state.phase === 'error';
+        this.field('progress').hidden = complete;
+        this.field('[data-elapsed]').hidden = complete;
+        this.field('[data-cancel]').hidden = true;
+        this.field('[data-confirm]').hidden = true;
+        this.field('[data-close]').hidden = !complete;
+        this.field('[data-detail]').textContent = '';
+        let message = state.message ?? '';
+        if (state.phase === 'preparing') {
+            message = state.action === 'install' ? 'Checking compatibility…' : 'Checking installation…';
+        }
+        if (state.phase === 'installing') {
+            message = `Installing tabby-rdp ${state.version}…`;
+        }
+        if (state.phase === 'uninstalling') {
+            message = 'Uninstalling tabby-rdp…';
+        }
+        if (state.phase === 'verifying') {
+            message = state.action === 'install' ? 'Verifying installation…' : 'Verifying removal…';
+        }
+        if (state.phase === 'success') {
+            this.field('[data-title]').textContent = state.action === 'install' ? 'Installation complete' : 'Uninstall complete';
+            if (!state.message) {
+                message = state.action === 'install' ? `tabby-rdp ${state.version} is installed.` : 'tabby-rdp is uninstalled.';
+                this.field('[data-detail]').textContent = 'Close remote desktops, then restart Tabby.';
+            }
+        }
+        if (state.phase === 'error') {
+            this.field('[data-title]').textContent = state.action === 'install' ? 'Installation failed' : 'Uninstall failed';
+        }
+        this.field('[data-message]').textContent = message;
+        if (complete) {
+            this.stopTimer();
+            this.field('[data-close]').focus();
+        }
+        else {
+            this.dialog.focus();
+        }
+    }
+    confirm(message, detail, action) {
+        this.open();
+        this.stopTimer();
+        this.field('[data-title]').textContent = message;
+        this.field('[data-message]').textContent = detail;
+        this.field('[data-detail]').textContent = '';
+        this.field('progress').hidden = true;
+        this.field('[data-elapsed]').hidden = true;
+        this.field('[data-close]').hidden = true;
+        const cancel = this.field('[data-cancel]');
+        const accept = this.field('[data-confirm]');
+        cancel.hidden = false;
+        accept.hidden = false;
+        accept.textContent = action;
+        this.field('[data-result]').dataset.phase = 'confirming';
+        cancel.focus();
+        return new Promise(resolve => { this.confirmation = resolve; });
+    }
+    field(selector) { return this.dialog.querySelector(selector); }
+    open() {
+        if (this.dialog) {
+            if (!this.dialog.open) {
+                this.dialog.showModal();
+            }
+            if (!this.timer) {
+                this.startTimer();
+            }
+            return;
+        }
+        if (!document.getElementById('trd-package-dialog-style')) {
+            const style = document.createElement('style');
+            style.id = 'trd-package-dialog-style';
+            style.textContent = STYLE;
+            document.head.appendChild(style);
+        }
+        this.previousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+        const dialog = document.createElement('dialog');
+        this.dialog = dialog;
+        dialog.className = 'trd-package-dialog';
+        dialog.setAttribute('aria-labelledby', 'trd-package-dialog-title');
+        dialog.setAttribute('tabindex', '-1');
+        dialog.setAttribute('closedby', 'none');
+        dialog.innerHTML = `<h4 id="trd-package-dialog-title" data-title></h4>
+            <div data-result role="status" aria-live="polite"><p data-message></p><p data-detail></p></div>
+            <progress aria-label="Package change progress"></progress><div data-elapsed></div>
+            <div class="trd-package-actions"><button class="btn btn-secondary" data-cancel hidden>Cancel</button>
+                <button class="btn btn-primary" data-confirm hidden></button><button class="btn btn-primary" data-close hidden>Close</button></div>`;
+        this.field('[data-confirm]').addEventListener('click', () => this.decide(true));
+        this.field('[data-cancel]').addEventListener('click', () => this.decide(false));
+        this.field('[data-close]').addEventListener('click', () => this.close());
+        dialog.addEventListener('cancel', event => {
+            event.preventDefault();
+            this.dismiss();
+        });
+        // Keep package-dialog keystrokes out of Tabby's terminal and shortcut handlers.
+        dialog.addEventListener('keydown', event => {
+            event.stopPropagation();
+            if (event.key === 'Escape') {
+                event.preventDefault();
+                this.dismiss();
+            }
+        });
+        dialog.addEventListener('keyup', event => event.stopPropagation());
+        document.body.appendChild(dialog);
+        dialog.showModal();
+        this.startTimer();
+    }
+    decide(accepted) {
+        const resolve = this.confirmation;
+        if (!resolve) {
+            return;
+        }
+        this.confirmation = undefined;
+        this.field('[data-confirm]').hidden = true;
+        this.field('[data-cancel]').hidden = true;
+        resolve(accepted);
+        if (!accepted) {
+            this.close();
+        }
+    }
+    dismiss() {
+        if (this.confirmation) {
+            this.decide(false);
+        }
+        else if (!this.field('[data-close]').hidden) {
+            this.close();
+        }
+    }
+    startTimer() {
+        this.started = Date.now();
+        const tick = () => {
+            const seconds = Math.floor((Date.now() - this.started) / 1000);
+            this.field('[data-elapsed]').textContent = `Elapsed ${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, '0')}`;
+        };
+        tick();
+        this.timer = setInterval(tick, 1000);
+    }
+    stopTimer() { clearInterval(this.timer); this.timer = undefined; }
+    close() {
+        this.stopTimer();
+        this.dialog?.close();
+        this.dialog?.remove();
+        this.dialog = null;
+        if (this.previousFocus?.isConnected) {
+            this.previousFocus.focus();
+        }
+        this.previousFocus = null;
+    }
+}
+exports.PackageChangeDialog = PackageChangeDialog;

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;