@vibelet/cli 0.1.34 → 0.1.36

package/dist/drivers/claude.test.js

@@ -0,0 +1,951 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { writeFile, rm, chmod, mkdtemp, readFile } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { ClaudeDriver, isClaudeSyntheticApprovalRequestId } from './claude.js';
+import { config } from '../config.js';
+// Helper: access private members via `any` cast
+function getDriver() {
+    const driver = new ClaudeDriver();
+    const d = driver;
+    return { driver, d };
+}
+async function withMockClaudePath(claudePath, fn) {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(config, 'claudePath');
+    Object.defineProperty(config, 'claudePath', {
+        configurable: true,
+        get() {
+            return claudePath;
+        },
+    });
+    try {
+        await fn();
+    }
+    finally {
+        if (originalDescriptor) {
+            Object.defineProperty(config, 'claudePath', originalDescriptor);
+        }
+    }
+}
+async function withMockSanitizedEnv(buildEnv, fn) {
+    const originalBuildSanitizedEnv = config.buildSanitizedEnv;
+    config.buildSanitizedEnv = buildEnv;
+    try {
+        await fn();
+    }
+    finally {
+        config.buildSanitizedEnv = originalBuildSanitizedEnv;
+    }
+}
+let sendPromptTestQueue = Promise.resolve();
+async function runSerializedSendPromptTest(fn) {
+    const previous = sendPromptTestQueue;
+    let release;
+    sendPromptTestQueue = new Promise((resolve) => {
+        release = resolve;
+    });
+    await previous;
+    try {
+        await fn();
+    }
+    finally {
+        release();
+    }
+}
+function testSendPrompt(name, fn) {
+    test(name, async () => {
+        await runSerializedSendPromptTest(fn);
+    });
+}
+// ─── system init ─────────────────────────────────────────────────────
+test('handleRaw updates sessionId on system init', () => {
+    const { d } = getDriver();
+    d.sessionId = 'old-id';
+    d.handleRaw({ type: 'system', subtype: 'init', session_id: 'new-session-123' });
+    assert.equal(d.sessionId, 'new-session-123');
+});
+test('handleRaw does not update sessionId when new id matches current', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'same-id';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({ type: 'system', subtype: 'init', session_id: 'same-id' });
+    assert.equal(d.sessionId, 'same-id');
+    assert.equal(messages.length, 0);
+});
+test('handleRaw does not update sessionId when session_id is empty', () => {
+    const { d } = getDriver();
+    d.sessionId = 'keep-me';
+    d.handleRaw({ type: 'system', subtype: 'init', session_id: '' });
+    assert.equal(d.sessionId, 'keep-me');
+});
+test('handleRaw system init does not call handler', () => {
+    const { driver, d } = getDriver();
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({ type: 'system', subtype: 'init', session_id: 'abc' });
+    assert.equal(messages.length, 0);
+});
+// ─── assistant with tool_use ─────────────────────────────────────────
+test('handleRaw emits tool.call for assistant message with tool_use blocks', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'assistant',
+        message: {
+            content: [
+                { type: 'tool_use', name: 'bash', input: { command: 'ls' }, id: 'tu-1' },
+                { type: 'tool_use', name: 'write', input: { path: '/tmp/x' }, id: 'tu-2' },
+            ],
+        },
+    });
+    assert.equal(messages.length, 2);
+    assert.deepEqual(messages[0], {
+        type: 'tool.call',
+        sessionId: 'sess-1',
+        toolName: 'bash',
+        input: { command: 'ls' },
+        toolCallId: 'tu-1',
+    });
+    assert.deepEqual(messages[1], {
+        type: 'tool.call',
+        sessionId: 'sess-1',
+        toolName: 'write',
+        input: { path: '/tmp/x' },
+        toolCallId: 'tu-2',
+    });
+});
+test('handleRaw uses empty object when tool_use has no input', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'assistant',
+        message: {
+            content: [{ type: 'tool_use', name: 'read', id: 'tu-3' }],
+        },
+    });
+    assert.equal(messages.length, 1);
+    assert.deepEqual(messages[0].input, {});
+});
+test('handleRaw ignores assistant message without content array', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({ type: 'assistant', message: { content: 'just text' } });
+    assert.equal(messages.length, 0);
+});
+test('handleRaw ignores assistant message without message field', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({ type: 'assistant' });
+    assert.equal(messages.length, 0);
+});
+test('handleRaw skips non-tool_use blocks in assistant content', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'assistant',
+        message: {
+            content: [
+                { type: 'text', text: 'I will run a command' },
+                { type: 'tool_use', name: 'bash', input: { command: 'echo hi' }, id: 'tu-4' },
+            ],
+        },
+    });
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].toolName, 'bash');
+});
+// ─── user with tool_result ───────────────────────────────────────────
+test('handleRaw emits tool.result for user message with string content', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'user',
+        message: {
+            content: [
+                { type: 'tool_result', tool_use_id: 'tu-1', content: 'command output here' },
+            ],
+        },
+    });
+    assert.equal(messages.length, 1);
+    assert.deepEqual(messages[0], {
+        type: 'tool.result',
+        sessionId: 'sess-1',
+        toolCallId: 'tu-1',
+        output: 'command output here',
+    });
+});
+test('handleRaw emits tool.result with JSON-stringified object content', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    const objContent = { status: 'ok', data: [1, 2, 3] };
+    d.handleRaw({
+        type: 'user',
+        message: {
+            content: [
+                { type: 'tool_result', tool_use_id: 'tu-2', content: objContent },
+            ],
+        },
+    });
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].output, JSON.stringify(objContent));
+});
+test('handleRaw skips tool_result blocks that only contain tool references', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'user',
+        message: {
+            content: [
+                {
+                    type: 'tool_result',
+                    tool_use_id: 'tu-ref',
+                    content: [{ type: 'tool_reference', tool_name: 'WebSearch' }],
+                },
+            ],
+        },
+    });
+    assert.equal(messages.length, 0);
+});
+test('handleRaw ignores user message without content array', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({ type: 'user', message: { content: 'raw string' } });
+    assert.equal(messages.length, 0);
+});
+test('handleRaw skips non-tool_result blocks in user content', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'user',
+        message: {
+            content: [
+                { type: 'text', text: 'some user text' },
+            ],
+        },
+    });
+    assert.equal(messages.length, 0);
+});
+// ─── control_request ─────────────────────────────────────────────────
+test('handleRaw emits approval.request for control_request can_use_tool', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'control_request',
+        request_id: 'req-42',
+        request: {
+            subtype: 'can_use_tool',
+            tool_name: 'bash',
+            input: { command: 'rm -rf /' },
+            description: 'Dangerous command',
+        },
+    });
+    assert.equal(messages.length, 1);
+    assert.deepEqual(messages[0], {
+        type: 'approval.request',
+        sessionId: 'sess-1',
+        requestId: 'req-42',
+        toolName: 'bash',
+        input: { command: 'rm -rf /' },
+        description: 'Dangerous command',
+    });
+});
+test('handleRaw approval.request falls back to title when description is missing', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'control_request',
+        request_id: 'req-43',
+        request: {
+            subtype: 'can_use_tool',
+            tool_name: 'write',
+            input: {},
+            title: 'Write file',
+        },
+    });
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].description, 'Write file');
+});
+test('handleRaw approval.request uses defaults for missing fields', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'control_request',
+        request_id: 'req-44',
+        request: { subtype: 'can_use_tool' },
+    });
+    assert.equal(messages.length, 1);
+    const msg = messages[0];
+    assert.equal(msg.toolName, 'unknown');
+    assert.deepEqual(msg.input, {});
+    assert.equal(msg.description, '');
+});
+test('handleRaw ignores control_request with non-can_use_tool subtype', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'control_request',
+        request_id: 'req-45',
+        request: { subtype: 'other_thing' },
+    });
+    assert.equal(messages.length, 0);
+});
+// ─── stream_event text_delta ─────────────────────────────────────────
+test('handleRaw emits text.delta for stream_event with text_delta', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'stream_event',
+        event: {
+            type: 'content_block_delta',
+            delta: { type: 'text_delta', text: 'Hello, world!' },
+        },
+    });
+    assert.equal(messages.length, 1);
+    assert.deepEqual(messages[0], {
+        type: 'text.delta',
+        sessionId: 'sess-1',
+        content: 'Hello, world!',
+    });
+});
+test('handleRaw ignores stream_event with non-text_delta delta type', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'stream_event',
+        event: {
+            type: 'content_block_delta',
+            delta: { type: 'input_json_delta', partial_json: '{"x":1}' },
+        },
+    });
+    assert.equal(messages.length, 0);
+});
+test('handleRaw ignores stream_event with non-content_block_delta event type', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'stream_event',
+        event: { type: 'content_block_start' },
+    });
+    assert.equal(messages.length, 0);
+});
+test('handleRaw ignores stream_event with empty text', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'stream_event',
+        event: {
+            type: 'content_block_delta',
+            delta: { type: 'text_delta', text: '' },
+        },
+    });
+    assert.equal(messages.length, 0);
+});
+// ─── result success ──────────────────────────────────────────────────
+test('handleRaw emits session.done on successful result with cost and usage', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'result',
+        result: 'Task completed successfully',
+        total_cost_usd: 0.042,
+        usage: { input_tokens: 1000, output_tokens: 500 },
+    });
+    assert.equal(messages.length, 1);
+    assert.deepEqual(messages[0], {
+        type: 'session.done',
+        sessionId: 'sess-1',
+        cost: 0.042,
+        usage: { inputTokens: 1000, outputTokens: 500 },
+    });
+    assert.equal(d.sawFinalResult, true);
+});
+test('handleRaw emits session.done without usage when not provided', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'result',
+        result: 'done',
+        total_cost_usd: 0.01,
+    });
+    assert.equal(messages.length, 1);
+    const msg = messages[0];
+    assert.equal(msg.type, 'session.done');
+    assert.equal(msg.cost, 0.01);
+    assert.equal(msg.usage, undefined);
+});
+test('handleRaw emits synthetic approval.request when result includes permission_denials', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'user',
+        message: {
+            content: [
+                {
+                    type: 'tool_result',
+                    tool_use_id: 'tu-1',
+                    is_error: true,
+                    content: 'Claude requested permissions to write to /tmp/probe.txt, but you haven\'t granted it yet.',
+                },
+            ],
+        },
+    });
+    d.handleRaw({
+        type: 'result',
+        result: 'Waiting for approval.',
+        permission_denials: [
+            {
+                tool_name: 'Write',
+                tool_use_id: 'tu-1',
+                tool_input: { file_path: '/tmp/probe.txt', content: 'hi' },
+            },
+        ],
+    });
+    assert.equal(messages.length, 2);
+    assert.equal(messages[0]?.type, 'approval.request');
+    assert.ok(isClaudeSyntheticApprovalRequestId(messages[0].requestId));
+    assert.deepEqual(messages[0], {
+        type: 'approval.request',
+        sessionId: 'sess-1',
+        requestId: messages[0].requestId,
+        toolName: 'Write',
+        input: { file_path: '/tmp/probe.txt', content: 'hi' },
+        description: 'Claude requested permissions to write to /tmp/probe.txt, but you haven\'t granted it yet.',
+    });
+    assert.deepEqual(messages[1], {
+        type: 'session.done',
+        sessionId: 'sess-1',
+        cost: undefined,
+        usage: undefined,
+    });
+});
+// ─── result error ────────────────────────────────────────────────────
+test('handleRaw preserves non-limit result error text', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'result',
+        is_error: true,
+        result: 'Authentication failed',
+    });
+    assert.equal(messages.length, 1);
+    assert.deepEqual(messages[0], {
+        type: 'error',
+        sessionId: 'sess-1',
+        message: 'Authentication failed',
+    });
+    assert.equal(d.sawFinalResult, true);
+});
+test('handleRaw normalizes usage limit result errors', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'result',
+        is_error: true,
+        result: 'Rate limit exceeded',
+    });
+    assert.equal(messages.length, 1);
+    assert.deepEqual(messages[0], {
+        type: 'error',
+        sessionId: 'sess-1',
+        message: 'Claude usage limit reached. Rate limit exceeded',
+    });
+});
+test('handleRaw emits error with default message when result text is empty', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'result',
+        is_error: true,
+        result: '',
+    });
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].message, 'Claude returned an error result.');
+});
+test('handleRaw emits error with default message when result is not a string', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({
+        type: 'result',
+        is_error: true,
+        result: { some: 'object' },
+    });
+    assert.equal(messages.length, 1);
+    assert.equal(messages[0].message, 'Claude returned an error result.');
+});
+// ─── No handler ──────────────────────────────────────────────────────
+test('handleRaw does not throw when handler is null', () => {
+    const { d } = getDriver();
+    // Do NOT set handler
+    assert.doesNotThrow(() => {
+        d.handleRaw({ type: 'assistant', message: { content: [{ type: 'tool_use', name: 'bash', input: {}, id: 'x' }] } });
+    });
+});
+test('handleRaw does not throw for stream_event when handler is null', () => {
+    const { d } = getDriver();
+    assert.doesNotThrow(() => {
+        d.handleRaw({
+            type: 'stream_event',
+            event: { type: 'content_block_delta', delta: { type: 'text_delta', text: 'hi' } },
+        });
+    });
+});
+test('handleRaw does not throw for result when handler is null', () => {
+    const { d } = getDriver();
+    assert.doesNotThrow(() => {
+        d.handleRaw({ type: 'result', result: 'ok' });
+    });
+});
+test('handleRaw system init still updates sessionId even without handler', () => {
+    const { d } = getDriver();
+    d.sessionId = 'old';
+    d.handleRaw({ type: 'system', subtype: 'init', session_id: 'new-id' });
+    assert.equal(d.sessionId, 'new-id');
+});
+// ─── Unknown type ────────────────────────────────────────────────────
+test('handleRaw does not emit for unknown type', () => {
+    const { driver, d } = getDriver();
+    d.sessionId = 'sess-1';
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    d.handleRaw({ type: 'unknown_event', data: {} });
+    assert.equal(messages.length, 0);
+});
+// ─── start() ─────────────────────────────────────────────────────────
+test('start() returns resumeSessionId when provided', async () => {
+    const { driver } = getDriver();
+    const id = await driver.start('/tmp', 'resume-abc');
+    assert.equal(id, 'resume-abc');
+});
+test('start() generates pending_ sessionId when no resume id', async () => {
+    const { driver } = getDriver();
+    const id = await driver.start('/tmp');
+    assert.ok(id.startsWith('pending_'));
+});
+test('start() stores cwd and approvalMode', async () => {
+    const { driver, d } = getDriver();
+    await driver.start('/home/user', undefined, 'autoApprove');
+    assert.equal(d.cwd, '/home/user');
+    assert.equal(d.approvalMode, 'autoApprove');
+});
+// ─── stop() ──────────────────────────────────────────────────────────
+test('stop() does nothing when proc is null', () => {
+    const { driver } = getDriver();
+    assert.doesNotThrow(() => driver.stop());
+});
+// ─── interrupt() ─────────────────────────────────────────────────────
+test('interrupt() does nothing when proc is null', () => {
+    const { driver } = getDriver();
+    assert.doesNotThrow(() => driver.interrupt());
+});
+// ─── respondApproval() ───────────────────────────────────────────────
+test('respondApproval() does not throw when proc is null', () => {
+    const { driver } = getDriver();
+    assert.doesNotThrow(() => driver.respondApproval('req-1', true));
+    assert.doesNotThrow(() => driver.respondApproval('req-2', false));
+});
+test('respondApproval() writes control_response JSON to stdin', async () => {
+    const { driver, d } = getDriver();
+    await driver.start('/tmp');
+    let written = '';
+    d.proc = {
+        stdin: {
+            writable: true,
+            write(chunk) {
+                written += chunk;
+                return true;
+            },
+        },
+    };
+    driver.respondApproval('req-42', true);
+    const parsed = JSON.parse(written.trim());
+    assert.equal(parsed.type, 'control_response');
+    assert.equal(parsed.request_id, 'req-42');
+    assert.equal(parsed.permission_granted, true);
+});
+test('respondApproval() sends permission_granted=false for denied requests', async () => {
+    const { driver, d } = getDriver();
+    await driver.start('/tmp');
+    let written = '';
+    d.proc = {
+        stdin: {
+            writable: true,
+            write(chunk) {
+                written += chunk;
+                return true;
+            },
+        },
+    };
+    driver.respondApproval('req-99', false);
+    const parsed = JSON.parse(written.trim());
+    assert.equal(parsed.type, 'control_response');
+    assert.equal(parsed.request_id, 'req-99');
+    assert.equal(parsed.permission_granted, false);
+});
+// ─── onMessage() ─────────────────────────────────────────────────────
+test('onMessage() sets the handler', () => {
+    const { driver, d } = getDriver();
+    assert.equal(d.handler, null);
+    const handler = () => { };
+    driver.onMessage(handler);
+    assert.equal(d.handler, handler);
+});
+// ─── sendPrompt() integration tests ─────────────────────────────────
+/** Helper: create a temp dir with a fake claude script and point config.claudePath at it. */
+async function withFakeClaudeScript(scriptBody, fn) {
+    const tmpDir = await mkdtemp(join(tmpdir(), 'claude-test-'));
+    const scriptPath = join(tmpDir, 'fake-claude');
+    await writeFile(scriptPath, `#!/bin/sh\n${scriptBody}\n`, 'utf-8');
+    await chmod(scriptPath, 0o755);
+    try {
+        await withMockClaudePath(scriptPath, fn);
+    }
+    finally {
+        await rm(tmpDir, { recursive: true, force: true });
+    }
+}
+async function waitForFile(path, timeoutMs = 1000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            return await readFile(path, 'utf-8');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    return await readFile(path, 'utf-8');
+}
+/** Wait until a message of the given type appears, or timeout */
+function waitForMessage(driver, messages, predicate, timeoutMs = 10_000) {
+    return new Promise((resolve, reject) => {
+        if (predicate(messages)) {
+            resolve();
+            return;
+        }
+        const originalHandler = driver.handler;
+        const timer = setTimeout(() => { reject(new Error('Timed out waiting for message')); }, timeoutMs);
+        driver.handler = (msg) => {
+            originalHandler?.(msg);
+            messages.push(msg);
+            if (predicate(messages)) {
+                clearTimeout(timer);
+                resolve();
+            }
+        };
+    });
+}
+/** Wait for the spawned process to exit */
+function waitForExit(driver, timeoutMs = 10_000) {
+    return new Promise((resolve, reject) => {
+        const proc = driver.proc;
+        if (!proc || proc.exitCode !== null || proc.signalCode !== null || proc.killed) {
+            resolve();
+            return;
+        }
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            if (!driver.proc || proc.exitCode !== null || proc.signalCode !== null || proc.killed) {
+                finish();
+                return;
+            }
+            reject(new Error('Timed out waiting for exit'));
+        }, timeoutMs);
+        proc.once('exit', finish);
+        proc.once('close', finish);
+    });
+}
+testSendPrompt('sendPrompt: spawns process and emits text.delta and session.done', async () => {
+    await withFakeClaudeScript(`echo '{"type":"system","subtype":"init","session_id":"test-sess-123"}'
+echo '{"type":"stream_event","event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"Hello"}}}'
+echo '{"type":"result","result":"done","total_cost_usd":0.01,"usage":{"input_tokens":10,"output_tokens":5}}'`, async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp');
+        const messages = [];
+        driver.onMessage((msg) => messages.push(msg));
+        driver.sendPrompt('test message');
+        await waitForMessage(driver, messages, (msgs) => msgs.some(m => m.type === 'session.done'));
+        const types = messages.map(m => m.type);
+        assert.ok(types.includes('text.delta'), `Expected text.delta in ${JSON.stringify(types)}`);
+        assert.ok(types.includes('session.done'), `Expected session.done in ${JSON.stringify(types)}`);
+    });
+});
+testSendPrompt('sendPrompt: emits error on non-zero exit code without result', async () => {
+    await withFakeClaudeScript('exit 1', async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp');
+        const messages = [];
+        driver.onMessage((msg) => messages.push(msg));
+        driver.sendPrompt('test message');
+        await waitForMessage(driver, messages, (msgs) => msgs.some(m => m.type === 'error'));
+        const errors = messages.filter(m => m.type === 'error');
+        assert.ok(errors.length > 0, 'Should emit error on non-zero exit');
+    });
+});
+testSendPrompt('sendPrompt: includes stderr detail in non-zero exit errors', async () => {
+    await withFakeClaudeScript(`echo 'authentication failed for current account' >&2
+exit 1`, async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp');
+        const messages = [];
+        driver.onMessage((msg) => messages.push(msg));
+        driver.sendPrompt('test message');
+        await waitForMessage(driver, messages, (msgs) => msgs.some(m => m.type === 'error'));
+        const error = messages.find(m => m.type === 'error');
+        assert.equal(error.message, 'Claude exited with code 1: authentication failed for current account');
+    });
+});
+testSendPrompt('sendPrompt: normalizes usage limit stderr on non-zero exit', async () => {
+    await withFakeClaudeScript(`echo 'Rate limit exceeded' >&2
+exit 1`, async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp');
+        const messages = [];
+        driver.onMessage((msg) => messages.push(msg));
+        driver.sendPrompt('test message');
+        await waitForMessage(driver, messages, (msgs) => msgs.some(m => m.type === 'error'));
+        const error = messages.find(m => m.type === 'error');
+        assert.equal(error.message, 'Claude usage limit reached. Rate limit exceeded');
+    });
+});
+testSendPrompt('sendPrompt: does not emit error on non-zero exit if result was already seen', async () => {
+    await withFakeClaudeScript(`echo '{"type":"result","result":"ok"}'
+exit 1`, async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp');
+        const messages = [];
+        driver.onMessage((msg) => messages.push(msg));
+        driver.sendPrompt('test message');
+        // Wait for process to fully exit
+        await waitForExit(driver);
+        // Small extra delay for any pending callbacks
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const errors = messages.filter(m => m.type === 'error');
+        assert.equal(errors.length, 0, 'Should not emit error when result was already seen');
+    });
+});
+testSendPrompt('sendPrompt: handles spawn error for nonexistent binary', async () => {
+    await withMockClaudePath('/nonexistent/path/to/claude-binary', async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp');
+        const messages = [];
+        driver.onMessage((msg) => messages.push(msg));
+        driver.sendPrompt('test message');
+        await waitForMessage(driver, messages, (msgs) => msgs.some(m => m.type === 'error'));
+        const errors = messages.filter(m => m.type === 'error');
+        assert.ok(errors.length > 0, 'Should emit error on spawn failure');
+    });
+});
+testSendPrompt('sendPrompt: uses --resume flag for existing session', async () => {
+    await withFakeClaudeScript(`echo '{"type":"result","result":"ok"}'`, async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp', 'existing-session-123');
+        driver.onMessage(() => { });
+        driver.sendPrompt('test');
+        await waitForExit(driver);
+    });
+});
+testSendPrompt('sendPrompt: uses --dangerously-skip-permissions for autoApprove mode', async () => {
+    await withFakeClaudeScript(`echo '{"type":"result","result":"ok"}'`, async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp', undefined, 'autoApprove');
+        driver.onMessage(() => { });
+        driver.sendPrompt('test');
+        await waitForExit(driver);
+    });
+});
+testSendPrompt('sendPrompt: injects --settings hook file for normal mode when hook bridge is configured', async () => {
+    const tmpDir = await mkdtemp(join(tmpdir(), 'claude-args-'));
+    const argLogPath = join(tmpDir, 'args.log');
+    let settingsPath = '';
+    try {
+        await withFakeClaudeScript(`printf '%s\n' "$@" > ${JSON.stringify(argLogPath)}
+echo '{"type":"result","result":"ok"}'`, async () => {
+            const driver = new ClaudeDriver();
+            driver.configureHookBridge(4321, 'secret-1');
+            await driver.start('/tmp', undefined, 'normal');
+            driver.onMessage(() => { });
+            driver.sendPrompt('test');
+            settingsPath = driver.hookFiles?.settingsPath ?? '';
+            assert.ok(settingsPath?.endsWith('settings.json'));
+            const settings = await readFile(settingsPath, 'utf-8');
+            assert.match(settings, /"PreToolUse"/);
+            assert.doesNotMatch(settings, /"PermissionRequest"/);
+            await waitForExit(driver);
+        });
+        const args = (await waitForFile(argLogPath)).trim().split('\n').filter(Boolean);
+        const settingsIndex = args.indexOf('--settings');
+        assert.ok(settingsIndex >= 0, `Expected --settings in ${JSON.stringify(args)}`);
+        assert.equal(args[settingsIndex + 1], settingsPath);
+        assert.equal(args.includes('--dangerously-skip-permissions'), false);
+    }
+    finally {
+        await rm(tmpDir, { recursive: true, force: true });
+    }
+});
+testSendPrompt('sendPrompt: strips CMUX environment variables before spawning Claude', async () => {
+    const tmpDir = await mkdtemp(join(tmpdir(), 'claude-env-'));
+    const envLogPath = join(tmpDir, 'env.log');
+    try {
+        const sanitizedEnvWithCmux = {
+            ...config.buildSanitizedEnv(),
+            CMUX_PORT: '9310',
+        };
+        await withMockSanitizedEnv(() => ({ ...sanitizedEnvWithCmux }), async () => await withFakeClaudeScript(`printf '%s' "$CMUX_PORT" > ${JSON.stringify(envLogPath)}
+echo '{"type":"result","result":"ok"}'`, async () => {
+            const driver = new ClaudeDriver();
+            await driver.start('/tmp', undefined, 'normal');
+            driver.onMessage(() => { });
+            driver.sendPrompt('test');
+            await waitForExit(driver);
+        }));
+        const value = await readFile(envLogPath, 'utf-8');
+        assert.equal(value, '');
+    }
+    finally {
+        await rm(tmpDir, { recursive: true, force: true });
+    }
+});
+testSendPrompt('sendPrompt: skips hook --settings when acceptEdits retry mode is used', async () => {
+    const tmpDir = await mkdtemp(join(tmpdir(), 'claude-args-'));
+    const argLogPath = join(tmpDir, 'args.log');
+    try {
+        await withFakeClaudeScript(`printf '%s\n' "$@" > ${JSON.stringify(argLogPath)}
+echo '{"type":"result","result":"ok"}'`, async () => {
+            const driver = new ClaudeDriver();
+            driver.configureHookBridge(4321, 'secret-2');
+            await driver.start('/tmp', undefined, 'acceptEdits');
+            driver.onMessage(() => { });
+            driver.sendPrompt('test');
+            await waitForExit(driver);
+        });
+        const args = (await waitForFile(argLogPath)).trim().split('\n').filter(Boolean);
+        assert.equal(args.includes('--settings'), false);
+        assert.deepEqual(args.slice(args.indexOf('--permission-mode'), args.indexOf('--permission-mode') + 2), [
+            '--permission-mode',
+            'acceptEdits',
+        ]);
+    }
+    finally {
+        await rm(tmpDir, { recursive: true, force: true });
+    }
+});
+testSendPrompt('sendPrompt: stderr output is handled without crashing', async () => {
+    await withFakeClaudeScript(`echo 'some warning' >&2
+echo '{"type":"result","result":"ok"}'`, async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp');
+        const messages = [];
+        driver.onMessage((msg) => messages.push(msg));
+        driver.sendPrompt('test');
+        await waitForMessage(driver, messages, (msgs) => msgs.some(m => m.type === 'session.done'));
+        const done = messages.filter(m => m.type === 'session.done');
+        assert.ok(done.length > 0, 'Should still emit session.done after stderr output');
+    });
+});
+testSendPrompt('stop: kills process and sets proc to null', async () => {
+    await withFakeClaudeScript('sleep 30', async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp');
+        driver.onMessage(() => { });
+        driver.sendPrompt('test');
+        await new Promise(resolve => setTimeout(resolve, 200));
+        assert.ok(driver.proc !== null, 'proc should be set after sendPrompt');
+        driver.stop();
+        assert.equal(driver.proc, null, 'proc should be null after stop');
+    });
+});
+test('setApprovalMode: changes mode for subsequent sendPrompt calls', async () => {
+    const driver = new ClaudeDriver();
+    await driver.start('/tmp', undefined, 'normal');
+    assert.equal(driver.approvalMode, 'normal');
+    driver.setApprovalMode('autoApprove');
+    assert.equal(driver.approvalMode, 'autoApprove');
+    driver.setApprovalMode('normal');
+    assert.equal(driver.approvalMode, 'normal');
+});
+testSendPrompt('sendPrompt: ENOENT with invalid cwd reports cwd error', async () => {
+    const driver = new ClaudeDriver();
+    await driver.start('/nonexistent/cwd/path/that/does/not/exist');
+    const messages = [];
+    driver.onMessage((msg) => messages.push(msg));
+    driver.sendPrompt('test message');
+    await waitForMessage(driver, messages, (msgs) => msgs.some(m => m.type === 'error'));
+    const errors = messages.filter(m => m.type === 'error');
+    assert.ok(errors.length > 0, 'Should emit error');
+    const errorMsg = errors[0].message;
+    assert.ok(errorMsg.includes('Working directory does not exist'), `Error should mention cwd, got: ${errorMsg}`);
+});
+testSendPrompt('interrupt: kills running process', async () => {
+    await withFakeClaudeScript('sleep 30', async () => {
+        const driver = new ClaudeDriver();
+        await driver.start('/tmp');
+        const messages = [];
+        driver.onMessage((msg) => messages.push(msg));
+        driver.sendPrompt('test');
+        await new Promise(resolve => setTimeout(resolve, 200));
+        driver.interrupt();
+        await waitForMessage(driver, messages, (msgs) => msgs.some((msg) => msg.type === 'session.interrupted'));
+    });
+});
+//# sourceMappingURL=claude.test.js.map