@addai/node 0.4.0

package/dist/codex-spawn.js

@@ -0,0 +1,320 @@
+"use strict";
+// codex exec --json adapter.
+//
+// Codex's CLI prints a JSONL stream similar in spirit to claude
+// --output-format stream-json, with different shapes. We normalise what
+// we can recognise (thread.started, turn.started/completed/failed,
+// assistant text deltas, errors) and pass everything else through as
+// claude:codex.<type> events.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexEffort = codexEffort;
+exports.spawnCodex = spawnCodex;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const codex_binary_1 = require("./codex-binary");
+const diskguard_1 = require("./diskguard");
+const win_1 = require("./win");
+const events_1 = require("./events");
+/** Quote a string as a TOML basic string (double-quoted, escape backslash + quote). */
+function tomlString(s) {
+    return '"' + String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"';
+}
+/** Build a config.toml that declares only the supplied MCP servers and
+ *  return the directory path to use as CODEX_HOME. Caller is responsible
+ *  for cleanup (we drop it under os.tmpdir() so it gets reaped). */
+function writeCodexHome(servers, workingDirectory) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'entities-codex-'));
+    let toml = '# Generated by ainode — sandboxes codex against host config\n\n';
+    for (const s of servers) {
+        if (!s.slug || !s.command)
+            continue;
+        // On native Windows, registry commands like `npx` are .cmd shims that
+        // codex can't CreateProcess directly — wrap with `cmd /c` (no-op on POSIX).
+        const wrapped = (0, win_1.wrapMcpCommandForPlatform)(s.command, Array.isArray(s.args) ? s.args : []);
+        toml += `[mcp_servers.${tomlString(s.slug).slice(1, -1)}]\n`;
+        toml += `command = ${tomlString(wrapped.command)}\n`;
+        if (wrapped.args.length > 0) {
+            toml += `args = [${wrapped.args.map(tomlString).join(', ')}]\n`;
+        }
+        if (s.env && Object.keys(s.env).length > 0) {
+            toml += `[mcp_servers.${tomlString(s.slug).slice(1, -1)}.env]\n`;
+            for (const [k, v] of Object.entries(s.env)) {
+                toml += `${k} = ${tomlString(String(v))}\n`;
+            }
+        }
+        toml += '\n';
+    }
+    fs.writeFileSync(path.join(dir, 'config.toml'), toml, { mode: 0o600 });
+    // Symlink the host's auth artifacts into the sandbox so codex can find
+    // the user's logged-in credentials. Without this codex sees CODEX_HOME
+    // pointing at an empty dir and 401s against the OpenAI API.
+    const hostHome = path.join(os.homedir(), '.codex');
+    if (fs.existsSync(hostHome)) {
+        for (const file of ['auth.json', 'credentials.json', 'config.json']) {
+            const real = path.join(hostHome, file);
+            if (fs.existsSync(real)) {
+                // symlink where allowed; copy on Windows (file symlinks need
+                // admin/Developer Mode there). A copied auth.json means a token
+                // refreshed mid-run doesn't propagate back to the host — acceptable:
+                // the next run re-copies the current host file.
+                (0, win_1.linkOrCopyFile)(real, path.join(dir, file));
+            }
+        }
+        // Also link the sessions dir so codex can resume across runs.
+        // 'junction' works unprivileged on Windows; ignored on POSIX.
+        const sessionsDir = path.join(hostHome, 'sessions');
+        if (fs.existsSync(sessionsDir)) {
+            (0, win_1.linkDir)(sessionsDir, path.join(dir, 'sessions'));
+        }
+    }
+    // The registry installer writes selected skills to .claude/skills for
+    // Claude. Codex discovers skills from CODEX_HOME/skills, so bridge the
+    // session-local install into the isolated home.
+    const sessionSkillsDir = path.join(workingDirectory, '.claude', 'skills');
+    if (fs.existsSync(sessionSkillsDir)) {
+        (0, win_1.linkDir)(sessionSkillsDir, path.join(dir, 'skills'));
+    }
+    return dir;
+}
+function lineToEvents(line) {
+    const type = typeof line.type === 'string' ? line.type : '';
+    // Errors come as { type: 'error', message: string } — surface them.
+    if (type === 'error') {
+        return [{ type: 'error', code: 'codex_stream_error', message: String(line.message ?? 'unknown') }];
+    }
+    // Failure of the whole turn.
+    if (type === 'turn.failed') {
+        const err = line.error?.message ?? 'turn failed';
+        return [
+            { type: 'error', code: 'codex_turn_failed', message: err },
+            { type: 'turn_complete', stopReason: 'failed' },
+        ];
+    }
+    // Successful completion of a turn.
+    if (type === 'turn.completed') {
+        return [{ type: 'turn_complete', usage: line.usage ?? undefined }];
+    }
+    // Agent text response (codex uses slightly different keys depending
+    // on version — try a few likely shapes).
+    if (type === 'agent_message' || type === 'agent.response.delta' || type === 'message') {
+        const text = (typeof line.text === 'string' && line.text) ||
+            (typeof line.message === 'string' && line.message) ||
+            (line.delta?.text) ||
+            undefined;
+        if (text)
+            return [{ type: 'assistant_text', delta: text }];
+    }
+    // Newer codex versions wrap assistant text in 'item.completed' events
+    // as { item: { type: 'agent_message', text } }. Keep this strict so
+    // command/reasoning/tool items with textual payloads don't become answers.
+    if (type === 'item.completed') {
+        const item = line.item;
+        if (item?.type === 'agent_message' && typeof item.text === 'string' && item.text) {
+            return [{ type: 'assistant_text', delta: item.text }];
+        }
+    }
+    // Anything else: opaque passthrough. Reusing the claude:<type> namespace
+    // is intentional — vault renders it generically; we'd otherwise need a
+    // new "codex:" namespace which adds zero value.
+    return [{ type: `claude:codex.${type || 'unknown'}`, raw: line }];
+}
+/** Clamp our effort ladder to a value codex's CLI accepts. codex only knows
+ *  `minimal|low|medium|high` and FAIL-FASTS (exit 2, dead-letter) on anything
+ *  else — but RuntimeEffortLevel also carries `xhigh`/`max`, and a ladder
+ *  failover (e.g. claude(max) → codex) forwards req.effort across agents
+ *  unchanged. Map the extra-high tiers down to `high`; drop anything
+ *  unrecognised so we emit no `-c reasoning.effort` at all rather than a bad
+ *  one. Mirrors grokEffort() in grok-spawn.ts. */
+function codexEffort(level) {
+    switch (level) {
+        case 'low': return 'low';
+        case 'medium': return 'medium';
+        case 'high':
+        case 'xhigh':
+        case 'max': return 'high';
+        default: return null;
+    }
+}
+function spawnCodex(input) {
+    // codex 0.132's `exec resume` subcommand has a restricted option set —
+    // --cd, --json, --skip-git-repo-check, --model all belong on the BASE
+    // `exec` command, before the `resume` subcommand. Putting them after
+    // resume returns "unexpected argument" and exits 2.
+    const baseFlags = ['--cd', input.workingDirectory, '--json'];
+    if (input.skipGitRepoCheck)
+        baseFlags.push('--skip-git-repo-check');
+    if (input.bypassPermissions)
+        baseFlags.push('--dangerously-bypass-approvals-and-sandbox');
+    else
+        baseFlags.push('--sandbox', input.sandboxMode ?? 'workspace-write');
+    if (input.model)
+        baseFlags.push('--model', input.model);
+    const effort = codexEffort(input.effortLevel);
+    if (effort) {
+        baseFlags.push('-c', `reasoning.effort=${JSON.stringify(effort)}`);
+    }
+    const args = input.resumeThreadId
+        ? ['exec', ...baseFlags, 'resume', input.resumeThreadId, input.prompt]
+        : ['exec', ...baseFlags, input.prompt];
+    // Sandbox codex against an isolated CODEX_HOME so the host's
+    // ~/.codex/config.toml mcp_servers don't leak in. TERM=dumb keeps
+    // codex's TTY heuristics happy (no fancy terminal output).
+    const codexHome = writeCodexHome(input.mcpServers ?? [], input.workingDirectory);
+    // Register the scratch dir with DiskGuard: marks it active (so a
+    // concurrent sweep won't evict a live run) and writes a PID lock so a
+    // different runtime process can tell it's still owned. dispose(true)
+    // removes the dir — this is the fix for the historical leak where every
+    // run's CODEX_HOME (50-350 MB) was abandoned under os.tmpdir() forever.
+    const guardSession = (0, diskguard_1.getDiskGuard)().beginSession(codexHome);
+    const childEnv = {
+        ...process.env,
+        TERM: 'dumb',
+        CODEX_HOME: codexHome,
+    };
+    // Resolve binary path before spawn. Previously called spawn('codex', ...)
+    // bare, which threw ENOENT under launchd / desktop-app PATH inheritance
+    // and rejected `done` before any session_end event fired → request
+    // stuck at 'running' on the DB.
+    const bin = (0, codex_binary_1.findCodexBinary)();
+    const listeners = [];
+    const emit = (e) => { for (const l of listeners)
+        try {
+            l(e);
+        }
+        catch { } };
+    const activityListeners = [];
+    const touchActivity = () => { for (const l of activityListeners)
+        try {
+            l();
+        }
+        catch { } };
+    let threadId = null;
+    let buffer = '';
+    if (!bin) {
+        // Synthesise a synchronous-looking failure: emit error + turn_complete
+        // so the caller's onExit logic gets the same shape as a normal failed
+        // run. bufferedEvents delivers even though the runner attaches its
+        // listener after an await (setImmediate used to fire first → dropped).
+        void guardSession.dispose(true);
+        const events = (0, events_1.bufferedEvents)([
+            { type: 'error', code: 'codex_not_found', message: 'codex binary not on PATH. Install with `npm i -g @openai/codex-cli`.' },
+            { type: 'turn_complete', stopReason: 'failed' },
+        ]);
+        return {
+            pid: undefined,
+            get threadId() { return null; },
+            onEvent: events.onEvent,
+            onActivity: () => { },
+            done: Promise.resolve(-1),
+            kill() { },
+        };
+    }
+    let proc;
+    try {
+        // npm .cmd shim → node script (win32); identity on POSIX. Throws on an
+        // unresolvable shim — caught below alongside spawn's own sync errors.
+        const inv = (0, win_1.resolveCliInvocation)(bin, args);
+        proc = (0, child_process_1.spawn)(inv.file, inv.args, {
+            cwd: input.workingDirectory,
+            env: childEnv,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch (err) {
+        const msg = err.message || String(err);
+        void guardSession.dispose(true);
+        const events = (0, events_1.bufferedEvents)([
+            { type: 'error', code: 'codex_spawn_failed', message: msg },
+            { type: 'turn_complete', stopReason: 'failed' },
+        ]);
+        return {
+            pid: undefined,
+            get threadId() { return null; },
+            onEvent: events.onEvent,
+            onActivity: () => { },
+            done: Promise.resolve(-1),
+            kill() { },
+        };
+    }
+    proc.stdout?.on('data', (chunk) => {
+        touchActivity();
+        buffer += chunk.toString('utf8');
+        let nl;
+        while ((nl = buffer.indexOf('\n')) !== -1) {
+            const raw = buffer.slice(0, nl).trim();
+            buffer = buffer.slice(nl + 1);
+            if (!raw)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.type === 'thread.started' && typeof parsed.thread_id === 'string') {
+                threadId = parsed.thread_id;
+            }
+            for (const ev of lineToEvents(parsed))
+                emit(ev);
+        }
+    });
+    proc.stderr?.on('data', (chunk) => {
+        touchActivity();
+        const txt = chunk.toString('utf8').trim();
+        if (txt === 'Reading additional input from stdin...')
+            return;
+        if (txt)
+            emit({ type: 'error', code: 'codex_stderr', message: txt.slice(0, 4096) });
+    });
+    const done = new Promise((resolve, reject) => {
+        // Remove the scratch CODEX_HOME on any terminal outcome (clean exit,
+        // SIGINT from kill()/timeout, or async spawn error). DiskGuard is the
+        // backstop for the paths this can't cover — SIGKILL and crashes.
+        proc.once('error', (err) => { void guardSession.dispose(true); reject(err); });
+        proc.once('exit', (code) => { void guardSession.dispose(true); resolve(code ?? -1); });
+    });
+    return {
+        pid: proc.pid,
+        get threadId() { return threadId; },
+        kill: () => { (0, win_1.killProcessTree)(proc); },
+        onEvent: (cb) => { listeners.push(cb); },
+        onActivity: (cb) => { activityListeners.push(cb); },
+        done,
+    };
+}

package/dist/command-runner.d.ts

@@ -0,0 +1,9 @@
+export type RestartHook = (opts: {
+    commandId: string;
+    version: string;
+}) => Promise<void>;
+export declare function setRestartHook(fn: RestartHook): void;
+/** Called from index.ts when a heartbeat reports pending_commands > 0.
+ *  Drains the queue serially; re-entrant calls while draining are no-ops
+ *  (the drain loop re-picks until empty). */
+export declare function wake(): void;