@platless/axom-cli 0.3.13 → 0.5.9

package/dist/workstation/files/host.js

@@ -0,0 +1,122 @@
+import { runFileFrame } from './adapters/computerFileFrames.js';
+import { FileTools, toolErrorMessage } from './adapters/toolRequests.js';
+import { pinnedForMs } from './fence.js';
+import { FILES_HOST_MAX_IN_FLIGHT } from './hostProtocol.js';
+/*
+ * The files host: a daemon-owned long-lived child (`fork`, not detached, so it stays in the daemon's process group and
+ * cgroup) that runs every workstation file operation — `file_*_request` frames in the request-root scope and `files.*`
+ * tool requests in the configured-roots / read-only scopes. Requests run concurrently; only `pinned()` sections are
+ * mutually exclusive (files/README.md). It exits when its IPC channel disconnects, so a dead daemon never leaves it
+ * behind. The daemon side is files/client.ts.
+ */
+const DISPOSE_BUDGET_MS = 5_000;
+const STATUS_INTERVAL_MS = 1_000;
+if (!process.send) {
+    console.error('[files-host] must be started by the workstation daemon');
+    process.exit(2);
+}
+let tools;
+let initializing = false;
+let closing;
+const inFlight = new Map();
+function send(message) {
+    if (!process.connected)
+        return;
+    try {
+        process.send(message);
+    }
+    catch { /* channel closed underneath us: disconnect handles exit */ }
+}
+function status() {
+    send({ t: 'status', pinnedMs: pinnedForMs(), uploads: tools?.activeUploads ?? 0, encodes: tools?.activeEncodes ?? 0, inFlight: inFlight.size });
+}
+async function init(options) {
+    if (tools || initializing)
+        return;
+    initializing = true;
+    try {
+        // FileTools.create runs uploads recover(): orphans a previous (crashed or killed) host left behind are removed here.
+        tools = await FileTools.create(options);
+        send({ t: 'ready', info: tools.info() });
+    }
+    catch (error) {
+        send({ t: 'init_failed', error: toolErrorMessage(error) });
+        process.exit(1);
+    }
+    finally {
+        initializing = false;
+    }
+}
+function run(request) {
+    if (closing || !tools) {
+        send({ id: request.id, ok: false, error: closing ? 'Files host is stopping' : 'Files host is starting' });
+        return;
+    }
+    if (inFlight.has(request.id)) {
+        send({ id: request.id, ok: false, error: 'Duplicate files host request id' });
+        return;
+    }
+    if (inFlight.size >= FILES_HOST_MAX_IN_FLIGHT) {
+        send({ id: request.id, ok: false, error: 'Files host is busy' });
+        return;
+    }
+    const controller = new AbortController();
+    inFlight.set(request.id, controller);
+    const deadline = request.deadlineAt === null ? undefined : setTimeout(() => controller.abort(), Math.max(0, request.deadlineAt - Date.now()));
+    const current = tools;
+    void (async () => {
+        let reply;
+        try {
+            // runFileFrame never throws: errors (and cancellation) come back as the result frame's `error`.
+            const result = request.op === 'frame' ? await runFileFrame(request.params, controller.signal)
+                : request.op === 'tool' ? await current.dispatch(request.params.method, request.params.params)
+                    : request.op === 'terminalCwd' ? { path: await current.resolveTerminalCwd(request.params.cwd) }
+                        : request.op === 'recoverUploads' ? (await current.recoverUploads(request.params.dir), {})
+                            : (() => { throw new Error('Unsupported files host request'); })();
+            reply = { id: request.id, ok: true, result };
+        }
+        catch (error) {
+            reply = { id: request.id, ok: false, error: toolErrorMessage(error) };
+        }
+        finally {
+            if (deadline)
+                clearTimeout(deadline);
+            inFlight.delete(request.id);
+        }
+        // Status BEFORE the reply (IPC preserves order): when the daemon's caller settles and its shell task ends, the
+        // sampled activity must already include what this request changed (an upload it opened), or a graceful update's
+        // idle check could pass in between.
+        status();
+        send(reply);
+    })();
+}
+/** Refuses new work, lets running calls finish within a budget (a hung IO cannot hold the exit forever), then exits. */
+function shutdown(code) {
+    closing ??= (async () => {
+        for (const controller of inFlight.values())
+            controller.abort();
+        const budget = new Promise(resolve => { setTimeout(resolve, DISPOSE_BUDGET_MS).unref(); });
+        await Promise.race([tools?.dispose().catch(() => { }), budget]);
+        process.exit(code);
+    })();
+    return closing;
+}
+process.on('message', (message) => {
+    if (!message || typeof message !== 'object')
+        return;
+    if ('cancel' in message) {
+        inFlight.get(message.cancel)?.abort();
+        return;
+    }
+    if ('op' in message) {
+        run(message);
+        return;
+    }
+    if (message.t === 'init')
+        void init(message.options);
+    else if (message.t === 'shutdown')
+        void shutdown(0);
+});
+// The daemon is gone (exit, crash, SIGKILL): never outlive it.
+process.on('disconnect', () => { void shutdown(0); });
+setInterval(status, STATUS_INTERVAL_MS).unref();

package/dist/workstation/files/hostProtocol.js

@@ -0,0 +1,2 @@
+/** Requests in flight per host, on both ends. */
+export const FILES_HOST_MAX_IN_FLIGHT = 32;