repoburg 1.3.202 → 1.3.204

package/agent-pane/backend/src/claude/claude-provider.test.ts

@@ -1,455 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// Mock the SDK query function
-vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
-  query: vi.fn(),
-}));
-
-import { query } from '@anthropic-ai/claude-agent-sdk';
-
-// Capture broadcasts without touching a real WebSocket server.
-const captured: Array<{ event: string; data: unknown }> = [];
-vi.mock('../ws/index.ts', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>;
-  return {
-    ...actual,
-    broadcast: vi.fn((event: string, data: unknown) => {
-      captured.push({ event, data });
-    }),
-  };
-});
-
-// Import after mocks are set up
-import { claudeProvider, clearAllThreads, handleResultMessage, handleMessage } from './claude-provider.ts';
-import { initDb } from '../db/index.ts';
-import type Database from 'better-sqlite3';
-import type { ClaudeSessionEntry } from './claude-types.ts';
-
-describe('claudeProvider', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    clearAllThreads();
-    captured.length = 0;
-  });
-
-  it('implements all RuntimeProvider methods', () => {
-    expect(claudeProvider.startTurn).toBeTypeOf('function');
-    expect(claudeProvider.interruptTurn).toBeTypeOf('function');
-    expect(claudeProvider.clearThread).toBeTypeOf('function');
-    expect(claudeProvider.clearAllThreads).toBeTypeOf('function');
-    expect(claudeProvider.getModels).toBeTypeOf('function');
-    expect(claudeProvider.shutdown).toBeTypeOf('function');
-  });
-
-  it('getModels returns an array', async () => {
-    const mockQuery = {
-      initializationResult: vi.fn().mockResolvedValue({ models: [] }),
-      close: vi.fn(),
-      [Symbol.asyncIterator]: async function* () {},
-    };
-    vi.mocked(query).mockReturnValue(mockQuery as never);
-
-    const models = await claudeProvider.getModels();
-    expect(Array.isArray(models)).toBe(true);
-  });
-
-  it('getModels returns empty array on error', async () => {
-    vi.mocked(query).mockImplementation(() => {
-      throw new Error('SDK not available');
-    });
-
-    const models = await claudeProvider.getModels();
-    expect(models).toEqual([]);
-  });
-
-  it('clearThread does not throw for unknown session', () => {
-    expect(() => claudeProvider.clearThread('unknown-id')).not.toThrow();
-  });
-
-  it('clearAllThreads does not throw when empty', () => {
-    expect(() => clearAllThreads()).not.toThrow();
-  });
-
-  it('interruptTurn returns false for unknown session', async () => {
-    const result = await claudeProvider.interruptTurn('unknown-id');
-    expect(result).toBe(false);
-  });
-
-  it('shutdown does not throw', async () => {
-    await expect(claudeProvider.shutdown()).resolves.not.toThrow();
-  });
-});
-
-/** Build a mock ClaudeSessionEntry whose query.getContextUsage() returns the given snapshot. */
-function makeEntry(getContextUsage: ReturnType<typeof vi.fn>): ClaudeSessionEntry {
-  return {
-    query: {
-      getContextUsage,
-      interrupt: vi.fn(),
-      setModel: vi.fn(),
-      close: vi.fn(),
-      stopTask: vi.fn(),
-      initializationResult: vi.fn(),
-      [Symbol.asyncIterator]: async function* () {},
-    } as never,
-    sessionId: 'cs_test',
-    turnId: null,
-    cwd: '/test',
-    promptQueue: { push: vi.fn(), close: vi.fn() } as never,
-    messageLoop: null,
-  };
-}
-
-/** Build a result/success SDK message with the given (accumulated) token usage. */
-function makeResultMessage(usage: {
-  input_tokens: number;
-  cache_read_input_tokens: number;
-  cache_creation_input_tokens: number;
-  output_tokens: number;
-}): unknown {
-  return {
-    type: 'result',
-    subtype: 'success',
-    usage,
-    modelUsage: {},
-    result: 'done',
-    is_error: false,
-    num_turns: 1,
-    stop_reason: 'end_turn',
-    duration_ms: 100,
-    duration_api_ms: 100,
-    total_cost_usd: 0,
-    permission_denials: [],
-    uuid: 'u1',
-    session_id: 'cs_test',
-  };
-}
-
-describe('handleResultMessage — context-window usage', () => {
-  let db: Database.Database;
-
-  beforeEach(() => {
-    db = initDb(':memory:');
-    // Session with a non-null title so syncThreadTitle short-circuits (no title query).
-    db.prepare(
-      `INSERT INTO sessions (id, title, runtime_type, status, is_running, lifecycle, created_at, updated_at)
-       VALUES ('s1', 'Test', 'claude', 'running', 1, 'working', ?, ?)`,
-    ).run(new Date().toISOString(), new Date().toISOString());
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, status, created_at, updated_at)
-       VALUES ('t1', 's1', 'hi', 'running', ?, ?)`,
-    ).run(new Date().toISOString(), new Date().toISOString());
-    captured.length = 0;
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  it('uses SDK getContextUsage() real fill, NOT the accumulated result.usage sum', async () => {
-    // Old buggy behavior: result.usage sums to 800K (accumulated). getContextUsage reports the real 130K.
-    const getContextUsage = vi.fn().mockResolvedValue({
-      totalTokens: 130000,
-      maxTokens: 1000000,
-      rawMaxTokens: 1000000,
-      percentage: 13,
-      categories: [],
-      gridRows: [],
-      model: 'claude-sonnet',
-      memoryFiles: [],
-      mcpTools: [],
-    });
-    const entry = makeEntry(getContextUsage);
-
-    await handleResultMessage(
-      makeResultMessage({
-        input_tokens: 300000,
-        cache_read_input_tokens: 400000,
-        cache_creation_input_tokens: 100000, // sum = 800K (the wrong accumulated value)
-        output_tokens: 500,
-      }) as never,
-      's1',
-      't1',
-      entry,
-      db,
-    );
-
-    // turn:contextUsage must carry the SDK's real fill (130K), not the 800K sum.
-    const ctx = captured.find((b) => b.event === 'turn:contextUsage');
-    expect(ctx).toBeDefined();
-    expect((ctx!.data as { totalTokens: number }).totalTokens).toBe(130000);
-    expect((ctx!.data as { contextWindow: number }).contextWindow).toBe(1000000);
-    expect((ctx!.data as { percentage: number }).percentage).toBe(13);
-
-    // Persisted to the session row so the counter survives reload.
-    const row = db.prepare('SELECT context_usage FROM sessions WHERE id = ?').get('s1') as
-      | { context_usage: string | null }
-      | undefined;
-    expect(row?.context_usage).toBeTruthy();
-    expect(JSON.parse(row!.context_usage!).totalTokens).toBe(130000);
-  });
-
-  it('does not broadcast a bad value when getContextUsage() rejects', async () => {
-    const getContextUsage = vi.fn().mockRejectedValue(new Error('not available'));
-    const entry = makeEntry(getContextUsage);
-
-    await handleResultMessage(
-      makeResultMessage({
-        input_tokens: 100,
-        cache_read_input_tokens: 0,
-        cache_creation_input_tokens: 0,
-        output_tokens: 10,
-      }) as never,
-      's1',
-      't1',
-      entry,
-      db,
-    );
-
-    expect(captured.find((b) => b.event === 'turn:contextUsage')).toBeUndefined();
-    // The turn still completes normally.
-    expect(captured.find((b) => b.event === 'turn:completed')).toBeDefined();
-  });
-});
-
-describe('handleMessage — system/init must not corrupt main session for thread entries', () => {
-  let db: Database.Database;
-
-  beforeEach(() => {
-    db = initDb(':memory:');
-    // Main session whose Claude session id is 'main-session-1'.
-    db.prepare(
-      `INSERT INTO sessions (id, title, runtime_type, status, is_running, lifecycle, external_thread_id, created_at, updated_at)
-       VALUES ('s1', 'Test', 'claude', 'active', 0, 'working', 'main-session-1', ?, ?)`,
-    ).run(new Date().toISOString(), new Date().toISOString());
-    captured.length = 0;
-  });
-
-  afterEach(() => {
-    db.close();
-  });
-
-  /** Build a minimal entry for init-handler tests (getContextUsage unused). */
-  function makeInitEntry(): ClaudeSessionEntry {
-    return makeEntry(vi.fn());
-  }
-
-  /** Build a system/init SDK message with the given Claude session id. */
-  function makeInitMessage(claudeSessionId: string): unknown {
-    return { type: 'system', subtype: 'init', session_id: claudeSessionId };
-  }
-
-  it('thread entry: sets entry.sessionId but does NOT overwrite the main session external_thread_id', async () => {
-    // Regression: the system/init handler previously wrote the forked session's
-    // id into the MAIN session's external_thread_id for ALL entries, because
-    // handleMessage is always called with the main session id and entry.threadId
-    // was never populated. After a restart/rewind the main session would resume
-    // the fork and "remember" the thread's discussion.
-    const entry = makeInitEntry();
-    entry.threadId = 'thread-1';
-
-    await handleMessage(
-      makeInitMessage('fork-session-9') as never,
-      's1', // main session id — passed to handleMessage for ALL entries
-      't1',
-      entry,
-      db,
-    );
-
-    // entry.sessionId is captured (needed for Monitor output-path construction).
-    expect(entry.sessionId).toBe('fork-session-9');
-    // The main session's resume id is NOT corrupted with the fork's id.
-    const row = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(row?.external_thread_id).toBe('main-session-1');
-  });
-
-  it('main entry: still persists external_thread_id (preserves existing behavior)', async () => {
-    const entry = makeInitEntry();
-    entry.threadId = null; // main session entry (not a thread/fork)
-
-    await handleMessage(
-      makeInitMessage('fork-session-9') as never,
-      's1',
-      't1',
-      entry,
-      db,
-    );
-
-    expect(entry.sessionId).toBe('fork-session-9');
-    const row = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(row?.external_thread_id).toBe('fork-session-9');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// startTurn — thread fork isolation (BUG 1 + BUG 2 regression tests)
-// ---------------------------------------------------------------------------
-
-/** Build a mock `Query` whose async iterator yields the given SDK messages in
- *  order, then ends. getContextUsage resolves an empty snapshot (0/0) so the
- *  result/success handler completes the turn without emitting contextUsage. */
-function createClaudeQueryMock(messages: unknown[]): unknown {
-  return {
-    getContextUsage: vi.fn().mockResolvedValue({
-      totalTokens: 0, maxTokens: 0, rawMaxTokens: 0, percentage: 0,
-      categories: [], gridRows: [], model: '', memoryFiles: [], mcpTools: [],
-    }),
-    interrupt: vi.fn(),
-    setModel: vi.fn(),
-    close: vi.fn(),
-    stopTask: vi.fn(),
-    initializationResult: vi.fn(),
-    [Symbol.asyncIterator]: async function* () {
-      for (const m of messages) yield m;
-    },
-  };
-}
-
-/** A `system/init` SDK message carrying the given Claude session id. */
-function initMsg(claudeSessionId: string): unknown {
-  return { type: 'system', subtype: 'init', session_id: claudeSessionId };
-}
-
-/** A `result/success` SDK message that completes a turn. */
-function resultSuccessMsg(claudeSessionId: string): unknown {
-  return {
-    type: 'result', subtype: 'success',
-    usage: { input_tokens: 10, cache_read_input_tokens: 0, cache_creation_input_tokens: 0, output_tokens: 5 },
-    modelUsage: {}, result: 'done', is_error: false, num_turns: 1,
-    stop_reason: 'end_turn', duration_ms: 1, duration_api_ms: 1, total_cost_usd: 0,
-    permission_denials: [], uuid: 'u1', session_id: claudeSessionId,
-  };
-}
-
-/** Poll the DB until the given turn reaches the expected status. */
-async function waitForTurnStatus(db: Database.Database, turnId: string, status: string, timeoutMs = 2000): Promise<void> {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    const row = db.prepare('SELECT status FROM turns WHERE id = ?').get(turnId) as { status: string } | undefined;
-    if (row?.status === status) return;
-    await new Promise((r) => setTimeout(r, 10));
-  }
-  throw new Error(`turn ${turnId} did not reach status '${status}' within ${timeoutMs}ms`);
-}
-
-describe('startTurn — thread fork isolation', () => {
-  let db: Database.Database;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    clearAllThreads();
-    captured.length = 0;
-    db = initDb(':memory:');
-    // Main Claude session with a known resume id. Title set so syncThreadTitle
-    // short-circuits (no title-generation query).
-    db.prepare(
-      `INSERT INTO sessions (id, title, runtime_type, status, is_running, lifecycle, external_thread_id, created_at, updated_at)
-       VALUES ('s1', 'Test', 'claude', 'active', 0, 'working', 'main-1', ?, ?)`,
-    ).run(new Date().toISOString(), new Date().toISOString());
-  });
-
-  afterEach(() => {
-    clearAllThreads();
-    db.close();
-  });
-
-  it('main session resumes from its own persisted external_thread_id', async () => {
-    // Seed a MAIN turn (no thread_id).
-    const now = new Date().toISOString();
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, status, created_at, updated_at)
-       VALUES ('t1', 's1', 'hi', 'pending', ?, ?)`,
-    ).run(now, now);
-
-    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('main-1'), resultSuccessMsg('main-1')]) as never);
-
-    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as never;
-    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('t1') as never;
-    await claudeProvider.startTurn(session, turn);
-
-    await waitForTurnStatus(db, 't1', 'completed');
-
-    // The main session's query was started with resume = its persisted external_thread_id.
-    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
-    expect(opts.resume).toBe('main-1');
-  });
-
-  it('thread turn resumes from its OWN fork id and does NOT corrupt the main session (BUG 1 + BUG 2)', async () => {
-    const now = new Date().toISOString();
-    // Anchor turn + a discussion thread forked to 'fork-9'.
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, status, created_at, updated_at)
-       VALUES ('t1', 's1', 'hi', 'resp', 'completed', ?, ?)`,
-    ).run(now, now);
-    db.prepare(
-      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, external_thread_id, status, created_at, updated_at)
-       VALUES ('th1', 's1', 'i1', 't1', 0, 4, 'resp', 'fork-9', 'open', ?, ?)`,
-    ).run(now, now);
-    // Thread turn.
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, status, thread_id, created_at, updated_at)
-       VALUES ('tt1', 's1', 'discuss this', 'pending', 'th1', ?, ?)`,
-    ).run(now, now);
-
-    // The forked query emits init with the FORK's session id, then completes.
-    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fork-9'), resultSuccessMsg('fork-9')]) as never);
-
-    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as never;
-    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('tt1') as never;
-    await claudeProvider.startTurn(session, turn);
-
-    await waitForTurnStatus(db, 'tt1', 'completed');
-
-    // BUG 2: the thread resumed its OWN fork ('fork-9'), not the main session.
-    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
-    expect(opts.resume).toBe('fork-9');
-
-    // BUG 1: the main session's external_thread_id was NOT overwritten with the
-    // fork's id (the system/init handler skipped the DB write for thread entries).
-    const row = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(row?.external_thread_id).toBe('main-1');
-  });
-
-  it('thread turn with a FAILED fork starts a fresh isolated session (resume undefined), never the main session (BUG 2)', async () => {
-    const now = new Date().toISOString();
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, agent_response, status, created_at, updated_at)
-       VALUES ('t1', 's1', 'hi', 'resp', 'completed', ?, ?)`,
-    ).run(now, now);
-    // Thread with NO external_thread_id (fork failed / not created).
-    db.prepare(
-      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
-       VALUES ('th1', 's1', 'i1', 't1', 0, 4, 'resp', 'open', ?, ?)`,
-    ).run(now, now);
-    db.prepare(
-      `INSERT INTO turns (id, session_id, user_prompt, status, thread_id, created_at, updated_at)
-       VALUES ('tt1', 's1', 'discuss this', 'pending', 'th1', ?, ?)`,
-    ).run(now, now);
-
-    // Fresh session emits its own init id, then completes.
-    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fresh-1'), resultSuccessMsg('fresh-1')]) as never);
-
-    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as never;
-    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('tt1') as never;
-    await claudeProvider.startTurn(session, turn);
-
-    await waitForTurnStatus(db, 'tt1', 'completed');
-
-    // The thread started a FRESH session: no `resume` option (must NOT fall back
-    // to the main session's 'main-1').
-    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
-    expect(opts.resume).toBeUndefined();
-
-    // The main session is untouched.
-    const row = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
-      | { external_thread_id: string | null }
-      | undefined;
-    expect(row?.external_thread_id).toBe('main-1');
-  });
-});