repoburg 1.3.198 → 1.3.201

package/agent-pane/backend/src/integration/threads-claude-fork.test.ts

@@ -0,0 +1,241 @@
+/**
+ * Integration test: discussion threads — Claude fork isolation (BUG 1 + BUG 2).
+ *
+ * Exercises the REAL claudeProvider + REAL thread routes with a mocked Claude
+ * SDK (`query` + `forkSession`). Verifies that creating a Discuss thread forks
+ * the main session, stores the fork id on the thread row, and never corrupts
+ * the main session's `external_thread_id`; and that a failed fork starts a
+ * fresh isolated session instead of resuming (and contaminating) the main
+ * session.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import type Database from 'better-sqlite3';
+import { clearBroadcasts, capturedBroadcasts } from './helpers/ws-capture.ts';
+import type { TestApp } from './helpers/test-app.ts';
+
+// Mock the Claude SDK — both the query factory and forkSession.
+vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
+  query: vi.fn(),
+  forkSession: vi.fn(),
+}));
+
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      capturedBroadcasts.push({ event, data });
+    }),
+  };
+});
+
+// Import after mocks are set up.
+import { query, forkSession } from '@anthropic-ai/claude-agent-sdk';
+import { clearAllThreads } from '../claude/claude-provider.ts';
+const { getDb } = await import('../db/index.ts');
+const { createTestApp, insertTestSession, waitForTurn } = await import('./helpers/test-app.ts');
+
+// ---------------------------------------------------------------------------
+// Mock helpers
+// ---------------------------------------------------------------------------
+
+/** 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,
+  };
+}
+
+describe('Integration: discussion threads — Claude fork isolation', () => {
+  let testApp: TestApp;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    clearAllThreads();
+    clearBroadcasts();
+    testApp = await createTestApp();
+  });
+
+  afterEach(async () => {
+    clearAllThreads();
+    await testApp.cleanup();
+  });
+
+  /** Seed a Claude session + anchor turn/item, ready for a thread creation. */
+  function seedSession(db: Database.Database): void {
+    insertTestSession(db, 's1', { runtime_type: 'claude', external_thread_id: 'main-1', title: 'Test' });
+    const now = '2025-01-01T00:00:00Z';
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, agent_response, status, external_turn_id, created_at, updated_at)
+       VALUES ('t1', 's1', 'prompt', 'response', 'completed', 'msg-uuid-1', ?, ?)`,
+    ).run(now, now);
+    db.prepare(
+      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+       VALUES ('i1', 't1', 'ext1', 'agent_message', ?, 'completed', ?, ?)`,
+    ).run(JSON.stringify({ text: 'Some text to discuss' }), now, now);
+  }
+
+  /** The shared thread-creation POST payload. */
+  const threadPayload = {
+    itemId: 'i1',
+    turnId: 't1',
+    startOffset: 0,
+    endOffset: 10,
+    selectedText: 'Some text ',
+    message: 'What does this mean?',
+  };
+
+  it('successful fork: stores fork id, resumes the fork, does NOT corrupt the main session (BUG 1 + BUG 2)', async () => {
+    const db: Database.Database = getDb();
+    seedSession(db);
+
+    // forkSession returns a new forked session id.
+    vi.mocked(forkSession).mockResolvedValue({ sessionId: 'fork-9' } as never);
+    // The forked query emits init with the FORK's id, then completes the turn.
+    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fork-9'), resultSuccessMsg('fork-9')]) as never);
+
+    const res = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions/s1/threads',
+      payload: threadPayload,
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    const threadId = body.thread.id as string;
+    const turnId = body.turn.id as string;
+
+    // forkSession was called with the MAIN session id + the anchor turn's message UUID.
+    expect(vi.mocked(forkSession).mock.calls[0][0]).toBe('main-1');
+    expect((vi.mocked(forkSession).mock.calls[0][1] as { upToMessageId?: string }).upToMessageId).toBe('msg-uuid-1');
+
+    // The fork id is stored on the THREAD row, not the main session.
+    const threadRow = db.prepare('SELECT external_thread_id FROM discussion_threads WHERE id = ?').get(threadId) as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(threadRow?.external_thread_id).toBe('fork-9');
+
+    // Wait for the thread turn to complete, then assert the main session is intact.
+    await waitForTurn(db, turnId);
+
+    // BUG 2: the thread turn 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.
+    const sessionRow = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(sessionRow?.external_thread_id).toBe('main-1');
+
+    // thread:created was broadcast.
+    expect(capturedBroadcasts.find((b) => b.event === 'thread:created')).toBeDefined();
+  });
+
+  it('failed fork (null): thread still created, starts a FRESH session (resume undefined), main session untouched (BUG 2)', async () => {
+    const db: Database.Database = getDb();
+    seedSession(db);
+
+    // forkSession returns null (e.g. no main session to fork from, or SDK refused).
+    vi.mocked(forkSession).mockResolvedValue(null as never);
+    // The fresh isolated session emits its own init id, then completes.
+    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fresh-1'), resultSuccessMsg('fresh-1')]) as never);
+
+    const res = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions/s1/threads',
+      payload: threadPayload,
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    const threadId = body.thread.id as string;
+    const turnId = body.turn.id as string;
+
+    // The thread row has NO fork id.
+    const threadRow = db.prepare('SELECT external_thread_id FROM discussion_threads WHERE id = ?').get(threadId) as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(threadRow?.external_thread_id).toBeNull();
+
+    await waitForTurn(db, turnId);
+
+    // BUG 2: the thread started a FRESH session — no `resume` option — and did
+    // 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 sessionRow = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(sessionRow?.external_thread_id).toBe('main-1');
+  });
+
+  it('failed fork (throws): caught, thread still created, main session untouched (BUG 2)', async () => {
+    const db: Database.Database = getDb();
+    seedSession(db);
+
+    // forkSession throws — the route must catch it and still create the thread.
+    vi.mocked(forkSession).mockRejectedValue(new Error('boom') as never);
+    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fresh-2'), resultSuccessMsg('fresh-2')]) as never);
+
+    const res = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions/s1/threads',
+      payload: threadPayload,
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    const threadId = body.thread.id as string;
+    const turnId = body.turn.id as string;
+
+    // The thread row has NO fork id (fork threw before storing anything).
+    const threadRow = db.prepare('SELECT external_thread_id FROM discussion_threads WHERE id = ?').get(threadId) as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(threadRow?.external_thread_id).toBeNull();
+
+    await waitForTurn(db, turnId);
+
+    // The thread started a fresh isolated session (no resume), not the main session.
+    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
+    expect(opts.resume).toBeUndefined();
+
+    const sessionRow = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(sessionRow?.external_thread_id).toBe('main-1');
+  });
+});

package/agent-pane/backend/src/providers/index.ts

@@ -7,8 +7,10 @@
 
 import { codexProvider } from '../codex/codex-provider.ts';
 import { claudeProvider } from '../claude/claude-provider.ts';
+import { repoburgProvider } from '../repoburg/repoburg-provider.ts';
 import { registerProvider } from './registry.ts';
 
 // Register built-in providers
 registerProvider('codex', codexProvider);
-registerProvider('claude', claudeProvider);
+registerProvider('claude', claudeProvider);
+registerProvider('repoburg', repoburgProvider);

package/agent-pane/backend/src/repoburg/action-mapping.ts

@@ -0,0 +1,216 @@
+/**
+ * Shared mapping helpers for the repoburg provider: repoburg AIAction →
+ * agent-pane item shapes, DB item helpers, and usage mapping.
+ * Used by both the provider (turn orchestration) and the turn projector
+ * (message-stream projection).
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import type Database from 'better-sqlite3';
+import { broadcast } from '../ws/index.ts';
+import type { Item, ItemStatus } from '../db/schema.ts';
+import type { RepoburgAction } from './repoburg-client.ts';
+
+/** Safely parse a JSON string field from an action row. */
+export function parseJsonArgs(raw: string | null | undefined): Record<string, unknown> | null {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === 'object' && parsed !== null ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Map a repoburg AIAction (+ its first execution log) to an agent-pane item
+ *  shape. Returns null for actions that carry no displayable content
+ *  (final/html_final — their text is part of the LLM response). */
+export function mapActionToItem(
+  action: RepoburgAction,
+): { type: Item['type']; data: Record<string, unknown>; status: ItemStatus } | null {
+  const failed = action.status === 'EXECUTION_FAILED';
+  const status: ItemStatus = failed ? 'failed' : 'completed';
+  const log = action.executionLogs?.[0];
+  const output = log?.output ?? '';
+  const errorMsg = log?.error_message ?? '';
+
+  switch (action.action_type) {
+    case 'create_file':
+    case 'overwrite_file':
+    case 'patch':
+    case 'quick_edit':
+    case 'apply_diff':
+    case 'write_todo':
+    case 'delete_file': {
+      const kind =
+        action.action_type === 'create_file'
+          ? 'add'
+          : action.action_type === 'delete_file'
+            ? 'delete'
+            : 'modify';
+      return {
+        type: 'file_change',
+        data: { changes: [{ path: action.file_path ?? '', kind }], status },
+        status,
+      };
+    }
+
+    case 'run_command':
+    case 'execute_code':
+      return {
+        type: 'command_execution',
+        data: {
+          command: action.command_string ?? action.action_type,
+          aggregated_output: output,
+          exit_code: failed ? 1 : 0,
+          status,
+        },
+        status,
+      };
+
+    case 'invoke_subagent': {
+      const args = parseJsonArgs(action.arguments);
+      return {
+        type: 'mcp_tool_call',
+        data: {
+          server: null,
+          tool: 'Agent',
+          arguments: {
+            description: (args?.agent_name as string) ?? (args?.agentName as string) ?? 'Subagent',
+            prompt: (args?.prompt as string) ?? '',
+          },
+          result: output ? [{ type: 'text', text: output }] : null,
+          error: failed ? errorMsg || 'Sub-agent failed' : null,
+          status,
+        },
+        status,
+      };
+    }
+
+    case 'web_search': {
+      const args = parseJsonArgs(action.arguments);
+      return { type: 'web_search', data: { query: (args?.query as string) ?? '' }, status };
+    }
+
+    case 'final':
+    case 'html_final':
+    case 'ask_user':
+      // Their text is part of the LLM response — no separate item.
+      return null;
+
+    default: {
+      // MCP tools (serverName__toolName) and remaining built-ins → generic tool call.
+      const isMcp = !!(action.server_name && action.tool_name);
+      return {
+        type: 'mcp_tool_call',
+        data: {
+          server: isMcp ? action.server_name : null,
+          tool: isMcp ? action.tool_name : action.action_type,
+          arguments: parseJsonArgs(action.arguments),
+          result: output ? [{ type: 'text', text: output }] : null,
+          error: failed ? errorMsg || 'Action failed' : null,
+          status,
+        },
+        status,
+      };
+    }
+  }
+}
+
+/** Map repoburg token counts to the agent-pane TokenUsage shape. */
+export function mapUsage(u: {
+  input: number;
+  cached: number;
+  output: number;
+}): {
+  input_tokens: number;
+  cached_input_tokens: number;
+  cache_write_input_tokens: number;
+  output_tokens: number;
+  reasoning_output_tokens: number;
+} {
+  return {
+    input_tokens: u.input,
+    cached_input_tokens: u.cached,
+    cache_write_input_tokens: 0,
+    output_tokens: u.output,
+    reasoning_output_tokens: 0,
+  };
+}
+
+/** Update the running state and status of a session. */
+export function setSessionStatus(
+  db: Database.Database,
+  sessionId: string,
+  isRunning: 0 | 1,
+  status: string,
+  now: string,
+  hasUnreviewed = false,
+): void {
+  if (hasUnreviewed) {
+    db.prepare('UPDATE sessions SET is_running = ?, status = ?, has_unreviewed = 1, updated_at = ? WHERE id = ?').run(
+      isRunning,
+      status,
+      now,
+      sessionId,
+    );
+  } else {
+    db.prepare('UPDATE sessions SET is_running = ?, status = ?, updated_at = ? WHERE id = ?').run(
+      isRunning,
+      status,
+      now,
+      sessionId,
+    );
+  }
+}
+
+/** Insert an item row and broadcast it. Returns the created item. */
+export function insertItem(
+  db: Database.Database,
+  sessionId: string,
+  turnId: string,
+  externalId: string,
+  type: Item['type'],
+  data: Record<string, unknown>,
+  status: ItemStatus,
+  broadcastEvent: 'item:started' | 'item:completed',
+): Item {
+  const now = new Date().toISOString();
+  const itemId = uuidv4();
+  db.prepare(
+    'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+  ).run(itemId, turnId, externalId, type, JSON.stringify(data), status, now, now);
+
+  const item: Item = {
+    id: itemId,
+    turn_id: turnId,
+    external_item_id: externalId,
+    type,
+    data,
+    status,
+    created_at: now,
+    updated_at: now,
+  };
+  broadcast(broadcastEvent, { sessionId, turnId, item });
+  return item;
+}
+
+/** Update an item's data + status and broadcast the completed item. */
+export function completeItem(
+  db: Database.Database,
+  sessionId: string,
+  turnId: string,
+  item: Item,
+  data: Record<string, unknown>,
+  status: ItemStatus,
+): void {
+  const now = new Date().toISOString();
+  db.prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE id = ?').run(
+    JSON.stringify(data),
+    status,
+    now,
+    item.id,
+  );
+  const updated: Item = { ...item, data, status, updated_at: now };
+  broadcast('item:completed', { sessionId, turnId, item: updated });
+}