factory-factory 0.2.6 → 0.2.8

package/dist/src/backend/domains/session/claude/protocol.test.js

@@ -0,0 +1,848 @@
+import { PassThrough } from 'node:stream';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ClaudeProtocol } from './protocol.js';
+describe('ClaudeProtocol', () => {
+    let stdin;
+    let stdout;
+    let protocol;
+    beforeEach(() => {
+        stdin = new PassThrough();
+        stdout = new PassThrough();
+        protocol = new ClaudeProtocol(stdin, stdout);
+        protocol.start();
+    });
+    afterEach(() => {
+        protocol.stop();
+    });
+    describe('sendUserMessage', () => {
+        it('should send message with string content', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendUserMessage('Hello, Claude!');
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.type).toBe('user');
+            expect(parsed.message.role).toBe('user');
+            expect(parsed.message.content).toBe('Hello, Claude!');
+        });
+        it('should send message with content array', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendUserMessage([{ type: 'text', text: 'Hello!' }]);
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.type).toBe('user');
+            expect(parsed.message.role).toBe('user');
+            expect(parsed.message.content).toEqual([{ type: 'text', text: 'Hello!' }]);
+        });
+        it('should send message with multiple content items', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendUserMessage([
+                { type: 'text', text: 'First part' },
+                { type: 'text', text: 'Second part' },
+            ]);
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.message.content).toHaveLength(2);
+            expect(parsed.message.content[0].text).toBe('First part');
+            expect(parsed.message.content[1].text).toBe('Second part');
+        });
+        it('should append newline to message for NDJSON format', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendUserMessage('Test');
+            const written = Buffer.concat(chunks).toString();
+            expect(written.endsWith('\n')).toBe(true);
+        });
+    });
+    describe('sendSetPermissionMode', () => {
+        it('should send set_permission_mode request with bypassPermissions', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendSetPermissionMode('bypassPermissions');
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.type).toBe('control_request');
+            expect(parsed.request.subtype).toBe('set_permission_mode');
+            expect(parsed.request.mode).toBe('bypassPermissions');
+        });
+        it('should send set_permission_mode request with default mode', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendSetPermissionMode('default');
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.request.mode).toBe('default');
+        });
+        it('should send set_permission_mode request with acceptEdits mode', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendSetPermissionMode('acceptEdits');
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.request.mode).toBe('acceptEdits');
+        });
+        it('should send set_permission_mode request with plan mode', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendSetPermissionMode('plan');
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.request.mode).toBe('plan');
+        });
+        it('should include a unique request_id', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendSetPermissionMode('bypassPermissions');
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.request_id).toBeDefined();
+            expect(typeof parsed.request_id).toBe('string');
+            expect(parsed.request_id.length).toBeGreaterThan(0);
+        });
+    });
+    describe('sendInterrupt', () => {
+        it('should send interrupt request', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendInterrupt();
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.type).toBe('control_request');
+            expect(parsed.request.subtype).toBe('interrupt');
+        });
+        it('should include a unique request_id', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendInterrupt();
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.request_id).toBeDefined();
+            expect(typeof parsed.request_id).toBe('string');
+        });
+        it('should generate different request_ids for multiple interrupts', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendInterrupt();
+            await protocol.sendInterrupt();
+            const written = Buffer.concat(chunks).toString();
+            const lines = written.trim().split('\n');
+            const parsed1 = JSON.parse(lines[0]);
+            const parsed2 = JSON.parse(lines[1]);
+            expect(parsed1.request_id).not.toBe(parsed2.request_id);
+        });
+    });
+    describe('sendControlResponse', () => {
+        it('should send control response with request_id', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendControlResponse('req-123', { behavior: 'allow', updatedInput: {} });
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.type).toBe('control_response');
+            expect(parsed.response.request_id).toBe('req-123');
+            expect(parsed.response.subtype).toBe('success');
+            expect(parsed.response.response).toEqual({ behavior: 'allow', updatedInput: {} });
+        });
+        it('should send deny response with message', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendControlResponse('req-456', {
+                behavior: 'deny',
+                message: 'Not allowed',
+            });
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.response.response.behavior).toBe('deny');
+            expect(parsed.response.response.message).toBe('Not allowed');
+        });
+        it('should send allow response with updated input', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendControlResponse('req-789', {
+                behavior: 'allow',
+                updatedInput: { file_path: '/modified/path.txt' },
+            });
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.response.response.behavior).toBe('allow');
+            expect(parsed.response.response.updatedInput).toEqual({ file_path: '/modified/path.txt' });
+        });
+        it('should send hook response data', async () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            await protocol.sendControlResponse('req-hook', {
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'allow',
+                    permissionDecisionReason: 'Safe tool',
+                },
+            });
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.response.response.hookSpecificOutput.hookEventName).toBe('PreToolUse');
+            expect(parsed.response.response.hookSpecificOutput.permissionDecision).toBe('allow');
+        });
+    });
+    describe('sendInitialize', () => {
+        it('should send initialize request', () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            const initPromise = protocol.sendInitialize();
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.type).toBe('control_request');
+            expect(parsed.request.subtype).toBe('initialize');
+            expect(parsed.request_id).toBeDefined();
+            protocol.stop();
+            initPromise.catch(() => {
+            });
+        });
+        it('should send initialize request with hooks config', () => {
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            const hooksConfig = {
+                PreToolUse: [{ matcher: 'Bash', hookCallbackIds: ['cb-1'] }],
+                Stop: [{ hookCallbackIds: ['cb-2'] }],
+            };
+            const initPromise = protocol.sendInitialize(hooksConfig);
+            const written = Buffer.concat(chunks).toString();
+            const parsed = JSON.parse(written.trim());
+            expect(parsed.request.hooks).toEqual(hooksConfig);
+            protocol.stop();
+            initPromise.catch(() => {
+            });
+        });
+        it('should resolve with response data when CLI responds', async () => {
+            const initPromise = protocol.sendInitialize();
+            await new Promise((resolve) => setImmediate(resolve));
+            const chunks = [];
+            stdin.on('data', (chunk) => chunks.push(chunk));
+            const responseData = {
+                commands: [{ name: 'test', description: 'Test command' }],
+                output_style: 'stream-json',
+                available_output_styles: ['stream-json', 'json'],
+                models: [{ value: 'claude-3', displayName: 'Claude 3', description: 'Latest' }],
+                account: { email: 'test@example.com', organization: 'Test', subscriptionType: 'pro' },
+            };
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 1000 });
+            protocol2.start();
+            const chunks2 = [];
+            stdin2.on('data', (chunk) => chunks2.push(chunk.toString()));
+            const initPromise2 = protocol2.sendInitialize();
+            await new Promise((resolve) => setImmediate(resolve));
+            const sentMessage = JSON.parse(chunks2[0].trim());
+            const requestId = sentMessage.request_id;
+            const response = {
+                type: 'control_response',
+                response: {
+                    subtype: 'success',
+                    request_id: requestId,
+                    response: responseData,
+                },
+            };
+            stdout2.write(`${JSON.stringify(response)}\n`);
+            const result = await initPromise2;
+            expect(result).toEqual(responseData);
+            protocol2.stop();
+            protocol.stop();
+            initPromise.catch(() => {
+            });
+        });
+        it('should reject on timeout', async () => {
+            const shortTimeoutProtocol = new ClaudeProtocol(stdin, stdout, { requestTimeout: 50 });
+            shortTimeoutProtocol.start();
+            await expect(shortTimeoutProtocol.sendInitialize()).rejects.toThrow('timed out');
+            shortTimeoutProtocol.stop();
+        });
+    });
+    describe('message parsing', () => {
+        it('should emit message event for valid JSON', async () => {
+            const messagePromise = new Promise((resolve) => {
+                protocol.on('message', resolve);
+            });
+            const msg = {
+                type: 'assistant',
+                session_id: 'abc',
+                message: { role: 'assistant', content: [] },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            const received = await messagePromise;
+            expect(received).toEqual(msg);
+        });
+        it('should emit control_request event for control requests', async () => {
+            const requestPromise = new Promise((resolve) => {
+                protocol.on('control_request', resolve);
+            });
+            const msg = {
+                type: 'control_request',
+                request_id: 'req-123',
+                request: {
+                    subtype: 'can_use_tool',
+                    tool_name: 'Read',
+                    input: { file_path: '/test.txt' },
+                    tool_use_id: 'tool-1',
+                },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            const received = await requestPromise;
+            expect(received).toEqual(msg);
+        });
+        it('should emit stream_event for stream events', async () => {
+            const eventPromise = new Promise((resolve) => {
+                protocol.on('stream_event', resolve);
+            });
+            const msg = {
+                type: 'stream_event',
+                session_id: 'abc',
+                event: {
+                    type: 'content_block_delta',
+                    index: 0,
+                    delta: { type: 'text_delta', text: 'Hi' },
+                },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            const received = await eventPromise;
+            expect(received).toEqual(msg);
+        });
+        it('should emit control_cancel event for cancel requests', async () => {
+            const cancelPromise = new Promise((resolve) => {
+                protocol.on('control_cancel', resolve);
+            });
+            const msg = {
+                type: 'control_cancel_request',
+                request_id: 'req-to-cancel',
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            const received = await cancelPromise;
+            expect(received).toEqual(msg);
+        });
+        it('should skip empty lines', async () => {
+            const messages = [];
+            protocol.on('message', (msg) => messages.push(msg));
+            stdout.write('\n');
+            stdout.write('  \n');
+            stdout.write('\t\n');
+            const msg = {
+                type: 'assistant',
+                session_id: 'test',
+                message: { role: 'assistant', content: [] },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(messages).toHaveLength(1);
+            expect(messages[0]).toEqual(msg);
+        });
+        it('should handle malformed JSON gracefully', async () => {
+            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {
+            });
+            const messages = [];
+            protocol.on('message', (msg) => messages.push(msg));
+            stdout.write('{ invalid json }\n');
+            const validMsg = {
+                type: 'assistant',
+                session_id: 'test',
+                message: { role: 'assistant', content: [] },
+            };
+            stdout.write(`${JSON.stringify(validMsg)}\n`);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(messages).toHaveLength(1);
+            expect(messages[0]).toEqual(validMsg);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            consoleErrorSpy.mockRestore();
+        });
+        it('should skip messages that fail schema validation', async () => {
+            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {
+            });
+            const messages = [];
+            protocol.on('message', (msg) => messages.push(msg));
+            stdout.write('{"session_id": "test", "data": "missing type field"}\n');
+            const validMsg = {
+                type: 'assistant',
+                session_id: 'test',
+                message: { role: 'assistant', content: [] },
+            };
+            stdout.write(`${JSON.stringify(validMsg)}\n`);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(messages).toHaveLength(1);
+            expect(messages[0]).toEqual(validMsg);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            consoleErrorSpy.mockRestore();
+        });
+        it('should emit both message and specific event for control requests', async () => {
+            const messages = [];
+            const controlRequests = [];
+            protocol.on('message', (msg) => messages.push(msg));
+            protocol.on('control_request', (req) => controlRequests.push(req));
+            const msg = {
+                type: 'control_request',
+                request_id: 'req-123',
+                request: {
+                    subtype: 'can_use_tool',
+                    tool_name: 'Bash',
+                    input: { command: 'ls' },
+                },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(messages).toHaveLength(1);
+            expect(controlRequests).toHaveLength(1);
+        });
+        it('should handle multiple messages in sequence', async () => {
+            const messages = [];
+            protocol.on('message', (msg) => messages.push(msg));
+            const msg1 = {
+                type: 'assistant',
+                session_id: 'test',
+                message: { role: 'assistant', content: [{ type: 'text', text: 'First' }] },
+            };
+            const msg2 = {
+                type: 'assistant',
+                session_id: 'test',
+                message: { role: 'assistant', content: [{ type: 'text', text: 'Second' }] },
+            };
+            stdout.write(`${JSON.stringify(msg1)}\n`);
+            stdout.write(`${JSON.stringify(msg2)}\n`);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(messages).toHaveLength(2);
+            expect(messages[0]).toEqual(msg1);
+            expect(messages[1]).toEqual(msg2);
+        });
+    });
+    describe('request tracking', () => {
+        it('should reject pending requests when protocol is stopped', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 60_000 });
+            protocol2.start();
+            const initPromise = protocol2.sendInitialize();
+            protocol2.stop();
+            await expect(initPromise).rejects.toThrow(/Protocol stopped|Connection closed/);
+        });
+        it('should reject pending requests when stream closes', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 60_000 });
+            protocol2.start();
+            const initPromise = protocol2.sendInitialize();
+            stdout2.end();
+            await expect(initPromise).rejects.toThrow('Connection closed');
+        });
+        it('should reject pending request when control_cancel is received', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 60_000 });
+            protocol2.start();
+            const chunks = [];
+            stdin2.on('data', (chunk) => chunks.push(chunk.toString()));
+            const initPromise = protocol2.sendInitialize();
+            await new Promise((resolve) => setImmediate(resolve));
+            const sentMessage = JSON.parse(chunks[0].trim());
+            const requestId = sentMessage.request_id;
+            const cancelMsg = {
+                type: 'control_cancel_request',
+                request_id: requestId,
+            };
+            stdout2.write(`${JSON.stringify(cancelMsg)}\n`);
+            await expect(initPromise).rejects.toThrow('Request cancelled by CLI');
+            protocol2.stop();
+        });
+        it('should emit close event when stream ends', async () => {
+            const closePromise = new Promise((resolve) => {
+                protocol.on('close', resolve);
+            });
+            stdout.end();
+            await closePromise;
+            expect(true).toBe(true);
+        });
+    });
+    describe('start/stop', () => {
+        it('should not start twice', () => {
+            const messages = [];
+            protocol.on('message', (msg) => messages.push(msg));
+            protocol.start();
+            const msg = {
+                type: 'assistant',
+                session_id: 'test',
+                message: { role: 'assistant', content: [] },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            return new Promise((resolve) => {
+                setImmediate(() => {
+                    expect(messages).toHaveLength(1);
+                    resolve();
+                });
+            });
+        });
+        it('should not stop twice without error', () => {
+            protocol.stop();
+            expect(() => protocol.stop()).not.toThrow();
+        });
+        it('should not emit events after stop', async () => {
+            const messages = [];
+            protocol.on('message', (msg) => messages.push(msg));
+            protocol.stop();
+            const msg = {
+                type: 'assistant',
+                session_id: 'test',
+                message: { role: 'assistant', content: [] },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(messages).toHaveLength(0);
+        });
+    });
+    describe('error handling', () => {
+        it('should have error event handler registered for stdin', () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2);
+            const listenersBefore = stdin2.listenerCount('error');
+            protocol2.start();
+            const listenersAfter = stdin2.listenerCount('error');
+            expect(listenersAfter).toBeGreaterThan(listenersBefore);
+            protocol2.stop();
+        });
+        it('should have error event handler registered for stdout', () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2);
+            const listenersBefore = stdout2.listenerCount('error');
+            protocol2.start();
+            const listenersAfter = stdout2.listenerCount('error');
+            expect(listenersAfter).toBeGreaterThan(listenersBefore);
+            protocol2.stop();
+        });
+        it('should emit error when stdin emits error', () => {
+            const errorHandler = vi.fn();
+            protocol.on('error', errorHandler);
+            const testError = new Error('stdin write error');
+            stdin.emit('error', testError);
+            expect(errorHandler).toHaveBeenCalledWith(testError);
+        });
+        it('should forward error events from the protocol to listeners', () => {
+            const errorHandler = vi.fn();
+            protocol.on('error', errorHandler);
+            const testError = new Error('Test error');
+            protocol.emit('error', testError);
+            expect(errorHandler).toHaveBeenCalledWith(testError);
+        });
+    });
+    describe('protocol options', () => {
+        it('should use default request timeout of 60000ms', () => {
+            const defaultProtocol = new ClaudeProtocol(stdin, stdout);
+            expect(defaultProtocol).toBeDefined();
+        });
+        it('should use custom request timeout', async () => {
+            const customTimeout = 100;
+            const customProtocol = new ClaudeProtocol(stdin, stdout, { requestTimeout: customTimeout });
+            customProtocol.start();
+            const startTime = Date.now();
+            try {
+                await customProtocol.sendInitialize();
+            }
+            catch (_e) {
+            }
+            const elapsed = Date.now() - startTime;
+            expect(elapsed).toBeGreaterThanOrEqual(customTimeout - 10);
+            expect(elapsed).toBeLessThan(customTimeout + 100);
+            customProtocol.stop();
+        });
+    });
+    describe('backpressure handling', () => {
+        it('should reject pending send when stop() is called during backpressure', async () => {
+            const smallStdin = new PassThrough({ highWaterMark: 16 });
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(smallStdin, stdout2);
+            protocol2.start();
+            smallStdin.pause();
+            const sendPromise = protocol2.sendUserMessage('x'.repeat(100));
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            protocol2.stop();
+            await expect(sendPromise).rejects.toThrow('Protocol stopped');
+        });
+        it('should reject queued sends when stop() is called', async () => {
+            const smallStdin = new PassThrough({ highWaterMark: 16 });
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(smallStdin, stdout2);
+            protocol2.start();
+            smallStdin.pause();
+            const sendPromise1 = protocol2.sendUserMessage('first'.repeat(20));
+            const sendPromise2 = protocol2.sendUserMessage('second'.repeat(20));
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            protocol2.stop();
+            await expect(sendPromise1).rejects.toThrow('Protocol stopped');
+            await expect(sendPromise2).rejects.toThrow('Protocol stopped');
+        });
+    });
+    describe('schema validation', () => {
+        it('should reject initialize response with invalid structure', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 1000 });
+            protocol2.start();
+            const chunks2 = [];
+            stdin2.on('data', (chunk) => chunks2.push(chunk.toString()));
+            const initPromise = protocol2.sendInitialize();
+            await new Promise((resolve) => setImmediate(resolve));
+            const sentMessage = JSON.parse(chunks2[0].trim());
+            const requestId = sentMessage.request_id;
+            const response = {
+                type: 'control_response',
+                response: {
+                    subtype: 'success',
+                    request_id: requestId,
+                    response: {
+                        commands: [],
+                        models: [],
+                        account: {},
+                    },
+                },
+            };
+            stdout2.write(`${JSON.stringify(response)}\n`);
+            await expect(initPromise).rejects.toThrow('Invalid initialize response');
+            protocol2.stop();
+        });
+        it('should reject initialize response with wrong account type', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 1000 });
+            protocol2.start();
+            const chunks2 = [];
+            stdin2.on('data', (chunk) => chunks2.push(chunk.toString()));
+            const initPromise = protocol2.sendInitialize();
+            await new Promise((resolve) => setImmediate(resolve));
+            const sentMessage = JSON.parse(chunks2[0].trim());
+            const requestId = sentMessage.request_id;
+            const response = {
+                type: 'control_response',
+                response: {
+                    subtype: 'success',
+                    request_id: requestId,
+                    response: {
+                        commands: [],
+                        output_style: 'stream-json',
+                        available_output_styles: ['stream-json'],
+                        models: [],
+                        account: 'not-an-object',
+                    },
+                },
+            };
+            stdout2.write(`${JSON.stringify(response)}\n`);
+            await expect(initPromise).rejects.toThrow('Invalid initialize response');
+            protocol2.stop();
+        });
+        it('should accept valid initialize response', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 1000 });
+            protocol2.start();
+            const chunks2 = [];
+            stdin2.on('data', (chunk) => chunks2.push(chunk.toString()));
+            const initPromise = protocol2.sendInitialize();
+            await new Promise((resolve) => setImmediate(resolve));
+            const sentMessage = JSON.parse(chunks2[0].trim());
+            const requestId = sentMessage.request_id;
+            const validResponse = {
+                commands: [{ name: 'test', description: 'Test command' }],
+                output_style: 'stream-json',
+                available_output_styles: ['stream-json', 'json'],
+                models: [{ value: 'claude-3', displayName: 'Claude 3', description: 'Latest' }],
+                account: {
+                    email: 'test@example.com',
+                    organization: 'Test Org',
+                    subscriptionType: 'pro',
+                },
+            };
+            const response = {
+                type: 'control_response',
+                response: {
+                    subtype: 'success',
+                    request_id: requestId,
+                    response: validResponse,
+                },
+            };
+            stdout2.write(`${JSON.stringify(response)}\n`);
+            const result = await initPromise;
+            expect(result).toEqual(validResponse);
+            protocol2.stop();
+        });
+        it('should reject rewind files response with invalid affected_files type', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 1000 });
+            protocol2.start();
+            const chunks2 = [];
+            stdin2.on('data', (chunk) => chunks2.push(chunk.toString()));
+            const rewindPromise = protocol2.sendRewindFiles('msg-123');
+            await new Promise((resolve) => setImmediate(resolve));
+            const sentMessage = JSON.parse(chunks2[0].trim());
+            const requestId = sentMessage.request_id;
+            const response = {
+                type: 'control_response',
+                response: {
+                    subtype: 'success',
+                    request_id: requestId,
+                    response: {
+                        affected_files: 123,
+                    },
+                },
+            };
+            stdout2.write(`${JSON.stringify(response)}\n`);
+            await expect(rewindPromise).rejects.toThrow('Invalid rewind files response');
+            protocol2.stop();
+        });
+        it('should accept valid rewind files response with affected_files', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 1000 });
+            protocol2.start();
+            const chunks2 = [];
+            stdin2.on('data', (chunk) => chunks2.push(chunk.toString()));
+            const rewindPromise = protocol2.sendRewindFiles('msg-123');
+            await new Promise((resolve) => setImmediate(resolve));
+            const sentMessage = JSON.parse(chunks2[0].trim());
+            const requestId = sentMessage.request_id;
+            const validResponse = {
+                affected_files: ['/path/to/file1.txt', '/path/to/file2.txt'],
+            };
+            const response = {
+                type: 'control_response',
+                response: {
+                    subtype: 'success',
+                    request_id: requestId,
+                    response: validResponse,
+                },
+            };
+            stdout2.write(`${JSON.stringify(response)}\n`);
+            const result = await rewindPromise;
+            expect(result).toEqual(validResponse);
+            protocol2.stop();
+        });
+        it('should accept valid rewind files response without affected_files', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2, { requestTimeout: 1000 });
+            protocol2.start();
+            const chunks2 = [];
+            stdin2.on('data', (chunk) => chunks2.push(chunk.toString()));
+            const rewindPromise = protocol2.sendRewindFiles('msg-123');
+            await new Promise((resolve) => setImmediate(resolve));
+            const sentMessage = JSON.parse(chunks2[0].trim());
+            const requestId = sentMessage.request_id;
+            const validResponse = {};
+            const response = {
+                type: 'control_response',
+                response: {
+                    subtype: 'success',
+                    request_id: requestId,
+                    response: validResponse,
+                },
+            };
+            stdout2.write(`${JSON.stringify(response)}\n`);
+            const result = await rewindPromise;
+            expect(result).toEqual(validResponse);
+            protocol2.stop();
+        });
+    });
+    describe('sendRaw error handling', () => {
+        it('should reject sendInitialize immediately if sendRaw fails', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2);
+            const initPromise = protocol2.sendInitialize();
+            await expect(initPromise).rejects.toThrow('Protocol stopped');
+        });
+        it('should reject sendRewindFiles immediately if sendRaw fails', async () => {
+            const stdin2 = new PassThrough();
+            const stdout2 = new PassThrough();
+            const protocol2 = new ClaudeProtocol(stdin2, stdout2);
+            const rewindPromise = protocol2.sendRewindFiles('msg-123');
+            await expect(rewindPromise).rejects.toThrow('Protocol stopped');
+        });
+        it('should cleanup timeout when sendInitialize fails immediately', async () => {
+            vi.useFakeTimers();
+            try {
+                const stdin2 = new PassThrough();
+                const stdout2 = new PassThrough();
+                const protocol2 = new ClaudeProtocol(stdin2, stdout2);
+                const initPromise = protocol2.sendInitialize();
+                await expect(initPromise).rejects.toThrow('Protocol stopped');
+                vi.advanceTimersByTime(120_000);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('should cleanup timeout when sendRewindFiles fails immediately', async () => {
+            vi.useFakeTimers();
+            try {
+                const stdin2 = new PassThrough();
+                const stdout2 = new PassThrough();
+                const protocol2 = new ClaudeProtocol(stdin2, stdout2);
+                const rewindPromise = protocol2.sendRewindFiles('msg-123');
+                await expect(rewindPromise).rejects.toThrow('Protocol stopped');
+                vi.advanceTimersByTime(120_000);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle messages with special characters', async () => {
+            const messagePromise = new Promise((resolve) => {
+                protocol.on('message', resolve);
+            });
+            const msg = {
+                type: 'assistant',
+                session_id: 'test',
+                message: {
+                    role: 'assistant',
+                    content: [{ type: 'text', text: 'Hello "world" with\nnewlines\tand\ttabs' }],
+                },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            const received = await messagePromise;
+            expect(received).toEqual(msg);
+        });
+        it('should handle messages with unicode', async () => {
+            const messagePromise = new Promise((resolve) => {
+                protocol.on('message', resolve);
+            });
+            const msg = {
+                type: 'assistant',
+                session_id: 'test',
+                message: {
+                    role: 'assistant',
+                    content: [{ type: 'text', text: 'Hello World!' }],
+                },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            const received = await messagePromise;
+            expect(received).toEqual(msg);
+        });
+        it('should handle very long messages', async () => {
+            const messagePromise = new Promise((resolve) => {
+                protocol.on('message', resolve);
+            });
+            const longText = 'x'.repeat(100_000);
+            const msg = {
+                type: 'assistant',
+                session_id: 'test',
+                message: {
+                    role: 'assistant',
+                    content: [{ type: 'text', text: longText }],
+                },
+            };
+            stdout.write(`${JSON.stringify(msg)}\n`);
+            const received = (await messagePromise);
+            const content = received.message.content;
+            expect(content[0].text).toBe(longText);
+        });
+    });
+});
+//# sourceMappingURL=protocol.test.js.map