@platless/axom-cli 0.1.0 → 0.3.13

package/dist/workstation/tools/terminal.js

@@ -0,0 +1,214 @@
+import os from 'node:os';
+import { createRequire } from 'node:module';
+import { identifier, integer, keys, TOOL_RESULT_BYTES } from './validation.js';
+const require = createRequire(import.meta.url);
+const { Terminal } = require('@xterm/headless');
+const { SerializeAddon } = require('@xterm/addon-serialize');
+const HISTORY_BYTES = 1024 * 1024;
+const MAX_POLL_BYTES = 64 * 1024;
+const SCROLLBACK = 1000;
+export class PersistentTerminals {
+    files;
+    options;
+    sessions = new Map();
+    ptyModule;
+    error;
+    constructor(files, options) {
+        this.files = files;
+        this.options = options;
+        try {
+            this.ptyModule = (options.loadPty ?? (() => require('node-pty')))();
+        }
+        catch {
+            this.error = 'Terminal native dependency unavailable; reinstall CLI with optional node-pty support';
+        }
+    }
+    get available() { return !!this.ptyModule; }
+    descriptor(s) {
+        return { id: s.id, name: s.name, cwd: s.cwd, cols: s.cols, rows: s.rows, exited: s.exited, exitCode: s.exitCode, controllerId: s.controllerId };
+    }
+    control(s, clientId) {
+        if (s.controllerId !== clientId)
+            throw new Error('Terminal is controlled by another client; take control explicitly');
+    }
+    resize(s, p) {
+        const cols = integer(p, 'cols', 20, 300, s.cols);
+        const rows = integer(p, 'rows', 5, 100, s.rows);
+        if (cols !== s.cols || rows !== s.rows) {
+            if (!s.exited)
+                s.pty.resize(cols, rows);
+            s.terminal.resize(cols, rows);
+            s.cols = cols;
+            s.rows = rows;
+        }
+    }
+    snapshot(s) {
+        // Scroll position belongs to the viewer, never the keeper. Serialization includes normal and
+        // alternate buffers, SGR attributes, cursor and modes; it starts from a clean emulator.
+        for (let scrollback = SCROLLBACK;; scrollback = Math.floor(scrollback / 2)) {
+            const snapshot = '\x1bc' + s.serializer.serialize({ scrollback });
+            if (Buffer.byteLength(JSON.stringify({ snapshot })) < TOOL_RESULT_BYTES - 8192)
+                return snapshot;
+            if (!scrollback)
+                throw new Error('Terminal screen exceeds snapshot limit; resize to a smaller viewport');
+        }
+    }
+    output(s, data) {
+        if (!data || s.closed)
+            return;
+        const bytes = Buffer.byteLength(data);
+        s.pendingBytes += bytes;
+        if (s.pendingBytes > 256 * 1024)
+            s.pty.pause();
+        const previous = s.rendered;
+        s.rendered = previous.then(() => new Promise(resolve => {
+            s.terminal.write(data, () => {
+                // Each PTY event is a sequence boundary. A single large event can exceed the history budget;
+                // dropping it is safe because poll then returns a fully rendered snapshot.
+                s.seq += 1;
+                s.ring.push({ seq: s.seq, data, bytes });
+                s.ringBytes += bytes;
+                const limit = this.options.historyBytes ?? HISTORY_BYTES;
+                while (s.ringBytes > limit && s.ring.length)
+                    s.ringBytes -= s.ring.shift().bytes;
+                s.pendingBytes -= bytes;
+                if (s.pendingBytes < 64 * 1024 && !s.exited)
+                    s.pty.resume();
+                resolve();
+            });
+        }));
+    }
+    async dispatch(method, p) {
+        if (method === 'terminal.list') {
+            keys(p, []);
+            return { sessions: [...this.sessions.values()].map(s => this.descriptor(s)) };
+        }
+        if (!this.ptyModule)
+            throw new Error(this.error ?? 'Terminal unavailable');
+        const id = identifier(p, 'id');
+        const clientId = identifier(p, 'clientId');
+        if (method === 'terminal.create') {
+            keys(p, ['id', 'clientId', 'name', 'cwd', 'cols', 'rows']);
+            const cols = integer(p, 'cols', 20, 300, 100);
+            const rows = integer(p, 'rows', 5, 100, 30);
+            if (p.name !== undefined && (typeof p.name !== 'string' || !p.name.length || p.name.length > 128 || /[\x00-\x1f]/.test(p.name)))
+                throw new Error('Invalid terminal name');
+            const old = this.sessions.get(id);
+            if (old)
+                return this.descriptor(old);
+            if (this.sessions.size >= 8)
+                throw new Error('Terminal session limit exceeded');
+            if (p.cwd !== undefined && typeof p.cwd !== 'string')
+                throw new Error('Invalid cwd');
+            const cwd = await this.files.resolve(p.cwd ?? this.files.home);
+            const terminal = new Terminal({ cols, rows, scrollback: SCROLLBACK, allowProposedApi: true });
+            const serializer = new SerializeAddon();
+            // Headless and browser xterm share the addon contract, but their declaration packages differ.
+            terminal.loadAddon(serializer);
+            let pty;
+            try {
+                pty = this.ptyModule.spawn(this.options.shell ?? process.env.SHELL ?? os.userInfo().shell ?? '/bin/sh', ['-l'], { name: 'xterm-256color', cwd, cols, rows, env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor' } });
+            }
+            catch (error) {
+                terminal.dispose();
+                throw error;
+            }
+            const session = { id, name: p.name ?? 'Terminal', cwd, cols, rows, exited: false, exitCode: null, controllerId: clientId, pty, closed: false, terminal, serializer, seq: 0, ring: [], ringBytes: 0, pendingBytes: 0, rendered: Promise.resolve() };
+            pty.onData(data => this.output(session, data));
+            pty.onExit(event => { session.exited = true; session.exitCode = event.exitCode; });
+            // Answering terminal queries (DA/DSR, etc.) is keeper-owned and does not require a web client.
+            terminal.onData(data => { if (!session.exited)
+                pty.write(data); });
+            this.sessions.set(id, session);
+            return this.descriptor(session);
+        }
+        const s = this.sessions.get(id);
+        if (!s)
+            throw new Error('Terminal session not found; keeper restart loses live PTYs');
+        switch (method) {
+            case 'terminal.attach': {
+                keys(p, ['id', 'clientId', 'cols', 'rows']);
+                // Validate dimensions even for a viewer, but only the controller's dimensions affect PTY.
+                integer(p, 'cols', 20, 300, s.cols);
+                integer(p, 'rows', 5, 100, s.rows);
+                await s.rendered;
+                if (s.controllerId === null)
+                    s.controllerId = clientId;
+                if (s.controllerId === clientId)
+                    this.resize(s, p);
+                return { session: this.descriptor(s), seq: s.seq, snapshot: this.snapshot(s), control: s.controllerId === clientId };
+            }
+            case 'terminal.poll': {
+                keys(p, ['id', 'clientId', 'after']);
+                const after = integer(p, 'after', 0, Number.MAX_SAFE_INTEGER);
+                await s.rendered;
+                const common = { exited: s.exited, exitCode: s.exitCode, control: s.controllerId === clientId };
+                if (after > s.seq || after < (s.ring[0]?.seq ?? s.seq + 1) - 1)
+                    return { ...common, seq: s.seq, data: '', reset: true, snapshot: this.snapshot(s) };
+                let data = '';
+                let bytes = 0;
+                let seq = after;
+                for (const output of s.ring) {
+                    if (output.seq <= after)
+                        continue;
+                    if (bytes + output.bytes > MAX_POLL_BYTES) {
+                        if (!bytes)
+                            return { ...common, seq: s.seq, data: '', reset: true, snapshot: this.snapshot(s) };
+                        break;
+                    }
+                    data += output.data;
+                    bytes += output.bytes;
+                    seq = output.seq;
+                }
+                return { ...common, seq, data, reset: false };
+            }
+            case 'terminal.takeover':
+                keys(p, ['id', 'clientId']);
+                s.controllerId = clientId;
+                return { ok: true };
+            case 'terminal.detach':
+                keys(p, ['id', 'clientId']);
+                if (s.controllerId === clientId)
+                    s.controllerId = null;
+                return { ok: true };
+            case 'terminal.write':
+                keys(p, ['id', 'clientId', 'data']);
+                this.control(s, clientId);
+                if (s.exited)
+                    throw new Error('Terminal has exited');
+                if (typeof p.data !== 'string' || Buffer.byteLength(p.data) > 64 * 1024)
+                    throw new Error('Invalid terminal input');
+                s.pty.write(p.data);
+                return { ok: true };
+            case 'terminal.resize':
+                keys(p, ['id', 'clientId', 'cols', 'rows']);
+                this.control(s, clientId);
+                integer(p, 'cols', 20, 300);
+                integer(p, 'rows', 5, 100);
+                await s.rendered;
+                this.resize(s, p);
+                return { ok: true };
+            case 'terminal.close':
+                keys(p, ['id', 'clientId']);
+                this.control(s, clientId);
+                this.sessions.delete(id);
+                s.closed = true;
+                if (!s.exited)
+                    s.pty.kill();
+                await s.rendered;
+                s.terminal.dispose();
+                return { ok: true };
+            default: throw new Error('Unsupported terminal tool');
+        }
+    }
+    async dispose() {
+        for (const session of this.sessions.values()) {
+            session.closed = true;
+            if (!session.exited)
+                session.pty.kill();
+            await session.rendered;
+            session.terminal.dispose();
+        }
+        this.sessions.clear();
+    }
+}

package/dist/workstation/tools/validation.js

@@ -0,0 +1,50 @@
+/** Bounds apply on both the encrypted channel and private keeper IPC. */
+export const TOOL_REQUEST_BYTES = 128 * 1024;
+export const TOOL_RESULT_BYTES = 2 * 1024 * 1024;
+export const CHUNK_BYTES = 64 * 1024;
+export const TOOL_METHODS = new Set([
+    'browser.list', 'browser.create', 'browser.attach', 'browser.frame', 'browser.navigate', 'browser.input', 'browser.takeover', 'browser.detach', 'browser.close',
+    'tools.info', 'terminal.list', 'terminal.create', 'terminal.attach', 'terminal.poll',
+    'terminal.write', 'terminal.resize', 'terminal.takeover', 'terminal.detach', 'terminal.close',
+    'files.list', 'files.read', 'files.mkdir', 'files.rename', 'files.delete',
+    'files.upload.begin', 'files.upload.chunk', 'files.upload.finish', 'files.upload.cancel',
+]);
+export function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function keys(params, allowed) {
+    if (Object.keys(params).some(key => !allowed.includes(key)))
+        throw new Error('Unexpected tool parameter');
+}
+export function string(params, name, max = 4096, fallback) {
+    const value = params[name] === undefined ? fallback : params[name];
+    if (typeof value !== 'string' || !value.length || value.includes('\0') || value.length > max)
+        throw new Error(`Invalid ${name}`);
+    return value;
+}
+export function identifier(params, name) {
+    const value = string(params, name, 128);
+    if (!/^[A-Za-z0-9_.:-]+$/.test(value))
+        throw new Error(`Invalid ${name}`);
+    return value;
+}
+export function integer(params, name, min, max, fallback) {
+    const value = params[name] === undefined ? fallback : params[name];
+    if (!Number.isSafeInteger(value) || value < min || value > max)
+        throw new Error(`Invalid ${name}`);
+    return value;
+}
+export function base64(value) {
+    if (typeof value !== 'string' || value.length > Math.ceil(CHUNK_BYTES / 3) * 4 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))
+        throw new Error('Invalid upload chunk');
+    const bytes = Buffer.from(value, 'base64');
+    if (bytes.length > CHUNK_BYTES || bytes.toString('base64') !== value)
+        throw new Error('Invalid upload chunk');
+    return bytes;
+}
+export function validateRequest(method, params) {
+    if (typeof method !== 'string' || !TOOL_METHODS.has(method))
+        throw new Error('Unsupported workstation tool');
+    if (!object(params) || Buffer.byteLength(JSON.stringify(params)) > TOOL_REQUEST_BYTES)
+        throw new Error('Invalid or oversized tool parameters');
+}

package/dist/workstation/update/coordinator.js

@@ -93,6 +93,14 @@ export class UpdateCoordinator {
         await this.transition({ ...this.status, phase: 'SUCCEEDED' });
     }
     async ensureInitialized() {
+        // Concurrent callers must share one in-flight attempt (assigned synchronously below, before
+        // any `await`), but a *rejected* attempt must not stay memoized: a transient failure here --
+        // the state dir being unwritable while the daemon died mid-update, say -- would otherwise wedge
+        // this coordinator forever, since every future `handle`/`snapshotAsync`/`managementReady` call
+        // awaits the same rejected promise and never gets a chance to retry. Clearing `this.initialized`
+        // only happens inside this same promise's own `.catch`, i.e. strictly after it has settled, so
+        // callers that started awaiting it while it was still in flight all observe the same outcome;
+        // only a call that arrives *after* it has rejected gets to start a fresh attempt.
         if (!this.initialized)
             this.initialized = this.options.state.load().then(async (saved) => {
                 if (!saved)
@@ -113,7 +121,28 @@ export class UpdateCoordinator {
                     catch { /* a broken logger must not fail a boot */ }
                     return;
                 }
+                // Any other non-terminal phase was written by a process that no longer exists: the execute()
+                // that owned it died with the previous daemon, so nothing will ever advance it. Adopting it
+                // verbatim makes handle() answer every later command with UPDATE_IN_PROGRESS while the
+                // heartbeat repeats the stale phase to the server forever -- the same permanent wedge the
+                // RESTARTING branch above exists to prevent, reachable by killing the daemon at any earlier
+                // point (a laptop shut mid-download, an operator's restart mid-drain). RESTARTING is the one
+                // deliberate exception in every lifecycle: the successor is *expected* to adopt it and let
+                // management_ready promote it (or the armed watchdog fail it).
+                if (!isTerminalPhase(saved.phase) && saved.phase !== 'RESTARTING') {
+                    this.status = { ...saved, phase: 'FAILED', error: `process restarted during '${saved.phase}'; the update never completed` };
+                    await this.options.state.save(this.status);
+                    // Reported like any other transition, for the same reason the container branch is.
+                    try {
+                        this.options.onPhase?.(this.status);
+                    }
+                    catch { /* a broken logger must not fail a boot */ }
+                    return;
+                }
                 this.status = saved;
+            }).catch((error) => {
+                this.initialized = null;
+                throw error;
             });
         await this.initialized;
     }

package/dist/workstation/update/npmInstaller.js

@@ -1,5 +1,6 @@
 import { spawn as nodeSpawn } from 'node:child_process';
 import { redactPaths, redactSecrets } from './redact.js';
+import { verifyOptionalPty } from './watchdog.js';
 const STDERR_LIMIT = 4096;
 function absolute(value, field) {
     if (!value.startsWith('/') || /[\u0000-\u001f\u007f]/.test(value))
@@ -47,6 +48,7 @@ export class NpmInstaller {
                     reject(new Error(`npm install failed: ${sanitizeNpmError(stderr) || `exit ${code ?? signal ?? 'unknown'}`}`));
             });
         });
+        await verifyOptionalPty(this.options.npmPrefix, this.spawn);
     }
     /** Packs the installed package locally; `--json` gives npm's own name/version validation input. */
     async pack(packageRoot, destination) {

package/dist/workstation/update/ptyPreflight.js

@@ -0,0 +1,24 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+const require = createRequire(import.meta.url);
+/**
+ * Says once, at daemon start, when the installed CLI's optional `node-pty` does not load. There is
+ * no repair to attempt: the pinned node-pty ships prebuilds for every desktop target, so a load
+ * failure means an unsupported platform (musl, an older glibc), not a missing build step.
+ */
+export async function preflightOptionalPty(context, deps = {}) {
+    const installedRoot = path.join(context.npmPrefix, process.platform === 'win32' ? 'node_modules' : 'lib/node_modules', '@platless/axom-cli');
+    // Source checkouts and custom unpacked installations load their own node-pty; nothing to report.
+    if (path.resolve(installedRoot) !== path.resolve(context.packageRoot))
+        return;
+    const addon = path.join(installedRoot, 'node_modules/node-pty');
+    try {
+        (deps.load ?? require)(addon);
+    }
+    catch (error) {
+        // An explicitly omitted optional dependency is not a problem worth a warning.
+        if (error.code === 'MODULE_NOT_FOUND' && String(error.message).includes(addon))
+            return;
+        (deps.warn ?? console.warn)('[daemon] Optional node-pty does not load on this platform; the terminal tool stays unavailable.');
+    }
+}

package/dist/workstation/update/taskRegistry.js

@@ -3,16 +3,39 @@
  * forced update closes it permanently because this daemon is about to be replaced.
  */
 export class TaskRegistry {
-    /** Every running shell's abort handle plus the promise that says its finally cleanup has run. */
+    /** Every running computer task's abort handle plus the promise that says its finally cleanup has run. */
     shellTasks = new Map();
-    agentTasks = new Set();
     agentOpenReservations = new Map();
     agentSessions = new Map();
     idleWaiters = new Set();
     stopping = null;
     accepting = true;
+    /**
+     * 忙碌是**现在采出来的**，不是攒出来的。
+     *
+     * 上一版把每个 `tool_call` / `permission_request` 记进一个 `Set`，指望 `turn_done` 来删。
+     * 任何一条没有配套 `turn_done` 的开始事件都会把那个 ref 永久钉住，`isIdle()` 于是永远假，
+     * 优雅更新白等满 drain 超时——2026-09-21 一次重装就这样卡在 BUSY。集合删掉之后这类缺陷
+     * **按构造**不存在：没有可泄漏的东西，而不是"记得要删"。
+     *
+     * `busy()` 由会话自己提供，两个来源取或（见 agentSessions.ts 的注册点）：本进程发出的
+     * 提示词是否在途，以及 agent 自报的状态。两个都是层级量。
+     */
     snapshot() {
-        const activeAgentRefs = new Set(this.agentTasks);
+        const activeAgentRefs = new Set();
+        for (const [sessionRef, session] of this.agentSessions) {
+            // 一个抛异常的采样器不得让心跳和更新准入一起垮掉；读不出来就当它不主张忙碌，
+            // 与未知 vendor 值的处置同一条推理。
+            let busy = false;
+            try {
+                busy = session.busy();
+            }
+            catch {
+                busy = false;
+            }
+            if (busy)
+                activeAgentRefs.add(sessionRef);
+        }
         for (const sessionRef of this.agentOpenReservations.keys())
             activeAgentRefs.add(sessionRef);
         return { activeShellTasks: this.shellTasks.size, activeAgentTasks: activeAgentRefs.size };
@@ -56,7 +79,7 @@ export class TaskRegistry {
         for (const waiter of [...this.idleWaiters])
             waiter();
     }
-    /** Run one shell task under an abort signal which force-update owns. */
+    /** Run one computer task under an abort signal which force-update owns. The method name preserves old callers. */
     async withShellTask(run) {
         if (!this.accepting)
             throw new Error('Workstation is not accepting new work');
@@ -73,9 +96,16 @@ export class TaskRegistry {
             this.notifyIfIdle();
         }
     }
-    /** Register a live native agent for force-stop; idle sessions deliberately do not count as busy. */
-    registerAgentSession(sessionRef, close) {
-        this.agentSessions.set(sessionRef, close);
+    /** Register a live native agent for force-stop, plus how to ask whether it is busy right now. */
+    registerAgentSession(sessionRef, close, busy) {
+        this.agentSessions.set(sessionRef, { close, busy });
+    }
+    /**
+     * 采样式判据没有"变空闲"这个事件可以挂钩，所以持有者在可能变空闲时喊一声。
+     * 多喊无害（`notifyIfIdle` 自己会再判一次），漏喊的代价只是等到下一次调用或超时。
+     */
+    sessionBusyChanged() {
+        this.notifyIfIdle();
     }
     /** Atomically admits and counts an asynchronous open before any journal or subprocess await. */
     tryReserveAgentOpen(sessionRef) {
@@ -98,19 +128,14 @@ export class TaskRegistry {
     }
     unregisterAgentSession(sessionRef) {
         this.agentSessions.delete(sessionRef);
-        this.agentTasks.delete(sessionRef);
         this.notifyIfIdle();
     }
-    /** Returns false whenever an update has closed the new-turn admission gate. */
-    agentTurnStarted(sessionRef) {
-        if (!this.accepting)
-            return false;
-        this.agentTasks.add(sessionRef);
-        return true;
-    }
-    agentTurnFinished(sessionRef) {
-        this.agentTasks.delete(sessionRef);
-        this.notifyIfIdle();
+    /**
+     * 排干期间拒收新回合。**只管准入**——它不再登记任何东西，忙碌由 [snapshot] 现场采样。
+     * 这两件事以前挤在一个方法里，删计数时极易把准入一起删掉，那会让 drain 期间照收新活。
+     */
+    tryAdmitTurn(_sessionRef) {
+        return this.accepting;
     }
     /**
      * Atomically refuse future work, signal every shell process group through its owning executor,
@@ -126,11 +151,10 @@ export class TaskRegistry {
             const shells = [...this.shellTasks.entries()];
             for (const [task] of shells)
                 task.abort();
-            this.agentTasks.clear();
             this.agentOpenReservations.clear();
             this.notifyIfIdle();
             const [outcomes] = await Promise.all([
-                Promise.allSettled([...this.agentSessions.values()].map(async (close) => close())),
+                Promise.allSettled([...this.agentSessions.values()].map(async (session) => session.close())),
                 Promise.all(shells.map(([, cleanedUp]) => cleanedUp)),
             ]);
             const failures = outcomes.filter((outcome) => outcome.status === 'rejected');

package/dist/workstation/update/watchdog.js

@@ -242,6 +242,72 @@ async function npmInstall(npmPath, npmPrefix, archive) {
         child.once('error', reject);
         child.once('close', (code) => code === 0 ? resolve() : reject(new Error(`npm rollback failed with exit ${code ?? 'unknown'}`)));
     });
+    await verifyOptionalPty(npmPrefix);
+}
+/**
+ * Whether the installed CLI's optional `node-pty` loads in this runtime. Kept in this standalone file
+ * because the rollback watchdog is copied out of the package.
+ *
+ * There is nothing to build: the pinned node-pty ships N-API prebuilds for all six desktop targets
+ * (linux included since 1.2.0-beta; 1.1.0 had none for linux, which is why this used to run
+ * `npm rebuild` and needed Python/make/a C++ compiler on the workstation). The check runs in a
+ * child process so a crashing addon cannot take the installer with it.
+ *
+ * Never fails the install. Terminal support is optional and the daemon already degrades only the
+ * terminal tool when the addon is missing; an update that rolled back over it left the whole
+ * workstation on the old client instead.
+ */
+export async function verifyOptionalPty(npmPrefix, spawn = nodeSpawn, timeoutMs = 60_000, warn = console.warn) {
+    const root = path.join(npmPrefix, process.platform === 'win32' ? 'node_modules' : 'lib/node_modules', PACKAGE_NAME);
+    const addon = path.join(root, 'node_modules/node-pty');
+    try {
+        await fs.access(path.join(addon, 'package.json'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false; // Explicitly omitted optional dependency.
+        throw error;
+    }
+    try {
+        await new Promise((resolve, reject) => {
+            // A detached POSIX group lets a timeout stop the check and anything the addon started.
+            // It must finish well before the previous release's 120-second rollback deadline.
+            const child = spawn(process.execPath, ['-e', 'require(process.argv[1])', addon], { shell: false, stdio: 'ignore', windowsHide: true, detached: process.platform !== 'win32' });
+            let done = false;
+            const finish = (error) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const timer = setTimeout(() => {
+                try {
+                    if (process.platform !== 'win32' && child.pid)
+                        process.kill(-child.pid, 'SIGKILL');
+                    else
+                        child.kill('SIGKILL');
+                }
+                catch {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch { /* Already exited. */ }
+                }
+                finish(new Error('timed out'));
+            }, timeoutMs);
+            child.once('error', () => finish(new Error('could not start the check')));
+            child.once('close', code => finish(code === 0 ? undefined : new Error(`exit ${code ?? 'unknown'}`)));
+        });
+        return true;
+    }
+    catch (error) {
+        warn(`[update] Optional node-pty does not load on this platform (${error.message}); the terminal tool stays unavailable.`);
+        return false;
+    }
 }
 /** How much of the child's own complaint is worth carrying into a 512-character status field. */
 const CAPTURED_STDERR_LIMIT = 300;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platless/axom-cli",
-  "version": "0.1.0",
+  "version": "0.3.13",
   "description": "Axomwork CLI - manage Axomwork structures, records and executions over MCP",
   "type": "module",
   "bin": {
@@ -14,14 +14,19 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc",
+    "build": "rm -rf dist && tsc && node scripts/copy-patches.mjs",
+    "pretest": "npm run build",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepack": "node scripts/copy-patches.mjs --check"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.4.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@napi-rs/keyring": "^1.1.3",
+    "@qoder-ai/qoder-agent-sdk": "1.0.50",
+    "@xterm/addon-serialize": "^0.14.0",
+    "@xterm/headless": "^6.0.0",
     "commander": "^15.0.0",
     "js-yaml": "^4.1.0",
     "semver": "^7.8.5",
@@ -35,5 +40,10 @@
     "@types/ws": "^8.5.13",
     "typescript": "^5.2.2",
     "vitest": "^2.1.9"
-  }
+  },
+  "optionalDependencies": {
+    "node-pty": "1.2.0-beta.15",
+    "playwright-core": "1.63.0"
+  },
+  "axomPatchBundle": true
 }