@mseep/claudian 2.0.25

package/tests/unit/providers/claude/runtime/customSpawn.test.ts

@@ -0,0 +1,374 @@
+import type { SpawnOptions } from '@anthropic-ai/claude-agent-sdk';
+import { spawn } from 'child_process';
+
+import { createCustomSpawnFunction } from '@/providers/claude/runtime/customSpawn';
+import * as env from '@/utils/env';
+
+jest.mock('child_process', () => ({
+  spawn: jest.fn(),
+}));
+
+describe('createCustomSpawnFunction', () => {
+  const originalPlatform = process.platform;
+  const spawnMock = spawn as jest.MockedFunction<typeof spawn>;
+
+  afterEach(() => {
+    Object.defineProperty(process, 'platform', { value: originalPlatform });
+    jest.restoreAllMocks();
+    spawnMock.mockReset();
+  });
+
+  const createMockProcess = () => {
+    const stderr = { on: jest.fn() } as unknown as NodeJS.ReadableStream;
+    return {
+      stdin: {} as NodeJS.WritableStream,
+      stdout: {} as NodeJS.ReadableStream,
+      stderr,
+      pid: 12345,
+      killed: false,
+      exitCode: null,
+      kill: jest.fn(),
+      on: jest.fn(),
+      once: jest.fn(),
+      off: jest.fn(),
+    };
+  };
+
+  it('resolves node command to full path when available', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const findNodeExecutable = jest
+      .spyOn(env, 'findNodeExecutable')
+      .mockReturnValue('/custom/node');
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    const signal = new AbortController().signal;
+    const options: SpawnOptions = {
+      command: 'node',
+      args: ['cli.js'],
+      cwd: '/tmp',
+      env: {},
+      signal,
+    };
+
+    const result = spawnFn(options);
+
+    expect(findNodeExecutable).toHaveBeenCalledWith('/enhanced/path');
+    expect(spawnMock).toHaveBeenCalledWith('/custom/node', ['cli.js'], expect.objectContaining({
+      cwd: '/tmp',
+    }));
+    expect(result).toBe(mockProcess);
+  });
+
+  it('launches Node-backed script commands through node when SDK passes them directly', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const findNodeExecutable = jest
+      .spyOn(env, 'findNodeExecutable')
+      .mockReturnValue('/custom/node');
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    const signal = new AbortController().signal;
+    spawnFn({
+      command: '/npm/node_modules/@anthropic-ai/claude-code/cli-wrapper.cjs',
+      args: ['--output-format', 'stream-json'],
+      cwd: '/tmp',
+      env: {},
+      signal,
+    });
+
+    expect(findNodeExecutable).toHaveBeenCalledWith('/enhanced/path');
+    expect(spawnMock).toHaveBeenCalledWith(
+      '/custom/node',
+      ['/npm/node_modules/@anthropic-ai/claude-code/cli-wrapper.cjs', '--output-format', 'stream-json'],
+      expect.objectContaining({ cwd: '/tmp' })
+    );
+  });
+
+  it('falls back to node command for Node-backed scripts when node path resolution fails', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    jest.spyOn(env, 'findNodeExecutable').mockReturnValue(null);
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    spawnFn({
+      command: '/npm/node_modules/@anthropic-ai/claude-code/cli-wrapper.cjs',
+      args: ['--output-format', 'stream-json'],
+      cwd: '/tmp',
+      env: {},
+    } as SpawnOptions);
+
+    expect(spawnMock).toHaveBeenCalledWith(
+      'node',
+      ['/npm/node_modules/@anthropic-ai/claude-code/cli-wrapper.cjs', '--output-format', 'stream-json'],
+      expect.any(Object)
+    );
+  });
+
+  it('pipes stderr only when DEBUG_CLAUDE_AGENT_SDK is set', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    const signal = new AbortController().signal;
+    spawnFn({
+      command: 'node',
+      args: ['cli.js'],
+      cwd: '/tmp',
+      env: { DEBUG_CLAUDE_AGENT_SDK: '1' },
+      signal,
+    });
+
+    const spawnOptions = spawnMock.mock.calls[0][2];
+    expect(spawnOptions.stdio).toEqual(['pipe', 'pipe', 'pipe']);
+    expect(mockProcess.stderr?.on).toHaveBeenCalledWith('data', expect.any(Function));
+  });
+
+  it('ignores stderr when DEBUG_CLAUDE_AGENT_SDK is not set', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    const signal = new AbortController().signal;
+    spawnFn({
+      command: 'node',
+      args: ['cli.js'],
+      cwd: '/tmp',
+      env: {},
+      signal,
+    });
+
+    const spawnOptions = spawnMock.mock.calls[0][2];
+    expect(spawnOptions.stdio).toEqual(['pipe', 'pipe', 'ignore']);
+    expect(mockProcess.stderr?.on).not.toHaveBeenCalled();
+  });
+
+  it('throws when process streams are missing', () => {
+    const mockProcess = {
+      stdin: null,
+      stdout: null,
+      stderr: null,
+      killed: false,
+      exitCode: null,
+      kill: jest.fn(),
+      on: jest.fn(),
+      once: jest.fn(),
+      off: jest.fn(),
+    };
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    const signal = new AbortController().signal;
+
+    expect(() => spawnFn({
+      command: 'node',
+      args: ['cli.js'],
+      cwd: '/tmp',
+      env: {},
+      signal,
+    })).toThrow('Failed to create process streams');
+  });
+
+  it('falls back to original command when findNodeExecutable returns null', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    jest.spyOn(env, 'findNodeExecutable').mockReturnValue(null);
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    const signal = new AbortController().signal;
+    spawnFn({
+      command: 'node',
+      args: ['cli.js'],
+      cwd: '/tmp',
+      env: {},
+      signal,
+    });
+
+    // Should use 'node' as-is since findNodeExecutable returned null
+    expect(spawnMock).toHaveBeenCalledWith('node', ['cli.js'], expect.any(Object));
+  });
+
+  it('does not resolve non-node commands', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const findNodeExecutable = jest.spyOn(env, 'findNodeExecutable');
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    const signal = new AbortController().signal;
+    spawnFn({
+      command: 'python',
+      args: ['script.py'],
+      cwd: '/tmp',
+      env: {},
+      signal,
+    });
+
+    expect(findNodeExecutable).not.toHaveBeenCalled();
+    expect(spawnMock).toHaveBeenCalledWith('python', ['script.py'], expect.any(Object));
+  });
+
+  it('wraps manually configured Windows .cmd commands through cmd.exe', () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const findNodeExecutable = jest.spyOn(env, 'findNodeExecutable');
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    spawnFn({
+      command: 'C:\\Users\\R&D\\AppData\\Roaming\\npm\\claude.cmd',
+      args: ['--output-format', 'stream-json'],
+      cwd: 'C:\\Vault',
+      env: {},
+    } as SpawnOptions);
+
+    expect(findNodeExecutable).not.toHaveBeenCalled();
+    expect(spawnMock).toHaveBeenCalledWith(
+      process.env.ComSpec || process.env.comspec || 'cmd.exe',
+      ['/d', '/s', '/c', '""C:\\Users\\R&D\\AppData\\Roaming\\npm\\claude.cmd" --output-format stream-json"'],
+      expect.objectContaining({
+        cwd: 'C:\\Vault',
+        windowsHide: true,
+        windowsVerbatimArguments: true,
+      }),
+    );
+  });
+
+  it('kills the process tree when aborting manually configured Windows .cmd commands', () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    const mockProcess = createMockProcess();
+    const originalKill = mockProcess.kill;
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const controller = new AbortController();
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    spawnFn({
+      command: 'C:\\Users\\R&D\\AppData\\Roaming\\npm\\claude.cmd',
+      args: ['--output-format', 'stream-json'],
+      cwd: 'C:\\Vault',
+      env: {},
+      signal: controller.signal,
+    } as SpawnOptions);
+
+    controller.abort();
+
+    expect(spawnMock).toHaveBeenCalledWith(
+      'taskkill.exe',
+      ['/pid', '12345', '/t', '/f'],
+      expect.objectContaining({
+        stdio: 'ignore',
+        windowsHide: true,
+      }),
+    );
+    expect(originalKill).not.toHaveBeenCalled();
+  });
+
+  it('delegates returned Windows .cmd process kill to process-tree termination', () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    const mockProcess = createMockProcess();
+    const originalKill = mockProcess.kill;
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    const result = spawnFn({
+      command: 'C:\\Users\\R&D\\AppData\\Roaming\\npm\\claude.cmd',
+      args: ['--output-format', 'stream-json'],
+      cwd: 'C:\\Vault',
+      env: {},
+    } as SpawnOptions);
+
+    expect(result).toBe(mockProcess);
+    expect(result.kill).not.toBe(originalKill);
+
+    result.kill('SIGKILL');
+
+    expect(spawnMock).toHaveBeenCalledWith(
+      'taskkill.exe',
+      ['/pid', '12345', '/t', '/f'],
+      expect.objectContaining({
+        stdio: 'ignore',
+        windowsHide: true,
+      }),
+    );
+    expect(originalKill).not.toHaveBeenCalled();
+  });
+
+  it('does not pass signal to spawn options', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    const signal = new AbortController().signal;
+    spawnFn({
+      command: 'node',
+      args: ['cli.js'],
+      cwd: '/tmp',
+      env: {},
+      signal,
+    });
+
+    const spawnOptions = spawnMock.mock.calls[0][2];
+    expect(spawnOptions).not.toHaveProperty('signal');
+  });
+
+  it('kills child immediately when signal is already aborted', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const controller = new AbortController();
+    controller.abort();
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    spawnFn({
+      command: 'node',
+      args: ['cli.js'],
+      cwd: '/tmp',
+      env: {},
+      signal: controller.signal,
+    });
+
+    expect(mockProcess.kill).toHaveBeenCalled();
+  });
+
+  it('kills child when signal aborts after spawn', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const controller = new AbortController();
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    spawnFn({
+      command: 'node',
+      args: ['cli.js'],
+      cwd: '/tmp',
+      env: {},
+      signal: controller.signal,
+    });
+
+    expect(mockProcess.kill).not.toHaveBeenCalled();
+
+    controller.abort();
+
+    expect(mockProcess.kill).toHaveBeenCalled();
+  });
+
+  it('does not kill child when signal is not provided', () => {
+    const mockProcess = createMockProcess();
+    spawnMock.mockReturnValue(mockProcess as unknown as ReturnType<typeof spawn>);
+
+    const spawnFn = createCustomSpawnFunction('/enhanced/path');
+    spawnFn({
+      command: 'node',
+      args: ['cli.js'],
+      cwd: '/tmp',
+      env: {},
+    } as SpawnOptions);
+
+    expect(mockProcess.kill).not.toHaveBeenCalled();
+  });
+});

package/tests/unit/providers/claude/runtime/index.test.ts

@@ -0,0 +1,13 @@
+import { ClaudianService } from '@/providers/claude/runtime/ClaudeChatRuntime';
+import { MessageChannel } from '@/providers/claude/runtime/ClaudeMessageChannel';
+import { QueryOptionsBuilder } from '@/providers/claude/runtime/ClaudeQueryOptionsBuilder';
+import { SessionManager } from '@/providers/claude/runtime/ClaudeSessionManager';
+
+describe('core/agent index', () => {
+  it('imports resolve to the provider-owned runtime symbols', () => {
+    expect(ClaudianService).toBeDefined();
+    expect(MessageChannel).toBeDefined();
+    expect(QueryOptionsBuilder).toBeDefined();
+    expect(SessionManager).toBeDefined();
+  });
+});

package/tests/unit/providers/claude/runtime/types.test.ts

@@ -0,0 +1,190 @@
+import { buildSDKMessage } from '@test/helpers/sdkMessages';
+
+import { createResponseHandler, isTurnCompleteMessage } from '@/providers/claude/runtime/types';
+
+describe('isTurnCompleteMessage', () => {
+  it('returns true for result message', () => {
+    const message = buildSDKMessage({ type: 'result' });
+    expect(isTurnCompleteMessage(message)).toBe(true);
+  });
+
+  it('returns false for assistant message', () => {
+    const message = buildSDKMessage({ type: 'assistant' });
+    expect(isTurnCompleteMessage(message)).toBe(false);
+  });
+
+  it('returns false for user message', () => {
+    const message = buildSDKMessage({ type: 'user' });
+    expect(isTurnCompleteMessage(message)).toBe(false);
+  });
+
+  it('returns false for system message', () => {
+    const message = buildSDKMessage({ type: 'system', subtype: 'status' });
+    expect(isTurnCompleteMessage(message)).toBe(false);
+  });
+});
+
+describe('createResponseHandler', () => {
+  it('creates a handler with initial state values as false', () => {
+    const handler = createResponseHandler({
+      id: 'test-handler',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    expect(handler.sawStreamText).toBe(false);
+    expect(handler.sawStreamThinking).toBe(false);
+    expect(handler.sawAnyChunk).toBe(false);
+  });
+
+  it('markStreamTextSeen sets sawStreamText to true', () => {
+    const handler = createResponseHandler({
+      id: 'test-handler',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    expect(handler.sawStreamText).toBe(false);
+    handler.markStreamTextSeen();
+    expect(handler.sawStreamText).toBe(true);
+  });
+
+  it('resetStreamText sets sawStreamText back to false', () => {
+    const handler = createResponseHandler({
+      id: 'test-handler',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    handler.markStreamTextSeen();
+    expect(handler.sawStreamText).toBe(true);
+    handler.resetStreamText();
+    expect(handler.sawStreamText).toBe(false);
+  });
+
+  it('markStreamThinkingSeen sets sawStreamThinking to true', () => {
+    const handler = createResponseHandler({
+      id: 'test-handler',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    expect(handler.sawStreamThinking).toBe(false);
+    handler.markStreamThinkingSeen();
+    expect(handler.sawStreamThinking).toBe(true);
+  });
+
+  it('resetStreamThinking sets sawStreamThinking back to false', () => {
+    const handler = createResponseHandler({
+      id: 'test-handler',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    handler.markStreamThinkingSeen();
+    expect(handler.sawStreamThinking).toBe(true);
+    handler.resetStreamThinking();
+    expect(handler.sawStreamThinking).toBe(false);
+  });
+
+  it('markChunkSeen sets sawAnyChunk to true', () => {
+    const handler = createResponseHandler({
+      id: 'test-handler',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    expect(handler.sawAnyChunk).toBe(false);
+    handler.markChunkSeen();
+    expect(handler.sawAnyChunk).toBe(true);
+  });
+
+  it('preserves id from options', () => {
+    const handler = createResponseHandler({
+      id: 'my-unique-id',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    expect(handler.id).toBe('my-unique-id');
+  });
+
+  it('calls onChunk callback when invoked', () => {
+    const onChunk = jest.fn();
+    const handler = createResponseHandler({
+      id: 'test-handler',
+      onChunk,
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    const chunk = { type: 'text' as const, content: 'hello' };
+    handler.onChunk(chunk);
+
+    expect(onChunk).toHaveBeenCalledWith(chunk);
+  });
+
+  it('calls onDone callback when invoked', () => {
+    const onDone = jest.fn();
+    const handler = createResponseHandler({
+      id: 'test-handler',
+      onChunk: jest.fn(),
+      onDone,
+      onError: jest.fn(),
+    });
+
+    handler.onDone();
+
+    expect(onDone).toHaveBeenCalled();
+  });
+
+  it('calls onError callback when invoked', () => {
+    const onError = jest.fn();
+    const handler = createResponseHandler({
+      id: 'test-handler',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError,
+    });
+
+    const error = new Error('test error');
+    handler.onError(error);
+
+    expect(onError).toHaveBeenCalledWith(error);
+  });
+
+  it('maintains independent state between handlers', () => {
+    const handler1 = createResponseHandler({
+      id: 'handler-1',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    const handler2 = createResponseHandler({
+      id: 'handler-2',
+      onChunk: jest.fn(),
+      onDone: jest.fn(),
+      onError: jest.fn(),
+    });
+
+    handler1.markStreamTextSeen();
+    handler1.markStreamThinkingSeen();
+    handler1.markChunkSeen();
+
+    // handler2 should not be affected
+    expect(handler1.sawStreamText).toBe(true);
+    expect(handler1.sawStreamThinking).toBe(true);
+    expect(handler1.sawAnyChunk).toBe(true);
+    expect(handler2.sawStreamText).toBe(false);
+    expect(handler2.sawStreamThinking).toBe(false);
+    expect(handler2.sawAnyChunk).toBe(false);
+  });
+});

package/tests/unit/providers/claude/sdk/typeGuards.test.ts

@@ -0,0 +1,50 @@
+import { isSessionInitEvent, isStreamChunk } from '@/providers/claude/sdk/typeGuards';
+import type { TransformEvent } from '@/providers/claude/sdk/types';
+
+describe('isSessionInitEvent', () => {
+  it('should return true for session_init events', () => {
+    const event: TransformEvent = { type: 'session_init', sessionId: 'abc-123' };
+
+    expect(isSessionInitEvent(event)).toBe(true);
+  });
+
+  it('should return true for session_init with agents', () => {
+    const event: TransformEvent = { type: 'session_init', sessionId: 'abc', agents: ['agent1'] };
+
+    expect(isSessionInitEvent(event)).toBe(true);
+  });
+
+  it('should return false for stream chunk events', () => {
+    const textChunk: TransformEvent = { type: 'text', content: 'hello' };
+    const doneChunk: TransformEvent = { type: 'done' };
+    const toolUseChunk: TransformEvent = { type: 'tool_use', id: 't1', name: 'Read', input: {} };
+
+    expect(isSessionInitEvent(textChunk)).toBe(false);
+    expect(isSessionInitEvent(doneChunk)).toBe(false);
+    expect(isSessionInitEvent(toolUseChunk)).toBe(false);
+  });
+});
+
+describe('isStreamChunk', () => {
+  it('should return true for stream chunk events', () => {
+    const textChunk: TransformEvent = { type: 'text', content: 'hello' };
+    const doneChunk: TransformEvent = { type: 'done' };
+    const errorChunk: TransformEvent = { type: 'error', content: 'oops' };
+    const blockedChunk: TransformEvent = { type: 'notice', content: 'blocked cmd', level: 'warning' };
+    const toolUseChunk: TransformEvent = { type: 'tool_use', id: 't1', name: 'Read', input: {} };
+    const toolResultChunk: TransformEvent = { type: 'tool_result', id: 't1', content: 'result' };
+
+    expect(isStreamChunk(textChunk)).toBe(true);
+    expect(isStreamChunk(doneChunk)).toBe(true);
+    expect(isStreamChunk(errorChunk)).toBe(true);
+    expect(isStreamChunk(blockedChunk)).toBe(true);
+    expect(isStreamChunk(toolUseChunk)).toBe(true);
+    expect(isStreamChunk(toolResultChunk)).toBe(true);
+  });
+
+  it('should return false for session_init events', () => {
+    const event: TransformEvent = { type: 'session_init', sessionId: 'abc-123' };
+
+    expect(isStreamChunk(event)).toBe(false);
+  });
+});