@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/runtime/desktopBinding.js

@@ -0,0 +1,20 @@
+export async function holdDesktopForTargetProbe(adapter) { await adapter?.holdNewAdmission(); }
+export async function replaceDesktopBinding(options) {
+    await options.original?.closeAdmission();
+    await options.original?.isolateOriginal();
+    options.original?.admission.dispose();
+    if (options.final())
+        return;
+    const next = options.create();
+    if (next && !options.allowed())
+        await next.closeAdmission();
+    if (next && options.held?.())
+        await next.holdNewAdmission();
+    if (options.final()) {
+        await next?.closeAdmission();
+        await next?.isolateOriginal();
+        next?.admission.dispose();
+        return;
+    }
+    return next;
+}

package/dist/workstation/runtime/deviceDesktop.js

@@ -0,0 +1,193 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+export async function resolveDeviceDesktop(root) {
+    if (process.platform === 'linux') {
+        const { LinuxDeviceHost } = await import('../rd/host.js');
+        const pending = await LinuxDeviceHost.recoverPending(root);
+        if (pending)
+            return { cleanupOnly: true, provider: { deviceAdmission: pending.admission, probe: async () => null,
+                    prepare: async () => { throw Error('cleanup_only'); }, recoverDisplay: async () => { throw Error('cleanup_only'); } },
+                stopOriginal: () => pending.stopOriginal(), finalizeOriginal: () => pending.finalizeOriginal() };
+    }
+    if (process.platform === 'darwin' || process.platform === 'linux') {
+        const cleanup = path.join(root, 'desktop-cleanup');
+        let files = [];
+        try {
+            const stat = await fs.lstat(cleanup);
+            if (!stat.isDirectory() || stat.uid !== process.getuid?.() || stat.mode & 0o077)
+                throw new Error('unsafe_desktop_cleanup');
+            files = (await fs.readdir(cleanup)).sort();
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (files.length) {
+            const first = files[0];
+            if (!/^[a-f0-9]{32}\.json$/.test(first))
+                throw new Error('unsafe_desktop_cleanup');
+            if (process.platform === 'darwin') {
+                const { MacProvider } = await import('../desktopControl/macProvider.js');
+                return { provider: await MacProvider.connect(root, path.join(cleanup, first)), cleanupOnly: true };
+            }
+            const { readDeviceHostGrant } = await import('../desktopControl/hostGrant.js');
+            const { NativeDeviceAdmission } = await import('../desktopControl/nativeDeviceAdmission.js');
+            const grant = await readDeviceHostGrant(path.join(cleanup, first), true);
+            const admission = await NativeDeviceAdmission.connect(grant);
+            if (admission.hostLifetimeId !== grant.hostGeneration)
+                throw Error('original_native_host_unconfirmed');
+            return { cleanupOnly: true, provider: { deviceAdmission: admission, probe: async () => null,
+                    prepare: async () => { throw Error('cleanup_only'); }, recoverDisplay: async () => { throw Error('cleanup_only'); } } };
+        }
+    }
+    if (process.platform === 'darwin') {
+        const { MacProvider } = await import('../desktopControl/macProvider.js');
+        try {
+            await fs.lstat(path.join(root, 'desktop-provider.json'));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        return { provider: await MacProvider.connect(root), cleanupOnly: false };
+    }
+    if (process.platform === 'linux') {
+        const { LinuxDesktopProvider } = await import('../rd/provider.js');
+        const provider = await LinuxDesktopProvider.connect(root);
+        return provider ? { provider, cleanupOnly: false, stopOriginal: () => provider.stopOriginal(), finalizeOriginal: () => provider.finalizeOriginal(), retirementRequired: () => provider.retirementRequired() } : undefined;
+    }
+    return undefined;
+}
+export class DeviceDesktopRuntime {
+    root;
+    owner;
+    resolve;
+    original;
+    published;
+    retired = false;
+    unknown = false;
+    nativeConsumers = 0;
+    busy;
+    consumers = new Map();
+    timer;
+    stopped = false;
+    finalAcknowledgements = new Set();
+    pendingFinalizer;
+    constructor(root, owner, resolve = resolveDeviceDesktop) {
+        this.root = root;
+        this.owner = owner;
+        this.resolve = resolve;
+    }
+    get provider() { return this.published; }
+    facts() { return { deviceEpoch: this.owner.snapshot().deviceEpoch, hostLifetimeId: this.original?.provider.deviceAdmission?.hostLifetimeId ?? null, hostRetired: this.retired }; }
+    activity() {
+        const activity = [...this.consumers.values()].map(consumer => consumer.activity());
+        return { known: !this.unknown && activity.every(value => value.known),
+            consumers: Math.max(this.unknown ? 1 : 0, this.nativeConsumers, ...activity.map(value => value.consumers), 0) };
+    }
+    async watch(id, consumer) {
+        this.consumers.set(id, consumer);
+        await consumer.bind(this.published);
+        return () => { if (this.consumers.get(id) === consumer)
+            this.consumers.delete(id); };
+    }
+    async start() {
+        await this.refresh();
+        if (!this.stopped) {
+            this.timer = setInterval(() => { void this.refresh(); }, 1000);
+            this.timer.unref();
+        }
+    }
+    refresh() {
+        if (this.busy)
+            return this.busy;
+        const current = this.tick().catch(() => { this.unknown = true; }).finally(() => { if (this.busy === current)
+            this.busy = undefined; });
+        this.busy = current;
+        return current;
+    }
+    async tick() {
+        for (const original of [...this.finalAcknowledgements])
+            try {
+                await original.acknowledgeHostRetirement(randomUUID());
+                this.finalAcknowledgements.delete(original);
+            }
+            catch { }
+        if (this.pendingFinalizer) {
+            await this.pendingFinalizer();
+            this.pendingFinalizer = undefined;
+            this.unknown = false;
+        }
+        if (!this.original || this.retired) {
+            const next = this.stopped ? undefined : await this.resolve(this.root);
+            if (!next)
+                return;
+            if (next.provider.deviceAdmission?.hostLifetimeId === this.original?.provider.deviceAdmission?.hostLifetimeId) {
+                if (this.retired && next.finalizeOriginal) {
+                    this.pendingFinalizer = next.finalizeOriginal;
+                    await this.pendingFinalizer();
+                    this.pendingFinalizer = undefined;
+                    this.unknown = false;
+                }
+                return;
+            }
+            this.original = next;
+            this.retired = false;
+        }
+        const candidate = this.original;
+        if (!candidate)
+            return;
+        const original = candidate.provider.deviceAdmission;
+        if (!original?.status || !original.retireHost)
+            throw new Error('unqualified_native_host');
+        const status = await original.status();
+        this.nativeConsumers = Math.max(status.workers, status.operations, Number(status.active));
+        const epoch = this.owner.snapshot().deviceEpoch;
+        const retiring = this.stopped || candidate.cleanupOnly || await candidate.retirementRequired?.() === true || !status.connected || status.deviceEpoch !== null && status.deviceEpoch !== epoch ||
+            status.deviceEpoch === null && !status.quiescent ||
+            status.rotationRequired && status.quiescent && this.owner.snapshot().state === 'free' && [...this.consumers.values()].every(value => { const activity = value.activity(); return activity.known && activity.consumers === 0; });
+        if (retiring) {
+            this.published = undefined;
+            original.retire();
+            const results = await Promise.allSettled([...this.consumers.values()].map(consumer => consumer.bind(undefined)));
+            if (candidate.stopOriginal)
+                try {
+                    await candidate.stopOriginal();
+                }
+                catch { }
+            if (results.some(result => result.status === 'rejected'))
+                throw new Error('original_desktop_cleanup_unconfirmed');
+            await original.retireHost(randomUUID());
+            if (this.finalAcknowledgements.size >= 32)
+                this.finalAcknowledgements.delete(this.finalAcknowledgements.values().next().value);
+            this.retired = true;
+            this.unknown = false;
+            this.nativeConsumers = 0;
+            this.finalAcknowledgements.add(original);
+            try {
+                await original.acknowledgeHostRetirement(randomUUID());
+                this.finalAcknowledgements.delete(original);
+            }
+            catch { }
+            if (candidate.finalizeOriginal) {
+                this.pendingFinalizer = candidate.finalizeOriginal;
+                await this.pendingFinalizer();
+                this.pendingFinalizer = undefined;
+            }
+            return;
+        }
+        if (!original.current())
+            throw new Error('original_desktop_cleanup_unconfirmed');
+        if (this.published !== candidate.provider) {
+            await original.bindDeviceEpoch(randomUUID(), epoch);
+            const results = await Promise.allSettled([...this.consumers.values()].map(consumer => consumer.bind(candidate.provider)));
+            if (results.some(result => result.status === 'rejected'))
+                throw new Error('desktop_rebind_unconfirmed');
+            this.published = candidate.provider;
+        }
+        this.unknown = false;
+    }
+    async stop() { this.stopped = true; clearInterval(this.timer); await this.busy; await this.refresh(); }
+}