discoclaw 0.1.0

package/dist/runtime/long-running-process.js

@@ -0,0 +1,415 @@
+import { execa } from 'execa';
+import { MAX_IMAGES_PER_INVOCATION } from './types.js';
+import { tryParseJsonLine, cliExecaEnv } from './cli-shared.js';
+import { extractTextFromUnknownEvent, extractResultText, extractImageFromUnknownEvent, extractResultContentBlocks, imageDedupeKey, stripToolUseBlocks, } from './cli-output-parsers.js';
+/**
+ * Manages a single long-running Claude Code subprocess using `--input-format stream-json`.
+ * Prompts are sent via stdin as NDJSON; responses stream back on stdout.
+ */
+export class LongRunningProcess {
+    subprocess = null;
+    _state = 'starting';
+    opts;
+    hangTimer = null;
+    idleTimer = null;
+    killAfterTimer = null;
+    cleanupCalled = false;
+    turnActive = false;
+    turnEnded = false;
+    stdoutOnData = null;
+    // For active turn: the queue + notify mechanism (same pattern as one-shot).
+    turnQueue = [];
+    turnNotify = null;
+    stdoutBuffer = '';
+    // Track accumulated text for the current turn.
+    turnMerged = '';
+    turnResultText = '';
+    turnInToolUse = false;
+    turnSeenImages = new Set();
+    turnImageCount = 0;
+    /** Called when this process is added to / removed from an external tracking set. */
+    onCleanup;
+    constructor(opts) {
+        this.opts = {
+            hangTimeoutMs: 60_000,
+            idleTimeoutMs: 300_000,
+            ...opts,
+        };
+    }
+    get state() {
+        return this._state;
+    }
+    get isAlive() {
+        return this._state === 'idle' || this._state === 'busy';
+    }
+    /**
+     * Spawn the Claude Code subprocess. Must be called once after construction.
+     * Returns false if spawn fails.
+     */
+    spawn() {
+        const args = [
+            '-p',
+            '--input-format', 'stream-json',
+            '--output-format', 'stream-json',
+            '--include-partial-messages',
+            '--model', this.opts.model,
+        ];
+        if (this.opts.dangerouslySkipPermissions) {
+            args.push('--dangerously-skip-permissions');
+        }
+        if (this.opts.strictMcpConfig) {
+            args.push('--strict-mcp-config');
+        }
+        if (this.opts.fallbackModel) {
+            args.push('--fallback-model', this.opts.fallbackModel);
+        }
+        if (this.opts.maxBudgetUsd != null) {
+            args.push('--max-budget-usd', String(this.opts.maxBudgetUsd));
+        }
+        if (this.opts.appendSystemPrompt) {
+            args.push('--append-system-prompt', this.opts.appendSystemPrompt);
+        }
+        if (this.opts.verbose) {
+            args.push('--verbose');
+        }
+        if (this.opts.tools) {
+            if (this.opts.tools.length > 0) {
+                args.push('--tools', this.opts.tools.join(','));
+            }
+            else {
+                args.push('--tools=');
+            }
+        }
+        if (this.opts.addDirs) {
+            for (const dir of this.opts.addDirs) {
+                args.push('--add-dir', dir);
+            }
+        }
+        this.opts.log?.debug({ args }, 'long-running: spawning');
+        try {
+            this.subprocess = execa(this.opts.claudeBin, args, {
+                cwd: this.opts.cwd,
+                reject: false,
+                stdin: 'pipe',
+                stdout: 'pipe',
+                stderr: 'pipe',
+                env: cliExecaEnv(),
+            });
+        }
+        catch (err) {
+            this.opts.log?.info({ err }, 'long-running: spawn failed');
+            this._state = 'dead';
+            return false;
+        }
+        // Handle process exit.
+        this.subprocess.then(() => {
+            this.handleExit();
+        }).catch(() => {
+            this.handleExit();
+        });
+        this._state = 'idle';
+        this.startIdleTimer();
+        return true;
+    }
+    /**
+     * Send a user turn to the long-running process and yield EngineEvents.
+     * Caller must ensure state is `idle` before calling.
+     */
+    async *sendTurn(prompt, images) {
+        if (this._state !== 'idle') {
+            yield { type: 'error', message: `long-running: cannot send turn in state ${this._state}` };
+            yield { type: 'done' };
+            return;
+        }
+        this._state = 'busy';
+        this.clearIdleTimer();
+        this.turnActive = true;
+        this.turnEnded = false;
+        // Reset per-turn state.
+        this.turnQueue = [];
+        this.turnNotify = null;
+        this.turnMerged = '';
+        this.turnResultText = '';
+        this.turnInToolUse = false;
+        this.turnSeenImages = new Set();
+        this.turnImageCount = 0;
+        this.stdoutBuffer = '';
+        // Wire up stdout parsing for this turn.
+        const onData = (chunk) => {
+            this.resetHangTimer();
+            this.parseStdoutChunk(String(chunk));
+        };
+        this.stdoutOnData = onData;
+        this.subprocess.stdout.on('data', onData);
+        // Start hang detection.
+        this.startHangTimer();
+        // Write the user message to stdin (Claude CLI stream-json expects API-shaped messages).
+        // When images are present, build a content-block array; otherwise plain string.
+        const content = images && images.length > 0
+            ? [
+                { type: 'text', text: prompt },
+                ...images.map((img) => ({
+                    type: 'image',
+                    source: { type: 'base64', media_type: img.mediaType, data: img.base64 },
+                })),
+            ]
+            : prompt;
+        const msg = JSON.stringify({ type: 'user', message: { role: 'user', content } }) + '\n';
+        try {
+            this.subprocess.stdin.write(msg);
+        }
+        catch (err) {
+            // Treat as a fatal termination for this turn: unblock the consumer.
+            this.terminate({
+                reason: 'stdin_write_failed',
+                signal: 'SIGKILL',
+                emitTurnError: true,
+                errorMessage: `long-running: stdin write failed: ${err}`,
+            });
+            // Drain the events we just enqueued.
+            while (this.turnQueue.length > 0) {
+                yield this.turnQueue.shift();
+            }
+            return;
+        }
+        // Yield events as they arrive.
+        try {
+            let done = false;
+            while (!done) {
+                if (this.turnQueue.length === 0) {
+                    await new Promise((resolve) => {
+                        this.turnNotify = resolve;
+                    });
+                }
+                while (this.turnQueue.length > 0) {
+                    const evt = this.turnQueue.shift();
+                    yield evt;
+                    if (evt.type === 'done') {
+                        done = true;
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            if (this.stdoutOnData) {
+                this.subprocess?.stdout?.off('data', this.stdoutOnData);
+                this.stdoutOnData = null;
+            }
+            this.clearHangTimer();
+            this.turnActive = false;
+            if (this._state === 'busy') {
+                this._state = 'idle';
+                this.startIdleTimer();
+            }
+        }
+    }
+    /** Gracefully kill the subprocess. */
+    kill() {
+        this.terminate({
+            reason: 'kill',
+            signal: 'SIGTERM',
+            forceKillAfterMs: 5000,
+            emitTurnError: true,
+            // Avoid triggering one-shot fallback heuristics ("long-running:" / "hang detected").
+            errorMessage: 'multi-turn: terminated',
+        });
+    }
+    /** Force-kill the subprocess. */
+    forceKill() {
+        this.terminate({
+            reason: 'force_kill',
+            signal: 'SIGKILL',
+            emitTurnError: true,
+            // Avoid triggering one-shot fallback heuristics ("long-running:" / "hang detected").
+            errorMessage: 'multi-turn: terminated',
+        });
+    }
+    /** Get the underlying subprocess for external tracking (e.g. activeSubprocesses set). */
+    getSubprocess() {
+        return this.subprocess;
+    }
+    // --- Internal ---
+    pushEvent(evt) {
+        this.turnQueue.push(evt);
+        if (this.turnNotify) {
+            const n = this.turnNotify;
+            this.turnNotify = null;
+            n();
+        }
+    }
+    parseStdoutChunk(s) {
+        this.stdoutBuffer += s;
+        const lines = this.stdoutBuffer.split(/\r?\n/);
+        this.stdoutBuffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const evt = tryParseJsonLine(trimmed);
+            if (!evt)
+                continue;
+            const anyEvt = evt;
+            // Detect end-of-turn: a `result` event signals Claude finished this turn.
+            if (anyEvt.type === 'result') {
+                const rt = extractResultText(evt);
+                if (rt)
+                    this.turnResultText = rt;
+                // Extract images from result content block arrays.
+                const blocks = extractResultContentBlocks(evt);
+                if (blocks) {
+                    if (blocks.text)
+                        this.turnResultText = blocks.text;
+                    for (const img of blocks.images) {
+                        this.pushImageIfNew(img);
+                    }
+                }
+                this.finalizeTurn();
+                return;
+            }
+            // Extract streaming text.
+            const text = extractTextFromUnknownEvent(evt);
+            if (text) {
+                this.turnMerged += text;
+                const hasToolOpen = text.includes('<tool_use>') || text.includes('<tool_calls>') || text.includes('<tool_call>') || text.includes('<tool_results>') || text.includes('<tool_result>');
+                const hasToolClose = text.includes('</tool_use>') || text.includes('</tool_calls>') || text.includes('</tool_call>') || text.includes('</tool_results>') || text.includes('</tool_result>');
+                if (hasToolOpen)
+                    this.turnInToolUse = true;
+                if (!this.turnInToolUse)
+                    this.pushEvent({ type: 'text_delta', text });
+                if (hasToolClose)
+                    this.turnInToolUse = false;
+            }
+            else {
+                // Try extracting a single image from streaming content blocks.
+                const img = extractImageFromUnknownEvent(evt);
+                if (img)
+                    this.pushImageIfNew(img);
+            }
+        }
+    }
+    finalizeTurn() {
+        const raw = this.turnResultText.trim() || (this.turnMerged.trim() ? this.turnMerged.trimEnd() : '');
+        const final = stripToolUseBlocks(raw);
+        if (final)
+            this.pushEvent({ type: 'text_final', text: final });
+        this.pushDoneOnce();
+    }
+    handleExit() {
+        const hadActiveTurn = this.turnActive && !this.turnEnded;
+        this._state = 'dead';
+        this.clearHangTimer();
+        this.clearIdleTimer();
+        this.clearKillAfterTimer();
+        if (hadActiveTurn) {
+            this.pushEvent({ type: 'error', message: 'long-running: process exited unexpectedly' });
+            this.pushDoneOnce();
+        }
+        this.cleanupOnce();
+    }
+    startHangTimer() {
+        this.clearHangTimer();
+        this.hangTimer = setTimeout(() => {
+            this.opts.log?.info('long-running: hang detected, killing process');
+            this.terminate({
+                reason: 'hang',
+                signal: 'SIGKILL',
+                emitTurnError: true,
+                errorMessage: 'multi-turn: hang detected',
+            });
+        }, this.opts.hangTimeoutMs);
+    }
+    resetHangTimer() {
+        if (this._state !== 'busy')
+            return;
+        this.startHangTimer();
+    }
+    clearHangTimer() {
+        if (this.hangTimer) {
+            clearTimeout(this.hangTimer);
+            this.hangTimer = null;
+        }
+    }
+    startIdleTimer() {
+        this.clearIdleTimer();
+        this.idleTimer = setTimeout(() => {
+            this.opts.log?.info('long-running: idle timeout, killing process');
+            // Idle kill is not a "turn failure" and should not affect consumers.
+            this.terminate({
+                reason: 'idle_timeout',
+                signal: 'SIGTERM',
+                forceKillAfterMs: 5000,
+                emitTurnError: false,
+            });
+        }, this.opts.idleTimeoutMs);
+    }
+    clearIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+    }
+    clearKillAfterTimer() {
+        if (this.killAfterTimer) {
+            clearTimeout(this.killAfterTimer);
+            this.killAfterTimer = null;
+        }
+    }
+    cleanupOnce() {
+        if (this.cleanupCalled)
+            return;
+        this.cleanupCalled = true;
+        this.onCleanup?.();
+    }
+    pushImageIfNew(img) {
+        if (this.turnImageCount >= MAX_IMAGES_PER_INVOCATION)
+            return;
+        const key = imageDedupeKey(img);
+        if (this.turnSeenImages.has(key))
+            return;
+        this.turnSeenImages.add(key);
+        this.turnImageCount++;
+        this.pushEvent({ type: 'image_data', image: img });
+    }
+    pushDoneOnce() {
+        if (this.turnEnded)
+            return;
+        this.turnEnded = true;
+        this.pushEvent({ type: 'done' });
+    }
+    terminate(opts) {
+        // Idempotent: once dead and the active turn is ended, there's nothing left to do.
+        if (this._state === 'dead' && (!this.turnActive || this.turnEnded)) {
+            this.cleanupOnce();
+            return;
+        }
+        this.clearHangTimer();
+        this.clearIdleTimer();
+        this.clearKillAfterTimer();
+        if (this.stdoutOnData) {
+            this.subprocess?.stdout?.off('data', this.stdoutOnData);
+            this.stdoutOnData = null;
+        }
+        this._state = 'dead';
+        // If a consumer is blocked waiting for events, guarantee we unblock it.
+        if (this.turnActive && !this.turnEnded) {
+            if (opts.emitTurnError && opts.errorMessage) {
+                this.pushEvent({ type: 'error', message: opts.errorMessage });
+            }
+            this.pushDoneOnce();
+        }
+        try {
+            this.subprocess?.kill(opts.signal);
+        }
+        catch { /* ignore */ }
+        if (opts.signal === 'SIGTERM' && opts.forceKillAfterMs && opts.forceKillAfterMs > 0) {
+            this.killAfterTimer = setTimeout(() => {
+                try {
+                    this.subprocess?.kill('SIGKILL');
+                }
+                catch { /* ignore */ }
+            }, opts.forceKillAfterMs);
+        }
+        this.cleanupOnce();
+    }
+}