@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/daemonctl.js

@@ -1,12 +1,28 @@
 import os from 'node:os';
+import { BindingStore } from './control/bindingStore.js';
+import { inspectRuntime, stopRuntime } from './control/runtimeClient.js';
+import { LocalControlError } from './control/protocol.js';
+import { normalizeWorkstationServer } from './control/serverIdentity.js';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { clientDir, loadClientConfig } from './config.js';
+import { randomUUID } from 'node:crypto';
+import { clientDir, loadClientConfig, updateServiceContext } from './config.js';
 import { createServiceManager } from './service/installer.js';
 import { buildServicePath } from './service/types.js';
 import { loginShellPath } from './service/loginShell.js';
 import { KeeperLauncher } from './keepers/kit/launcher.js';
 import { stopKeepers } from './keepers/stop.js';
+import { assertRuntimeRestartSafe } from './control/restartGuard.js';
+import { promises as fs } from 'node:fs';
+import { inspectDeviceRuntime, prepareDeviceRuntimeStop, stopDeviceRuntime } from './control/runtimeClient.js';
+import { assertDeviceUpdateTransitionSafe } from './control/daemonIdentity.js';
+import { RegistrationStore } from './registrations/store.js';
+import { readLegacyRegistrationSources, assertRegistrationEnrollmentAdmission } from './registrations/migration.js';
+import { assertDeviceGuard } from './control/deviceProtocol.js';
+import { resolveRegistrationOwnership } from './runtime/ownership.js';
+import { captureStartupPackageEvidence } from './update/deviceHealth.js';
+import { CLIENT_VERSION } from './version.js';
+import { readDeviceBootstrapRecovery } from './update/recoveryPlan.js';
 const __filename = fileURLToPath(import.meta.url);
 /**
  * The package's real npm bin entry (`package.json`'s `bin.axom`), given the directory a compiled
@@ -36,21 +52,27 @@ export function serviceContext() {
         throw new Error('Axomwork Workstation user service supervision is supported only on macOS and Linux.');
     }
     const directory = path.dirname(__filename);
-    const nodeDirectory = path.dirname(process.execPath);
+    const managed = updateServiceContext();
+    const nodeDirectory = path.dirname(managed.nodePath);
     return {
         platform: process.platform,
         username: os.userInfo().username,
         userId: process.getuid?.() ?? os.userInfo().uid,
         homeDir: os.homedir(),
-        nodePath: process.execPath,
+        nodePath: managed.nodePath,
         cliPath: CLI_PATH,
-        npmPath: process.env.AXOM_WORKSTATION_NPM_PATH ?? path.join(nodeDirectory, 'npm'),
+        npmPath: managed.npmPath,
         // dist/workstation/ is nested under lib/node_modules/@platless/axom-cli; climb to npm's prefix.
-        npmPrefix: process.env.AXOM_WORKSTATION_NPM_PREFIX ?? path.resolve(directory, '../../../../../..'),
+        npmPrefix: managed.npmPrefix,
         configDir: clientDir(),
-        pathEnv: buildServicePath(process.env.PATH, nodeDirectory),
+        pathEnv: buildServicePath(managed.env?.PATH ?? process.env.PATH, nodeDirectory),
+        ...(managed.managed ? { npmConfigPrefix: managed.managed.prefix } : {}),
     };
 }
+async function installationServiceContext(base, shellPath = loginShellPath) {
+    const loginPath = await shellPath();
+    return loginPath ? { ...base, pathEnv: buildServicePath(`${loginPath}:${process.env.PATH ?? ''}`, path.dirname(base.nodePath)) } : base;
+}
 /** The workstation's keepers stopped (see {@link DaemonControllerDeps.stopKeepers}); an unregistered client has none. */
 async function stopRegisteredKeepers() {
     const configDir = clientDir();
@@ -62,6 +84,10 @@ async function stopRegisteredKeepers() {
     });
 }
 const defaultDeps = {
+    identity: () => new BindingStore(clientDir()).inspect(),
+    runtime: async () => (await (await import('./control/inspect.js')).inspectWorkstation(clientDir())).runtime,
+    shutdown: generation => stopRuntime(clientDir(), generation),
+    restartSafe: generation => assertRuntimeRestartSafe(clientDir(), generation),
     service: (context) => createServiceManager(context ?? serviceContext()),
     config: () => loadClientConfig(clientDir()),
     stopKeepers: stopRegisteredKeepers,
@@ -72,6 +98,22 @@ const defaultDeps = {
  */
 export function createDaemonController(overrides = {}) {
     const deps = { ...defaultDeps, ...overrides };
+    async function checked(options) {
+        const runtime = await deps.runtime();
+        if (runtime.state === 'unknown')
+            throw new LocalControlError('OUTCOME_UNKNOWN', 'Cannot verify the running workstation');
+        if (options) {
+            const identity = await deps.identity();
+            if (identity.revision !== options.guard.revision || runtime.generation !== options.guard.runtimeGeneration)
+                throw new LocalControlError('BINDING_CONFLICT', 'Workstation changed; check it again');
+        }
+        if (runtime.state === 'running') {
+            const config = await deps.config();
+            if (!runtime.binding || runtime.binding.server !== normalizeWorkstationServer(config.server) || runtime.binding.workstationId !== config.workstationId)
+                throw new LocalControlError('INSTANCE_OCCUPIED', 'Another workstation binding is running');
+        }
+        return runtime;
+    }
     return {
         async install() {
             // The definition is written from the login shell's PATH when one can be had, unioned with
@@ -79,11 +121,7 @@ export function createDaemonController(overrides = {}) {
             // itself after an update they are not, and only the login shell knows where the user's CLIs
             // are — see loginShellPath for why reusing the service's own PATH would make a machine
             // reinstall its own blind spot.
-            const shellPath = await loginShellPath();
-            const base = serviceContext();
-            const context = shellPath
-                ? { ...base, pathEnv: buildServicePath(`${shellPath}:${process.env.PATH ?? ''}`, path.dirname(base.nodePath)) }
-                : base;
+            const context = await installationServiceContext(serviceContext());
             await deps.service(context).install({ interactive: true });
         },
         // The workstation is stopped by the user: what its keepers host ends too (the daemon first, so nothing relaunches them).
@@ -94,28 +132,191 @@ export function createDaemonController(overrides = {}) {
         finally {
             await deps.stopKeepers();
         } },
-        async start() { await deps.service().start(); },
-        async stop() { try {
-            await deps.service().stop();
+        async start(options) { if ((await checked(options)).state === 'running')
+            return; await deps.service().start(); },
+        async stop(options) { const runtime = await checked(options); try {
+            if (runtime.mode === 'foreground' && runtime.generation)
+                await deps.shutdown(runtime.generation);
+            else
+                await deps.service().stop();
         }
         finally {
             await deps.stopKeepers();
         } },
         // A restart keeps the keepers: terminals, commands and agent sessions go on under the next daemon.
-        async restart() { await deps.service().restart(); },
+        async restart(options) {
+            const runtime = await checked(options);
+            if (runtime.state === 'running' && runtime.generation)
+                await deps.restartSafe(runtime.generation);
+            if (runtime.mode === 'foreground' && runtime.generation)
+                await deps.shutdown(runtime.generation);
+            await deps.service().restart();
+        },
+        async setEnabled(enabled, options) {
+            const runtime = await checked(options);
+            const service = deps.service();
+            if (!service.setEnabled)
+                throw new LocalControlError('UNSUPPORTED_PROTOCOL', 'Service enablement is unavailable');
+            if (enabled)
+                await service.setEnabled(true);
+            else {
+                try {
+                    await service.setEnabled(false);
+                    if (runtime.mode === 'foreground' && runtime.generation) {
+                        const current = await deps.runtime();
+                        if (current.state === 'running' && current.generation === runtime.generation)
+                            await deps.shutdown(runtime.generation);
+                        else if (current.state !== 'stopped')
+                            throw new LocalControlError('OUTCOME_UNKNOWN', 'The running workstation changed during shutdown');
+                    }
+                }
+                finally {
+                    await deps.stopKeepers();
+                }
+            }
+        },
         async status() {
+            const runtime = await deps.runtime();
+            if (runtime.state === 'running' && runtime.binding)
+                return { running: true, server: runtime.binding.server, workstationId: runtime.binding.workstationId };
+            if (runtime.state === 'unknown')
+                return { running: false, uncertain: true };
             const state = await deps.service().status();
-            if (!state.running)
-                return { running: false };
-            const config = await deps.config().catch(() => null);
-            return { running: true, server: config?.server, workstationId: config?.workstationId };
+            return state.running ? { running: true, uncertain: true } : { running: false };
+        },
+    };
+}
+export function createDeviceDaemonController(directory, overrides = {}) {
+    const context = overrides.context ?? (() => ({ ...serviceContext(), configDir: directory }));
+    const service = overrides.service ?? ((input) => createServiceManager(input ?? context()));
+    const store = new RegistrationStore(directory);
+    const runtime = async () => {
+        try {
+            return (await inspectDeviceRuntime(directory)).runtime;
+        }
+        catch {
+            const legacy = await inspectRuntime(directory);
+            if (legacy.state !== 'stopped')
+                throw new LocalControlError('OUTCOME_UNKNOWN', 'The existing owner is not a verified device daemon');
+            return { state: 'stopped', generation: null, mode: 'unknown' };
+        }
+    };
+    const checked = async (options) => {
+        if (options) {
+            const inspection = await inspectDeviceRuntime(directory);
+            assertDeviceGuard(options.guard, inspection);
+            return inspection.runtime;
+        }
+        return runtime();
+    };
+    const terminateKeepers = async () => {
+        const inspection = await store.inspect();
+        if (!inspection.known || inspection.entries.some(entry => entry.state !== 'ready'))
+            throw new LocalControlError('OUTCOME_UNKNOWN', 'Cannot verify every owned keeper namespace');
+        for (const registration of await store.list()) {
+            const sources = await readLegacyRegistrationSources(directory, registration.id);
+            const ownership = await resolveRegistrationOwnership(registration, sources);
+            const launcher = new KeeperLauncher({ configDir: registration.keeperConfigDirectory, workstationId: registration.workstationId, server: sources?.keeperServer ?? registration.server, ownership });
+            const reports = await stopKeepers(launcher);
+            if (reports.some(report => !report.result.stopped))
+                throw new LocalControlError('OUTCOME_UNKNOWN', 'A workstation keeper has not stopped');
+        }
+    };
+    const finishPrepared = async (generation, mode) => {
+        const current = await runtime();
+        if (current.state === 'stopped')
+            return;
+        if (current.generation !== generation)
+            throw new LocalControlError('BINDING_CONFLICT', 'A successor device daemon replaced the prepared owner');
+        await stopDeviceRuntime(directory, generation, mode);
+    };
+    return {
+        async install(options) {
+            const installation = await installationServiceContext(context(), overrides.loginShellPath);
+            if (!path.isAbsolute(installation.cliPath) || path.resolve(installation.cliPath) !== installation.cliPath || path.basename(installation.cliPath) !== 'cli.js' || path.basename(path.dirname(installation.cliPath)) !== 'dist')
+                throw new LocalControlError('OUTCOME_UNKNOWN', 'Installed service entrypoint must identify its exact dist/cli.js package');
+            const startup = await captureStartupPackageEvidence(path.dirname(path.dirname(installation.cliPath)), CLIENT_VERSION);
+            await assertDeviceUpdateTransitionSafe(directory, startup);
+            if (options) {
+                const recovery = await readDeviceBootstrapRecovery(directory, startup);
+                const transaction = recovery?.transaction;
+                if (!transaction || transaction.lifecycle !== 'provision-and-arm' || transaction.phase !== 'RESTARTING' || transaction.installation !== 'started' || transaction.installedRollback || transaction.recoveryRequired || transaction.initiatingDaemonGeneration !== options.updateGeneration)
+                    throw new LocalControlError('OUTCOME_UNKNOWN', 'Service replacement requires the original active device update handoff');
+                const current = await inspectDeviceRuntime(directory);
+                if (current.runtime.state !== 'running' || current.runtime.generation !== options.updateGeneration)
+                    throw new LocalControlError('BINDING_CONFLICT', 'The original device update owner changed before service replacement');
+            }
+            await service(installation).install({ interactive: true });
         },
+        async start(options) { if ((await checked(options)).state === 'running')
+            return; await assertDeviceUpdateTransitionSafe(directory); await assertRegistrationEnrollmentAdmission(directory); await service().start(); },
+        async stop(options) {
+            const current = await checked(options);
+            const manager = service();
+            if (current.generation && current.mode === 'launchd') {
+                await prepareDeviceRuntimeStop(directory, current.generation, 'terminate', options?.operationId ?? randomUUID());
+                await manager.stop();
+                await finishPrepared(current.generation, 'terminate');
+            }
+            else {
+                if (current.generation)
+                    await stopDeviceRuntime(directory, current.generation, 'terminate');
+                await manager.stop();
+            }
+            if (!current.generation)
+                await terminateKeepers();
+        },
+        async uninstall(options) {
+            const current = await checked(options);
+            const manager = service();
+            if (current.generation && current.mode === 'launchd') {
+                await prepareDeviceRuntimeStop(directory, current.generation, 'terminate', options?.operationId ?? randomUUID());
+                await manager.uninstall();
+                await finishPrepared(current.generation, 'terminate');
+            }
+            else {
+                if (current.generation)
+                    await stopDeviceRuntime(directory, current.generation, 'terminate');
+                await manager.uninstall();
+            }
+            if (!current.generation)
+                await terminateKeepers();
+        },
+        async restart(options) {
+            const current = await checked(options);
+            const manager = service();
+            if (current.generation) {
+                await (overrides.restartSafe ?? (generation => assertRuntimeRestartSafe(directory, generation)))(current.generation);
+                if (current.mode === 'launchd') {
+                    await prepareDeviceRuntimeStop(directory, current.generation, 'detach', options?.operationId ?? randomUUID());
+                    await manager.stop();
+                    await finishPrepared(current.generation, 'detach');
+                    await manager.restart();
+                    return;
+                }
+                await stopDeviceRuntime(directory, current.generation, 'detach');
+            }
+            await manager.restart();
+        },
+        async status() { const current = await runtime(); return { running: current.state === 'running' }; },
     };
 }
+async function deviceControllerSelected() {
+    for (const name of ['device.json', 'legacy-migration.json'])
+        try {
+            await fs.lstat(path.join(clientDir(), name));
+            return true;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    return false;
+}
 const controller = createDaemonController();
-export const install = () => controller.install();
-export const uninstall = () => controller.uninstall();
-export const start = () => controller.start();
-export const stop = () => controller.stop();
-export const restart = () => controller.restart();
-export const status = () => controller.status();
+export const install = async () => (await deviceControllerSelected() ? createDeviceDaemonController(clientDir()) : controller).install();
+export const uninstall = async () => (await deviceControllerSelected() ? createDeviceDaemonController(clientDir()) : controller).uninstall();
+export const start = async () => (await deviceControllerSelected() ? createDeviceDaemonController(clientDir()) : controller).start();
+export const stop = async () => (await deviceControllerSelected() ? createDeviceDaemonController(clientDir()) : controller).stop();
+export const restart = async () => (await deviceControllerSelected() ? createDeviceDaemonController(clientDir()) : controller).restart();
+export const status = async () => (await deviceControllerSelected() ? createDeviceDaemonController(clientDir()) : controller).status();

package/dist/workstation/desktopControl/audio.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+export const audioMode = z.enum(['off', 'auto', 'high', 'low']);
+export const AUDIO_HEADER_BYTES = 40;
+export const AUDIO_MAX_PAYLOAD = 1000;
+export const audioConfiguration = z.strictObject({
+    commandId: z.string().regex(/^[0-9a-f]{32}$/), audioEpoch: z.number().int().min(1).max(0xffffffff),
+    sampleRate: z.literal(48000), channels: z.literal(2), framesPerPacket: z.literal(960),
+    bitrate: z.number().int().min(64000).max(256000), lookaheadFrames: z.number().int().min(0).max(960),
+});
+function requireAudio(value) {
+    if (!value)
+        throw new Error('invalid_audio');
+}
+export function decodeAudio(bytes) {
+    requireAudio(bytes.length >= 41 && bytes.length <= 1040 && bytes.subarray(0, 4).equals(Buffer.from('AXDA')));
+    requireAudio(bytes[4] === 1 && bytes[5] === 0 && bytes.readUInt16BE(6) === 40 &&
+        bytes.readUInt16BE(32) === 960 && bytes[34] === 2 && bytes[35] === 0 &&
+        bytes.readUInt16BE(38) === 0 && bytes.readUInt16BE(36) === bytes.length - 40);
+    const packet = { epoch: bytes.readUInt32BE(8), sequence: bytes.readUInt32BE(12),
+        firstSample: Number(bytes.readBigUInt64BE(16)), captureTimestampUs: Number(bytes.readBigUInt64BE(24)),
+        payload: bytes.subarray(40) };
+    validate(packet);
+    return packet;
+}
+function validate(packet) {
+    requireAudio(Number.isInteger(packet.epoch) && packet.epoch >= 1 && packet.epoch <= 0xffffffff &&
+        Number.isInteger(packet.sequence) && packet.sequence >= 1 && packet.sequence <= 0xffffffff &&
+        Number.isSafeInteger(packet.firstSample) && packet.firstSample === (packet.sequence - 1) * 960 &&
+        Number.isSafeInteger(packet.captureTimestampUs) && packet.captureTimestampUs >= 0 &&
+        packet.payload.length >= 1 && packet.payload.length <= AUDIO_MAX_PAYLOAD);
+}
+export function encodeAudio(packet) {
+    validate(packet);
+    const bytes = Buffer.alloc(AUDIO_HEADER_BYTES + packet.payload.length);
+    bytes.write('AXDA');
+    bytes[4] = 1;
+    bytes.writeUInt16BE(40, 6);
+    bytes.writeUInt32BE(packet.epoch, 8);
+    bytes.writeUInt32BE(packet.sequence, 12);
+    bytes.writeBigUInt64BE(BigInt(packet.firstSample), 16);
+    bytes.writeBigUInt64BE(BigInt(packet.captureTimestampUs), 24);
+    bytes.writeUInt16BE(960, 32);
+    bytes[34] = 2;
+    bytes.writeUInt16BE(packet.payload.length, 36);
+    packet.payload.copy(bytes, 40);
+    return bytes;
+}
+export class AudioRateController {
+    mode;
+    ladder = [64000, 96000, 128000, 192000, 256000];
+    current = 128000;
+    bad = 0;
+    healthy = 0;
+    lastObservation = -Infinity;
+    lastDown = -Infinity;
+    lastUp = -Infinity;
+    constructor(mode = 'off') {
+        this.mode = mode;
+    }
+    get bitrate() {
+        return this.mode === 'off' ? 0 : this.mode === 'high' ? 256000 : this.mode === 'low' ? 64000 : this.current;
+    }
+    select(mode) {
+        audioMode.parse(mode);
+        if (mode !== this.mode) {
+            this.current = mode === 'auto' ? 128000 : this.current;
+            this.bad = this.healthy = 0;
+            this.lastObservation = this.lastDown = this.lastUp = -Infinity;
+        }
+        this.mode = mode;
+        return this.bitrate;
+    }
+    observe(now, feedback) {
+        if (this.mode !== 'auto' || !Number.isFinite(now) || now - this.lastObservation < 500)
+            return this.bitrate;
+        if (![feedback.queueMs, feedback.lateRatio, feedback.lostRatio, feedback.underruns].every(Number.isFinite) ||
+            feedback.queueMs < 0 || feedback.lateRatio < 0 || feedback.lateRatio > 1 ||
+            feedback.lostRatio < 0 || feedback.lostRatio > 1 || feedback.underruns < 0)
+            return this.bitrate;
+        this.lastObservation = now;
+        const adverse = feedback.congested || feedback.queueMs > 40 || feedback.lateRatio > 0.02 || feedback.lostRatio > 0.03;
+        const recovered = !adverse && feedback.headroom && feedback.queueMs < 15 &&
+            feedback.lateRatio < 0.005 && feedback.lostRatio < 0.005 && feedback.underruns === 0;
+        this.bad = adverse ? this.bad + 1 : 0;
+        this.healthy = recovered ? this.healthy + 1 : 0;
+        const index = this.ladder.indexOf(this.current);
+        if (this.bad >= 2 && now - this.lastDown >= 1000 && index > 0) {
+            this.current = this.ladder[index - 1];
+            this.bad = this.healthy = 0;
+            this.lastDown = now;
+        }
+        else if (this.healthy >= 10 && now - Math.max(this.lastUp, this.lastDown) >= 5000 && index < this.ladder.length - 1) {
+            this.current = this.ladder[index + 1];
+            this.bad = this.healthy = 0;
+            this.lastUp = now;
+        }
+        return this.bitrate;
+    }
+}

package/dist/workstation/desktopControl/automationDevice.js

@@ -0,0 +1,219 @@
+import WebSocket from 'ws';
+import { automationSchema, decodeAutomationRequest, decodeAutomationResponse, encodeAutomationBinary } from './automationProtocol.js';
+import { parseAutomationJson } from './automationJson.js';
+import { desktopSocketUrl } from './deviceSockets.js';
+import { bounded, NativeCommandError } from './helperProcess.js';
+import { managedAutomationBinding } from './automationLocalState.js';
+export class AutomationDeviceConnections {
+    server;
+    provider;
+    allowPrivateWs;
+    localStateDirectory;
+    admission;
+    get activeCount() { return this.active.size; }
+    active = new Map();
+    generation;
+    constructor(server, provider, allowPrivateWs = false, localStateDirectory, admission) {
+        this.server = server;
+        this.provider = provider;
+        this.allowPrivateWs = allowPrivateWs;
+        this.localStateDirectory = localStateDirectory;
+        this.admission = admission;
+    }
+    ready(generation) { this.close(); this.generation = generation; }
+    retired(generation) { if (generation === this.generation) {
+        this.close();
+        this.generation = undefined;
+    } }
+    close() { for (const entry of this.active.values())
+        entry.close(); this.active.clear(); }
+    async prepare(grant, binding, generation) {
+        if (generation !== this.generation || binding.route.deviceGeneration !== generation || this.active.size >= 8 || this.active.has(grant))
+            throw new Error('stale_generation');
+        if (!this.localStateDirectory)
+            throw new Error('trusted_storage_unavailable');
+        const localBinding = await managedAutomationBinding(this.localStateDirectory, { ...binding, registrationId: this.admission?.registrationId ?? binding.registrationId });
+        if (generation !== this.generation || this.active.size >= 8 || this.active.has(grant))
+            throw new Error('stale_generation');
+        const socket = new WebSocket(desktopSocketUrl(this.server, 'automation', this.allowPrivateWs), {
+            headers: { 'X-Axom-Automation-Grant': grant, 'X-Axom-Automation-Features': 'capture_wait_v1' }, followRedirects: false, perMessageDeflate: false, maxPayload: 49152
+        });
+        let selectedWait = false;
+        socket.once('upgrade', response => {
+            const selected = response.headers['x-axom-automation-features'];
+            if (selected !== undefined && selected !== 'capture_wait_v1') {
+                socket.terminate();
+                return;
+            }
+            selectedWait = selected === 'capture_wait_v1';
+        });
+        let session, retired = false, leaseBusy = false;
+        let mode = 'live';
+        let statusRequest;
+        const pending = new Map();
+        let lease;
+        const close = () => {
+            if (retired)
+                return;
+            retired = true;
+            clearInterval(lease);
+            pending.forEach(controller => controller.abort());
+            pending.clear();
+            this.active.delete(grant);
+            socket.terminate();
+            void session?.dispose().catch(() => { });
+        };
+        const current = () => !retired && this.generation === generation;
+        this.active.set(grant, { generation, close });
+        socket.on('error', close);
+        socket.on('close', close);
+        const send = async (bytes) => {
+            if (!current() || socket.readyState !== WebSocket.OPEN || socket.bufferedAmount > 8388608)
+                throw new Error('transport_failed');
+            await bounded(new Promise((resolve, reject) => socket.send(bytes, error => error ? reject(error) : resolve())), 5000);
+        };
+        try {
+            await bounded(new Promise((resolve, reject) => { socket.once('open', resolve); socket.once('error', reject); socket.once('close', () => reject(new Error('closed'))); }), 3000);
+            if (!this.provider?.prepareAutomation) {
+                await send(JSON.stringify({ automationProtocol: 1, operations: [] }));
+                return;
+            }
+            try {
+                session = await this.provider.prepareAutomation(localBinding);
+            }
+            catch {
+                await send(JSON.stringify({ automationProtocol: 1, operations: [] }));
+                return;
+            }
+            if (!current()) {
+                await session.dispose();
+                return;
+            }
+            await send(JSON.stringify({ automationProtocol: 1, operations: session.operations.filter(method => Object.hasOwn(automationSchema.requests, method) && (method !== 'capture_wait_v1' || selectedWait)) }));
+            const backend = session;
+            lease = setInterval(() => {
+                if (leaseBusy || !current() || mode !== 'live')
+                    return;
+                leaseBusy = true;
+                if (this.admission && !this.admission.current(localBinding)) {
+                    close();
+                    return;
+                }
+                void backend.renewAuthenticatedLease(3000).catch(() => { if (mode === 'live')
+                    close(); }).finally(() => { leaseBusy = false; });
+            }, 1000);
+            socket.on('message', (bytes, binary) => {
+                if (!current() || binary) {
+                    close();
+                    return;
+                }
+                try {
+                    const text = bytes.toString(), raw = parseAutomationJson(text, 49152).value;
+                    if (raw.command === 'cancel' && Object.keys(raw).length === 2) {
+                        pending.get(raw.requestId)?.abort();
+                        return;
+                    }
+                    if (raw.command === 'status_only' || raw.command === 'isolate') {
+                        if (pending.size >= 64 || pending.has(raw.requestId)) {
+                            close();
+                            return;
+                        }
+                        mode = 'detaching';
+                        clearInterval(lease);
+                        const controller = new AbortController();
+                        pending.set(raw.requestId, controller);
+                        const operation = raw.command === 'status_only' ? backend.detachApplicationStatus?.(raw.launchRequestId, raw.canonicalArgsDigest) : backend.isolate?.();
+                        void (operation ?? Promise.reject(new Error('unsupported'))).then(async (result) => {
+                            if (raw.command === 'status_only') {
+                                mode = 'status_only';
+                                statusRequest = raw.launchRequestId;
+                            }
+                            if (current() && !controller.signal.aborted)
+                                await send(JSON.stringify({ control: raw.command, id: raw.requestId, result }));
+                        }, async (error) => {
+                            if (current() && !controller.signal.aborted)
+                                await send(JSON.stringify({ control: 'prepare_failed', id: raw.requestId, code: error instanceof Error ? error.message : 'service_unavailable', detail: null }));
+                        }).catch(close).finally(() => pending.delete(raw.requestId));
+                        return;
+                    }
+                    if (raw.command === 'prepare' && Object.keys(raw).length === 3) {
+                        if (this.admission && !this.admission.current(localBinding))
+                            throw new Error('control_lost');
+                        if (mode !== 'live') {
+                            void send(JSON.stringify({ control: 'prepare_failed', id: raw.requestId, code: 'control_lost', detail: null })).catch(close);
+                            return;
+                        }
+                        if (pending.size >= 64 || pending.has(raw.requestId)) {
+                            close();
+                            return;
+                        }
+                        const controller = new AbortController();
+                        pending.set(raw.requestId, controller);
+                        void backend.prepareAttachment(raw.preparation, { signal: controller.signal }).then(attachment => { if (current() && !controller.signal.aborted)
+                            return send(JSON.stringify({ control: 'prepared', id: raw.requestId, attachment })); }, error => { if (current() && !controller.signal.aborted)
+                            return send(JSON.stringify({ control: 'prepare_failed', id: raw.requestId, code: error instanceof Error ? error.message : 'service_unavailable', detail: error instanceof NativeCommandError ? error.detail : null })); }).catch(close).finally(() => pending.delete(raw.requestId));
+                        return;
+                    }
+                    const request = decodeAutomationRequest(text);
+                    if (this.admission && !this.admission.current(localBinding) && request.method !== 'close')
+                        throw new Error('control_lost');
+                    if (mode !== 'live' && (mode !== 'status_only' || request.method !== 'application_status' || request.payload.requestId !== statusRequest)) {
+                        void send(JSON.stringify({ ...request, payload: { type: 'failure', code: 'control_lost', message: 'Input authority was retired', detail: null } })).catch(close);
+                        return;
+                    }
+                    if (pending.size >= 64 || pending.has(request.requestId)) {
+                        close();
+                        return;
+                    }
+                    if (request.method === 'capture_wait_v1' && (!selectedWait || !backend.operations.includes(request.method))) {
+                        void send(JSON.stringify({ ...request, payload: { type: 'failure', code: 'unsupported', message: 'Conditional observation was not negotiated', detail: null } })).catch(close);
+                        return;
+                    }
+                    const controller = new AbortController();
+                    pending.set(request.requestId, controller);
+                    void (async () => {
+                        const reply = await backend.execute(request, { signal: controller.signal });
+                        if (!current() || controller.signal.aborted)
+                            return;
+                        let response = decodeAutomationResponse(JSON.stringify(reply.response), request);
+                        let binary;
+                        if (reply.image) {
+                            const data = response.payload.data, transfer = request.method === 'capture' ? data : request.method === 'capture_wait_v1' ? data.image : data.postImage;
+                            binary = encodeAutomationBinary(transfer.header, reply.image);
+                            const captureAgeMs = Date.now() - transfer.metadata.capturedAtEpochMs;
+                            if (!Number.isSafeInteger(captureAgeMs) || captureAgeMs < 0 || captureAgeMs > 30000) {
+                                if (request.method !== 'act' && request.method !== 'status')
+                                    throw new Error('stale_observation');
+                                response = { ...response, payload: { type: 'success', data: { ...data, postImage: null, captureError: 'capture_failed' } } };
+                                binary = undefined;
+                            }
+                            else
+                                response = { ...response, captureAgeMs };
+                        }
+                        await send(JSON.stringify(response));
+                        if (binary)
+                            await send(binary);
+                    })().catch(async (error) => {
+                        if (!current() || controller.signal.aborted)
+                            return;
+                        const code = error instanceof Error && error.message === 'stale_observation' ? 'stale_observation'
+                            : error instanceof Error && error.message === 'unsupported' ? 'unsupported' : 'service_unavailable';
+                        try {
+                            await send(JSON.stringify({ ...request, payload: { type: 'failure', code, message: error instanceof Error ? error.message : code, detail: null } }));
+                        }
+                        catch {
+                            close();
+                        }
+                    }).finally(() => pending.delete(request.requestId));
+                }
+                catch {
+                    close();
+                }
+            });
+        }
+        catch (error) {
+            close();
+            throw error;
+        }
+    }
+}