@addai/node 0.4.0

package/dist/claude-spawn.js

@@ -0,0 +1,220 @@
+"use strict";
+// Spawn a Claude Code session in a pseudoterminal. The runtime never
+// renders a TUI, so we only need:
+//   - the PTY (node-pty) so Claude thinks it has a terminal
+//   - onData callback so the request runner can observe startup output
+//     and inject Enter to submit the initial prompt
+//   - onExit so sessions clean up
+//   - write() so callers can send prompts
+//   - the JSONL path on disk so the tail can stream clean 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.spawnClaudeForRuntime = spawnClaudeForRuntime;
+const pty = __importStar(require("node-pty"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const claude_binary_1 = require("./claude-binary");
+const win_1 = require("./win");
+const mcp_config_1 = require("./mcp-config");
+const paths_1 = require("./paths");
+function resolveMcpFilter(workingDirectory, enabled) {
+    if (!enabled)
+        return null;
+    const all = (0, mcp_config_1.listMcps)(workingDirectory).map(s => s.name);
+    // If the request lists every installed server, no filter needed.
+    if (enabled.length === all.length && enabled.every(n => all.includes(n)))
+        return null;
+    return enabled;
+}
+function spawnClaudeForRuntime(input) {
+    const ptyId = (0, crypto_1.randomUUID)();
+    const sessionId = (0, crypto_1.randomUUID)();
+    const claudeBin = (0, claude_binary_1.findClaudeBinary)();
+    // No claude on this runtime — fail THIS request cleanly rather than
+    // spawning a bare 'claude' that ENOENTs and crashes the daemon. The
+    // caller (runClaudeTui) wraps this in try/catch → per-request 'spawn_failed'.
+    if (!claudeBin) {
+        throw new Error('claude CLI not found on this runtime — install it from Studio → Runtimes → Harnesses, ' +
+            'or run `npm i -g @anthropic-ai/claude-code`.');
+    }
+    const isWin = process.platform === 'win32';
+    // Build CLI flags.
+    const permissionFlags = [];
+    if (input.permissionMode === 'bypassPermissions') {
+        permissionFlags.push('--dangerously-skip-permissions');
+    }
+    else if (input.permissionMode) {
+        permissionFlags.push('--permission-mode', input.permissionMode);
+    }
+    const effortFlags = input.effortLevel ? ['--effort', input.effortLevel] : [];
+    // Must include 'user' so the pre-written `~/.claude/settings.json` with
+    // `skipDangerousModePermissionPrompt: true` is honored. Without user
+    // scope, Claude re-prompts the "WARNING: Bypass Permissions" dialog on
+    // every spawn → the TUI hangs forever waiting for confirmation → the
+    // daemon sees `ready` then `transcript_slow` 30s later and nothing
+    // else (the smoking-gun pattern we were chasing).
+    //
+    // We exclude 'local' on purpose: ~/.claude/settings.local.json can
+    // declare its own mcpServers that would leak through --strict-mcp-config.
+    // 'user' (settings.json only) is safe — mcpServers in user settings are
+    // still overridden by our --mcp-config + --strict-mcp-config flags.
+    const settingSources = ['--setting-sources', 'user,project'];
+    const mcpFlags = [];
+    let mcpConfigPath = null;
+    if (input.mcpConfigPathOverride) {
+        // install.ts already wrote a complete .mcp.json from the registry;
+        // skip the local-catalog filter entirely.
+        mcpConfigPath = input.mcpConfigPathOverride;
+        mcpFlags.push('--mcp-config', mcpConfigPath, '--strict-mcp-config');
+    }
+    else {
+        const filter = resolveMcpFilter(input.workingDirectory, input.enabledMcps);
+        if (filter !== null) {
+            try {
+                mcpConfigPath = (0, mcp_config_1.writeSessionMcpConfig)(ptyId, input.workingDirectory, filter);
+                if (mcpConfigPath) {
+                    mcpFlags.push('--mcp-config', mcpConfigPath, '--strict-mcp-config');
+                }
+            }
+            catch (err) {
+                console.error('[runtime] failed to write session MCP config', err);
+            }
+        }
+    }
+    // --resume <id> attaches to an existing transcript; otherwise we
+    // mint a fresh session-id so the JSONL path is predictable for tailing.
+    const effectiveSessionId = input.resumeSessionId || sessionId;
+    const entityFlags = [];
+    if (input.appendSystemPrompt && input.appendSystemPrompt.trim().length > 0) {
+        entityFlags.push('--append-system-prompt', input.appendSystemPrompt);
+    }
+    if (Array.isArray(input.allowedTools) && input.allowedTools.length > 0) {
+        // Mirror claude-print: skip the flag entirely for an empty array.
+        // An empty `--allowed-tools ` value would hand claude an EMPTY allowlist
+        // (no tools at all) instead of inheriting its defaults — tool-blocking
+        // the entity. Empty array = "inherit defaults", same as undefined.
+        entityFlags.push('--allowed-tools', input.allowedTools.join(','));
+    }
+    // Model override — without this, claude uses its CLI default regardless
+    // of what the user picked in the composer.
+    const modelFlags = (input.model && input.model.trim())
+        ? ['--model', input.model.trim()]
+        : [];
+    // We never pass the prompt as argv anymore. Claude's TUI behavior with
+    // `--resume <id> <prompt>` was concatenating turn 2's prompt onto the
+    // previous turn instead of submitting it as a fresh user message. The
+    // daemon now types the prompt directly into the PTY after the TUI has
+    // settled — same input path for first-turn and continuation-turn, so
+    // both are reliable.
+    const claudeArgs = input.resumeSessionId
+        ? ['--resume', input.resumeSessionId]
+        : ['--session-id', sessionId];
+    const effectiveArgs = [
+        ...permissionFlags,
+        ...effortFlags,
+        ...modelFlags,
+        ...settingSources,
+        ...mcpFlags,
+        ...entityFlags,
+        ...claudeArgs,
+    ];
+    let shell;
+    let shellArgs;
+    if (isWin) {
+        // NO cmd.exe: node-pty joins argv with CommandLineToArgvW quoting, which
+        // cmd.exe re-parses by its own rules — paths with spaces break, and
+        // --append-system-prompt text (quotes/%/newlines) would be interpreted
+        // as shell syntax. resolveCliInvocation unwraps an npm .cmd shim to its
+        // node script (run via process.execPath) or passes an .exe straight
+        // through; either target parses argv via CommandLineToArgvW, matching
+        // node-pty's quoting. ConPTY handles both fine.
+        const inv = (0, win_1.resolveCliInvocation)(claudeBin, effectiveArgs);
+        shell = inv.file;
+        shellArgs = inv.args;
+    }
+    else {
+        // `exec "$@"` passes positional args straight through without shell escaping.
+        shell = process.env.SHELL || '/bin/bash';
+        shellArgs = ['-l', '-c', 'exec "$@"', '_', claudeBin, ...effectiveArgs];
+    }
+    const proc = pty.spawn(shell, shellArgs, {
+        name: 'xterm-256color',
+        cols: 120,
+        rows: 30,
+        cwd: input.workingDirectory,
+        env: {
+            ...process.env,
+            TERM: 'xterm-256color',
+            COLORTERM: 'truecolor',
+            ...(input.extraEnv ?? {}),
+        },
+    });
+    const dataListeners = [];
+    proc.onData((data) => {
+        for (const l of dataListeners)
+            try {
+                l(data);
+            }
+            catch { }
+    });
+    const exitListeners = [];
+    proc.onExit(({ exitCode }) => {
+        for (const l of exitListeners)
+            try {
+                l(exitCode);
+            }
+            catch { }
+        // best-effort cleanup of any temp MCP config
+        if (mcpConfigPath) {
+            try {
+                require('fs').unlinkSync(mcpConfigPath);
+            }
+            catch { }
+        }
+    });
+    const jsonlPath = path.join(paths_1.CLAUDE_PROJECTS_DIR, (0, claude_binary_1.encodeProjectPath)(input.workingDirectory), `${effectiveSessionId}.jsonl`);
+    return {
+        ptyId,
+        sessionId: effectiveSessionId,
+        jsonlPath,
+        write: (data) => proc.write(data),
+        kill: () => { try {
+            proc.kill();
+        }
+        catch { } },
+        onData: cb => { dataListeners.push(cb); },
+        onExit: cb => { exitListeners.push(cb); },
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+"use strict";
+// ainode CLI — the +Ai Node console.
+//
+//   ainode                run this node: daemon + live dashboard
+//   ainode harnesses      interactive harness manager (install / login)
+//   ainode unpair --yes   disconnect from +Ai, cancel in-flight work
+//   ainode version        print version
+//
+// With no args on a terminal, the daemon starts and the dashboard takes
+// over the screen. Piped or headless (nohup/launchd) it prints plain log
+// lines instead, so the daemon log never fills with escape sequences. If a
+// daemon is already running, this attaches to it read-only rather than
+// refusing to start.
+//
+// Unpair reaches Supabase via the daemon token in ~/.ainode/state.json and
+// does not require the daemon to be running.
+Object.defineProperty(exports, "__esModule", { value: true });
+const lockfile_1 = require("./lockfile");
+const index_1 = require("./index");
+const store_1 = require("./store");
+const supabase_client_1 = require("./supabase-client");
+const harnesses_1 = require("./tui/harnesses");
+const run_1 = require("./tui/run");
+const args = process.argv.slice(2);
+function token() {
+    const p = (0, store_1.readPairing)();
+    if (!p) {
+        console.error('Not paired. Run `ainode` (no args) to start the pairing flow.');
+        process.exit(1);
+    }
+    return p.daemonToken;
+}
+async function cmdUnpair() {
+    if (!(0, store_1.isPaired)()) {
+        console.log('Not paired — nothing to do.');
+        return;
+    }
+    const confirm = args.includes('--yes') || args.includes('-y');
+    if (!confirm) {
+        console.log('This will disconnect the runtime from +Ai and cancel any in-flight requests.');
+        console.log('Re-run with --yes to confirm.');
+        return;
+    }
+    try {
+        const r = await (0, supabase_client_1.rpc)('runtime_self_unpair', { p_token: token() });
+        if (r?.cancelled_requests) {
+            console.log(`Cancelled ${r.cancelled_requests} in-flight request(s).`);
+        }
+    }
+    catch (err) {
+        console.error(`server unpair failed (continuing with local cleanup): ${err.message}`);
+    }
+    (0, store_1.clearPairing)();
+    console.log('Unpaired. Run `ainode` to pair again.');
+}
+async function main() {
+    const cmd = args[0];
+    if (!cmd || cmd === 'run' || cmd === 'start' || cmd === '--run') {
+        const tui = (0, run_1.shouldRenderTui)({
+            isTTY: Boolean(process.stdout.isTTY),
+            stdinTTY: Boolean(process.stdin.isTTY),
+            noTui: process.env.AINODE_NO_TUI === '1',
+        });
+        // A daemon may already own this node. Rather than refusing, attach
+        // read-only so "is it running?" is answerable from any terminal.
+        //
+        // Only when it is genuinely still running, though. A crashed daemon
+        // leaves its lockfile behind, and treating that as an owner sent every
+        // later `ainode` into the viewer and returned before start() — so a node
+        // could never come back from a crash without someone deleting the file
+        // by hand. Same liveness check acquireLockfile() uses.
+        const existing = (0, lockfile_1.readLockfile)();
+        if (existing && (0, lockfile_1.processAlive)(existing.pid) && tui) {
+            await (0, run_1.runDashboard)({
+                viewerMode: true,
+                pid: existing.pid,
+                startedAt: existing.startedAt ?? null,
+                version: index_1.VERSION,
+            });
+            return;
+        }
+        const runtime = await (0, index_1.start)();
+        if (!tui) {
+            console.log(`ainode v${index_1.VERSION} running (pid ${runtime.pid}, port ${runtime.port})`);
+            if (!(0, store_1.isPaired)())
+                console.log('Not paired yet — pairing flow comes online in the next build.');
+            await new Promise(() => { });
+            return;
+        }
+        await (0, run_1.runDashboard)({
+            viewerMode: false,
+            pid: runtime.pid,
+            startedAt: Date.now(),
+            version: index_1.VERSION,
+        });
+        return;
+    }
+    switch (cmd) {
+        case 'harnesses':
+            await (0, harnesses_1.runHarnessesTui)();
+            return;
+        case 'unpair':
+            await cmdUnpair();
+            return;
+        case 'version':
+        case '--version':
+        case '-v':
+            console.log(index_1.VERSION);
+            return;
+        case 'help':
+        case '--help':
+        case '-h':
+            console.log(`ainode v${index_1.VERSION}
+
+usage:
+  ainode                    run this +Ai Node — daemon + live dashboard
+  ainode harnesses          install / log in agent harnesses (interactive)
+  ainode unpair --yes       disconnect from +Ai
+  ainode version            print version
+
+Piped or headless output falls back to plain log lines. Set AINODE_NO_TUI=1
+to force that on a terminal.
+
+Pair the node by running it with no args and following the prompt
+to vault.add.ai/entity/connect/<CODE>.
+`);
+            return;
+    }
+    console.error(`unknown command: ${cmd}`);
+    console.error("try 'ainode help'");
+    process.exit(2);
+}
+main().catch(err => {
+    console.error(err.message || err);
+    process.exit(1);
+});

package/dist/codex-binary.d.ts

@@ -0,0 +1,4 @@
+/** Forget the cached lookup — call after an install so a fresh probe
+ *  can see a binary that was missing at daemon start. */
+export declare function resetCache(): void;
+export declare function findCodexBinary(): string | null;

package/dist/codex-binary.js

@@ -0,0 +1,70 @@
+"use strict";
+// Locate the `codex` binary (OpenAI codex-cli) on the host.
+// `npm install -g @openai/codex-cli` puts it on PATH as `codex`
+// (a .cmd shim under %APPDATA%\npm on Windows).
+//
+// Before this existed, codex-spawn.ts called `spawn('codex', ...)` bare —
+// which fails with ENOENT when the daemon's PATH (especially under
+// launchd / desktop-app spawn) doesn't include npm-global's bin dir.
+// The ENOENT rejected the spawn promise BEFORE session_end could be
+// emitted, leaving the request stuck at 'running' on the DB.
+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.resetCache = resetCache;
+exports.findCodexBinary = findCodexBinary;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const win_1 = require("./win");
+const POSIX_CANDIDATES = [
+    '/usr/local/bin/codex',
+    '/opt/homebrew/bin/codex',
+    path.join(os.homedir(), '.npm-global/bin/codex'),
+];
+const WIN32_CANDIDATES = [
+    path.join(os.homedir(), '.npm-global', 'codex.cmd'),
+];
+/** Forget the cached lookup — call after an install so a fresh probe
+ *  can see a binary that was missing at daemon start. */
+function resetCache() { cached = undefined; }
+let cached;
+function findCodexBinary() {
+    if (cached !== undefined)
+        return cached;
+    cached = (0, win_1.findCliBinary)('codex', {
+        posixCandidates: POSIX_CANDIDATES,
+        win32Candidates: WIN32_CANDIDATES,
+    });
+    return cached;
+}

package/dist/codex-spawn.d.ts

@@ -0,0 +1,47 @@
+import type { RuntimeEvent, RuntimeEffortLevel } from './types';
+/** What we pass into codex for one MCP server. Shape matches the
+ *  install.ts ResolvedMcp env-resolved structure. */
+export interface CodexMcpServer {
+    slug: string;
+    command: string;
+    args?: string[] | null;
+    env?: Record<string, string> | null;
+}
+export interface CodexInput {
+    workingDirectory: string;
+    prompt: string;
+    model?: string;
+    effortLevel?: RuntimeEffortLevel;
+    /** Sandbox for normal non-bypass runs. Defaults to workspace-write. */
+    sandboxMode?: 'read-only' | 'workspace-write' | 'danger-full-access';
+    /** Skip Codex approvals and sandboxing. Codex's "yolo" equivalent. */
+    bypassPermissions?: boolean;
+    /** If false, codex requires the workingDirectory to be a git repo. */
+    skipGitRepoCheck?: boolean;
+    /** Existing codex thread id to resume via `codex exec resume <id>`. */
+    resumeThreadId?: string;
+    /** When set, codex runs against a sandboxed CODEX_HOME that contains
+     *  ONLY these MCP servers (host's ~/.codex/config.toml is ignored).
+     *  Mirrors the claude --strict-mcp-config behavior. */
+    mcpServers?: CodexMcpServer[];
+}
+export interface CodexHandle {
+    pid: number | undefined;
+    threadId: string | null;
+    kill(): void;
+    onEvent(cb: (e: RuntimeEvent) => void): void;
+    /** Fires on every raw stdout/stderr chunk. codex emits no per-tool progress
+     *  events during a long `command_execution`, so raw bytes are the liveness
+     *  signal the hang-watchdog uses to avoid killing a busy agent. */
+    onActivity(cb: () => void): void;
+    done: Promise<number>;
+}
+/** 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. */
+export declare function codexEffort(level?: RuntimeEffortLevel): string | null;
+export declare function spawnCodex(input: CodexInput): CodexHandle;