@addai/node 0.4.0

package/dist/claude-config.js

@@ -0,0 +1,144 @@
+"use strict";
+// Pre-seeds claude's own config so the TUI doesn't block on
+// interactive dialogs the daemon can't answer.
+//
+// Two dialogs to clear:
+//
+// 1. "WARNING: Claude Code running in Bypass Permissions mode" — fires
+//    when --dangerously-skip-permissions (or any bypass-mode flag) is
+//    passed. Claude persists user acceptance in
+//      ~/.claude/settings.json   →  "skipDangerousModePermissionPrompt": true
+//    Daemon writes this once on boot so the dialog never appears for
+//    daemon-spawned claudes.
+//
+// 2. "Are you sure you want to trust this directory?" — per-cwd dialog
+//    that fires the first time claude opens a project directory.
+//    Acceptance is keyed by absolute path under ~/.claude.json:
+//      .projects["<abs-cwd>"].hasTrustDialogAccepted = true
+//    Daemon creates a fresh ephemeral cwd per request, so we write that
+//    entry just before spawning claude.
+//
+// Both writes are best-effort and idempotent. A read/parse failure
+// causes a silent skip — claude will fall back to the dialog (the
+// existing failure mode), but the daemon won't crash.
+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.ensureBypassPermissionsAccepted = ensureBypassPermissionsAccepted;
+exports.preTrustProject = preTrustProject;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const win_1 = require("./win");
+const CLAUDE_CONFIG = path.join(os.homedir(), '.claude.json');
+const CLAUDE_SETTINGS = path.join(os.homedir(), '.claude', 'settings.json');
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+function atomicWrite(target, body) {
+    const tmp = `${target}.tmp.${process.pid}.${Date.now()}`;
+    fs.writeFileSync(tmp, body, { mode: 0o600 });
+    // ~/.claude.json is often held open by a running claude session — on
+    // Windows a rename over an open file fails EPERM/EBUSY; retried there.
+    (0, win_1.safeRenameSync)(tmp, target);
+}
+function readJson(target) {
+    try {
+        const raw = fs.readFileSync(target, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Make sure ~/.claude/settings.json has skipDangerousModePermissionPrompt: true.
+ * Idempotent: if the key is already true, no write.
+ */
+function ensureBypassPermissionsAccepted() {
+    try {
+        if (!fs.existsSync(CLAUDE_DIR))
+            fs.mkdirSync(CLAUDE_DIR, { recursive: true, mode: 0o700 });
+        const current = readJson(CLAUDE_SETTINGS) ?? {};
+        if (current.skipDangerousModePermissionPrompt === true)
+            return;
+        const next = { ...current, skipDangerousModePermissionPrompt: true };
+        atomicWrite(CLAUDE_SETTINGS, JSON.stringify(next, null, 2));
+    }
+    catch (err) {
+        console.error(`[claude-config] failed to pre-accept bypass dialog: ${err.message}`);
+    }
+}
+/**
+ * Add an entry to ~/.claude.json `.projects[cwd]` marking the cwd as
+ * trusted and onboarding-seen, so claude TUI doesn't block on either
+ * dialog when launched in this directory. Existing fields are preserved.
+ */
+function preTrustProject(cwd) {
+    try {
+        const config = readJson(CLAUDE_CONFIG);
+        if (!config) {
+            // ~/.claude.json is missing or unparseable. We can't pre-trust
+            // without it, but creating one from scratch would clobber state
+            // claude expects to manage itself. Log so an unexpected trust
+            // dialog isn't a silent mystery.
+            if (fs.existsSync(CLAUDE_CONFIG)) {
+                console.error(`[claude-config] ~/.claude.json exists but is unparseable; trust dialog will fire for ${cwd}`);
+            }
+            return;
+        }
+        const projects = (config.projects && typeof config.projects === 'object'
+            ? config.projects
+            : {});
+        const existing = projects[cwd] || {};
+        if (existing.hasTrustDialogAccepted === true && existing.projectOnboardingSeenCount > 0) {
+            return; // already pre-trusted
+        }
+        projects[cwd] = {
+            allowedTools: [],
+            mcpContextUris: [],
+            mcpServers: {},
+            enabledMcpjsonServers: [],
+            disabledMcpjsonServers: [],
+            hasClaudeMdExternalIncludesApproved: false,
+            hasClaudeMdExternalIncludesWarningShown: true,
+            ...existing,
+            hasTrustDialogAccepted: true,
+            projectOnboardingSeenCount: Math.max(existing.projectOnboardingSeenCount ?? 0, 1),
+        };
+        const next = { ...config, projects };
+        atomicWrite(CLAUDE_CONFIG, JSON.stringify(next, null, 2));
+    }
+    catch (err) {
+        console.error(`[claude-config] failed to pre-trust ${cwd}: ${err.message}`);
+    }
+}

package/dist/claude-print.d.ts

@@ -0,0 +1,35 @@
+import type { RuntimeEvent, RuntimePermissionMode, RuntimeEffortLevel } from './types';
+export interface ClaudePrintInput {
+    workingDirectory: string;
+    prompt: string;
+    permissionMode?: RuntimePermissionMode;
+    effortLevel?: RuntimeEffortLevel;
+    model?: string;
+    mcpConfigPath?: string;
+    /** Continue an existing session via --resume <id>. */
+    resumeSessionId?: string;
+    /** Studio-entity system prompt appended onto Claude's defaults. */
+    appendSystemPrompt?: string;
+    /** Restrict to a specific set of tools (claude only). null/undefined = inherit. */
+    allowedTools?: string[];
+}
+export interface ClaudePrintHandle {
+    pid: number | undefined;
+    sessionId: string | null;
+    kill(): void;
+    onEvent(cb: (e: RuntimeEvent) => void): void;
+    /** Resolves with exit code; rejects on spawn error. */
+    done: Promise<number>;
+}
+/**
+ * Parse one stream-json line into 0+ RuntimeEvents.
+ *
+ * `suppressText`: when partial-message streaming is on, the incremental
+ * text_delta stream_events already carry the full text of each turn. Claude
+ * ALSO emits the aggregated `assistant` message line at turn end — its text
+ * blocks would double the reply (the server appends every assistant_text event
+ * to the message content). So we skip the final text blocks and keep only
+ * tool_use. Text is delivered purely as deltas.
+ */
+export declare function lineToEvents(line: Record<string, unknown>, suppressText?: boolean): RuntimeEvent[];
+export declare function spawnClaudePrint(input: ClaudePrintInput): ClaudePrintHandle;

package/dist/claude-print.js

@@ -0,0 +1,312 @@
+"use strict";
+// claude --print --output-format stream-json adapter.
+//
+// Spawns Claude non-interactively, parses each JSONL line on stdout into
+// our normalised RuntimeEvent shape, and resolves when the process exits.
+// No PTY needed — Claude detects non-TTY and runs headless.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineToEvents = lineToEvents;
+exports.spawnClaudePrint = spawnClaudePrint;
+const child_process_1 = require("child_process");
+const claude_binary_1 = require("./claude-binary");
+const win_1 = require("./win");
+/**
+ * Parse one stream-json line into 0+ RuntimeEvents.
+ *
+ * `suppressText`: when partial-message streaming is on, the incremental
+ * text_delta stream_events already carry the full text of each turn. Claude
+ * ALSO emits the aggregated `assistant` message line at turn end — its text
+ * blocks would double the reply (the server appends every assistant_text event
+ * to the message content). So we skip the final text blocks and keep only
+ * tool_use. Text is delivered purely as deltas.
+ */
+function lineToEvents(line, suppressText = false) {
+    const type = typeof line.type === 'string' ? line.type : '';
+    if (type === 'assistant') {
+        const msg = line.message;
+        const content = msg?.content;
+        const out = [];
+        if (Array.isArray(content)) {
+            for (const b of content) {
+                if (b.type === 'text' && typeof b.text === 'string') {
+                    if (!suppressText)
+                        out.push({ type: 'assistant_text', delta: b.text });
+                }
+                else if (b.type === 'tool_use') {
+                    out.push({
+                        type: 'tool_use',
+                        id: String(b.id ?? ''),
+                        name: String(b.name ?? ''),
+                        input: b.input,
+                    });
+                }
+            }
+        }
+        return out;
+    }
+    if (type === 'user') {
+        const msg = line.message;
+        const content = msg?.content;
+        if (!Array.isArray(content))
+            return [];
+        const out = [];
+        for (const b of content) {
+            if (b.type === 'tool_result') {
+                out.push({
+                    type: 'tool_result',
+                    id: String(b.tool_use_id ?? ''),
+                    content: b.content,
+                    isError: b.is_error === true,
+                });
+            }
+        }
+        return out;
+    }
+    if (type === 'result') {
+        // claude can exit 0 while reporting a failed result: is_error:true (e.g.
+        // a usage-limit banner delivered as the "reply") or an error subtype
+        // (error_max_turns / error_during_execution). Mapping every result to a
+        // clean turn_complete would finalize that banner as the answer. Surface
+        // an error event (→ lastError → non-clean finalize) BEFORE turn_complete
+        // so the run is flagged instead of silently completing.
+        const subtype = typeof line.subtype === 'string' ? line.subtype : undefined;
+        const isErrResult = line.is_error === true ||
+            (subtype != null && subtype !== 'success' && subtype.startsWith('error'));
+        const events = [];
+        if (isErrResult) {
+            const text = typeof line.result === 'string' ? line.result.trim() : '';
+            events.push({
+                type: 'error',
+                // `claude_result_*` prefix is how runClaudePrint distinguishes a
+                // terminal result-error from transient mid-stream error lines.
+                code: subtype ? `claude_result_${subtype}` : 'claude_result_error',
+                message: (text || `claude finished with an error result${subtype ? ` (${subtype})` : ''}`).slice(0, 4096),
+            });
+        }
+        events.push({
+            type: 'turn_complete',
+            usage: line.usage ?? undefined,
+            stopReason: subtype ?? (typeof line.stop_reason === 'string' ? line.stop_reason : undefined),
+        });
+        return events;
+    }
+    return [{ type: `claude:${type || 'unknown'}`, raw: line }];
+}
+function spawnClaudePrint(input) {
+    const bin = (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. Both
+    // callers (runClaudePrint, runGuardrailRetryTurn) wrap this in try/catch
+    // and turn the throw into a per-request 'spawn_failed'.
+    if (!bin) {
+        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`.');
+    }
+    // Token-level streaming. When on, Claude emits incremental content_block_delta
+    // stream_events as it generates, so the chat draft grows in real time instead
+    // of jumping in whole-turn lumps. Kill switch: set ADDAI_STREAM_PARTIAL=0 and
+    // restart the daemon to fall straight back to whole-turn behaviour — no code
+    // change or redeploy needed. Default on.
+    const partialStream = process.env.ADDAI_STREAM_PARTIAL !== '0';
+    const args = [
+        '--print',
+        '--output-format', 'stream-json',
+        '--verbose',
+        // 'user'/'local' leak the host's ~/.claude/settings.local.json mcpServers
+        // through --strict-mcp-config. Restrict to 'project'.
+        '--setting-sources', 'project',
+    ];
+    if (partialStream)
+        args.push('--include-partial-messages');
+    if (input.permissionMode === 'bypassPermissions') {
+        args.push('--dangerously-skip-permissions');
+    }
+    else if (input.permissionMode) {
+        args.push('--permission-mode', input.permissionMode);
+    }
+    if (input.effortLevel)
+        args.push('--effort', input.effortLevel);
+    if (input.model)
+        args.push('--model', input.model);
+    if (input.mcpConfigPath) {
+        args.push('--mcp-config', input.mcpConfigPath, '--strict-mcp-config');
+    }
+    if (input.resumeSessionId) {
+        args.push('--resume', input.resumeSessionId);
+    }
+    if (input.appendSystemPrompt && input.appendSystemPrompt.trim().length > 0) {
+        args.push('--append-system-prompt', input.appendSystemPrompt);
+    }
+    if (Array.isArray(input.allowedTools) && input.allowedTools.length > 0) {
+        // Claude expects a comma-separated list. We skip the flag entirely
+        // for an empty array — otherwise `--allowed-tools ` (empty value)
+        // would consume the NEXT argv (the prompt) as its value, leaving
+        // claude with no prompt and an unparseable tool list. Empty array =
+        // "inherit defaults", same as undefined.
+        args.push('--allowed-tools', input.allowedTools.join(','));
+    }
+    // NOTE: no --image flag here — the claude CLI has never supported one
+    // (0.2.36 shipped it and every image message died with exit 1). Vision
+    // input is handled upstream: session-runner downloads attachment URLs
+    // into the cwd (see attachments.ts) and the agent Reads them.
+    args.push(input.prompt);
+    // On Windows the discovered binary can be an npm .cmd shim, which Node
+    // refuses to spawn without a shell (EINVAL) — and a shell would route the
+    // prompt text through cmd.exe. resolveCliInvocation unwraps the shim to
+    // its node script instead (identity on POSIX). It can throw; so can
+    // spawn() itself (synchronously, on win32). Surface either as a normal
+    // rejected `done` so callers keep their single error path.
+    let proc;
+    try {
+        const inv = (0, win_1.resolveCliInvocation)(bin, args);
+        proc = (0, child_process_1.spawn)(inv.file, inv.args, {
+            cwd: input.workingDirectory,
+            env: { ...process.env, TERM: 'dumb' },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch (err) {
+        const done = Promise.reject(err instanceof Error ? err : new Error(String(err)));
+        // Mark handled now — the caller awaits `done` a few ticks later, and an
+        // already-rejected promise with no handler would fire unhandledRejection.
+        done.catch(() => { });
+        return { pid: undefined, sessionId: null, kill: () => { }, onEvent: () => { }, done };
+    }
+    const listeners = [];
+    const emit = (e) => { for (const l of listeners)
+        try {
+            l(e);
+        }
+        catch { } };
+    let sessionId = null;
+    let buffer = '';
+    // Text-delta coalescer (partial-stream mode). Token deltas arrive many times
+    // per second; emitting one DB event each would flood runtime_event_emit — the
+    // same write path that has wedged the daemon under load. Instead we accumulate
+    // deltas and flush at most every FLUSH_MS into a single assistant_text event:
+    // smooth to watch, ~1-2 orders of magnitude fewer writes. Boundaries (block /
+    // message end, turn result, process exit) force a flush so no text is stranded.
+    const FLUSH_MS = 300;
+    let textBuf = '';
+    let flushTimer = null;
+    let sawDeltaThisMsg = false;
+    // Thinking deltas (extended thinking) — coalesced lazily into 'thinking'
+    // events; the chat relay renders them as a collapsed section.
+    const THINK_FLUSH_MS = 700;
+    let thinkBuf = '';
+    let thinkTimer = null;
+    const flushThinking = () => {
+        if (thinkTimer) {
+            clearTimeout(thinkTimer);
+            thinkTimer = null;
+        }
+        if (thinkBuf) {
+            const t = thinkBuf;
+            thinkBuf = '';
+            emit({ type: 'thinking', delta: t });
+        }
+    };
+    const flushText = () => {
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+        }
+        if (textBuf) {
+            const t = textBuf;
+            textBuf = '';
+            emit({ type: 'assistant_text', delta: t });
+        }
+    };
+    const scheduleFlush = () => { if (!flushTimer)
+        flushTimer = setTimeout(flushText, FLUSH_MS); };
+    const handleLine = (parsed) => {
+        const type = typeof parsed.type === 'string' ? parsed.type : '';
+        if (partialStream && type === 'stream_event') {
+            const sev = parsed.event;
+            const st = sev?.type;
+            if (st === 'message_start') {
+                sawDeltaThisMsg = false;
+                return;
+            }
+            if (st === 'content_block_delta') {
+                const d = sev?.delta;
+                if (d?.type === 'text_delta' && typeof d.text === 'string' && d.text.length > 0) {
+                    flushThinking(); // thoughts precede the text they produced
+                    textBuf += d.text;
+                    sawDeltaThisMsg = true;
+                    scheduleFlush();
+                }
+                else if (d?.type === 'thinking_delta' && typeof d.thinking === 'string' && d.thinking.length > 0) {
+                    thinkBuf += d.thinking;
+                    if (thinkBuf.length >= 1500)
+                        flushThinking();
+                    else if (!thinkTimer)
+                        thinkTimer = setTimeout(flushThinking, THINK_FLUSH_MS);
+                }
+                return; // input_json_delta (tool args) etc. — ignored; tools come from the complete line
+            }
+            if (st === 'content_block_stop' || st === 'message_stop' || st === 'message_delta') {
+                flushThinking();
+                flushText();
+                return;
+            }
+            return; // ping and other bookkeeping stream_events
+        }
+        // Complete message lines. In partial mode, flush buffered deltas first so
+        // event order (text → tool_use) is preserved, then suppress the aggregated
+        // text blocks the deltas already delivered — unless, defensively, no delta
+        // was seen for this message, in which case we keep the block (never lose text).
+        if (partialStream && (type === 'assistant' || type === 'user' || type === 'result'))
+            flushText();
+        const suppressText = partialStream && sawDeltaThisMsg && type === 'assistant';
+        for (const ev of lineToEvents(parsed, suppressText))
+            emit(ev);
+    };
+    proc.stdout?.on('data', (chunk) => {
+        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 (typeof parsed.session_id === 'string' && !sessionId)
+                sessionId = parsed.session_id;
+            handleLine(parsed);
+        }
+    });
+    // Buffer stderr rather than emitting an `error` event per line: claude
+    // writes benign warnings (deprecation notices, MCP startup chatter) to
+    // stderr on perfectly successful runs, and each one used to render as an
+    // error bubble in chat. Surface it only if the run actually fails.
+    let stderrBuf = '';
+    proc.stderr?.on('data', (chunk) => {
+        stderrBuf += chunk.toString('utf8');
+    });
+    const done = new Promise((resolve, reject) => {
+        proc.once('error', reject);
+        proc.once('exit', (code) => {
+            flushThinking();
+            flushText();
+            const trimmed = stderrBuf.trim();
+            if ((code ?? -1) !== 0 && trimmed) {
+                emit({ type: 'error', code: 'claude_stderr', message: trimmed.slice(0, 4096) });
+            }
+            resolve(code ?? -1);
+        });
+    });
+    return {
+        pid: proc.pid,
+        get sessionId() { return sessionId; },
+        kill: () => { (0, win_1.killProcessTree)(proc); },
+        onEvent: (cb) => { listeners.push(cb); },
+        done,
+    };
+}

package/dist/claude-spawn.d.ts

@@ -0,0 +1,40 @@
+import type { RuntimePermissionMode, RuntimeEffortLevel } from './types';
+export interface SpawnedClaude {
+    ptyId: string;
+    sessionId: string;
+    jsonlPath: string;
+    write: (data: string) => void;
+    kill: () => void;
+    onData: (cb: (chunk: string) => void) => void;
+    onExit: (cb: (code: number) => void) => void;
+}
+export interface SpawnInput {
+    workingDirectory: string;
+    enabledMcps?: string[];
+    permissionMode?: RuntimePermissionMode;
+    effortLevel?: RuntimeEffortLevel;
+    initialPrompt?: string;
+    /** Pre-built .mcp.json path from install.ts. Bypasses the local-catalog
+     *  resolution so registry-resolved MCPs work without prior install. */
+    mcpConfigPathOverride?: string;
+    /** When set, attach this session to an existing Claude session id
+     *  via --resume <id> instead of starting a fresh one. */
+    resumeSessionId?: string;
+    /** Studio-entity system prompt appended onto Claude's defaults. */
+    appendSystemPrompt?: string;
+    /** Restrict to a specific set of tools. null/undefined = inherit. */
+    allowedTools?: string[];
+    /** Override claude's default model. Maps to --model <id>. */
+    model?: string | null;
+    /**
+     * Phase 4 T7: extra env vars layered on top of the daemon's own
+     * process.env for THIS spawn only (never mutates process.env itself).
+     * Currently used to thread ENTITY_STUDIO_ENTITY_ID / RUNTIME_REQUEST_ID
+     * through to the PreCompact hook script (scripts/precompact-capture.js),
+     * which runs as a grandchild of this spawn and has no other way to learn
+     * which request/entity it's running for. Undefined/omitted for every
+     * caller that doesn't pass it — byte-identical spawn env otherwise.
+     */
+    extraEnv?: Record<string, string>;
+}
+export declare function spawnClaudeForRuntime(input: SpawnInput): SpawnedClaude;