factory-factory 0.2.8 → 0.3.0

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

@@ -1,848 +0,0 @@
-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