repoburg 1.3.202 → 1.3.204

package/agent-pane/backend/src/integration/turn-lifecycle.test.ts

@@ -1,141 +0,0 @@
-/**
- * Integration test: full turn lifecycle.
- *
- * Verifies the complete pipeline: HTTP POST → startTurn → runStreamed
- * (replayed) → handleEvent → DB writes → WS broadcasts.
- *
- * Uses the real codex-provider.ts code with a mocked app-server client.
- * The HTTP route handler calls startTurn() fire-and-forget. Tests wait
- * for the turn to reach terminal status by polling the DB.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import type Database from 'better-sqlite3';
-import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
-import { clearBroadcasts, findBroadcast, expectBroadcastSequence, capturedBroadcasts } from './helpers/ws-capture.ts';
-import type { TestApp } from './helpers/test-app.ts';
-
-const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/simple-turn.json'), 'utf-8')) as Fixture;
-
-vi.mock('../codex/app-server-client.ts', () => ({
-  AppServerClient: createAppServerMock(fixture),
-}));
-
-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 });
-    }),
-  };
-});
-
-const { getDb } = await import('../db/index.ts');
-const { createTestApp, waitForTurn } = await import('./helpers/test-app.ts');
-
-describe('Integration: turn lifecycle', () => {
-  let testApp: TestApp;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    clearBroadcasts();
-    testApp = await createTestApp();
-  });
-
-  afterEach(async () => {
-    await testApp.cleanup();
-  });
-
-  it('completes a full turn: HTTP → startTurn → events → DB → WS', async () => {
-    const db: Database.Database = getDb();
-
-    // 1. Create session via HTTP
-    const createRes = await testApp.app.inject({
-      method: 'POST',
-      url: '/api/sessions',
-      payload: { cwd: '/test' },
-    });
-    expect(createRes.statusCode).toBe(200);
-    const session = createRes.json();
-    const sessionId = session.id;
-
-    // 2. Submit turn via HTTP — route handler calls startTurn() fire-and-forget
-    const turnRes = await testApp.app.inject({
-      method: 'POST',
-      url: `/api/sessions/${sessionId}/turns`,
-      payload: { user_prompt: 'Hello, how are you?' },
-    });
-    expect(turnRes.statusCode).toBe(200);
-    const turn = turnRes.json();
-    const turnId = turn.id;
-    expect(turn.status).toBe('pending');
-
-    // 3. Wait for turn to reach terminal status
-    await waitForTurn(db, turnId);
-
-    // 4. Assert DB state — session
-    const dbSession = db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId) as {
-      external_thread_id: string | null;
-      is_running: number;
-      status: string;
-      has_unreviewed: number;
-      title: string | null;
-    };
-    expect(dbSession.external_thread_id).toBe('thread_fix_001');
-    expect(dbSession.is_running).toBe(0);
-    expect(dbSession.status).toBe('active');
-    expect(dbSession.has_unreviewed).toBe(1);
-
-    // 5. Assert DB state — turn
-    const dbTurn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as {
-      status: string;
-      agent_response: string | null;
-      token_usage: string | null;
-    };
-    expect(dbTurn.status).toBe('completed');
-    expect(dbTurn.agent_response).toBe('Hello! How can I help you today?');
-    // Real app-server does not send usage in turn/completed — token_usage is null
-    // until thread/tokenUsage/updated notification is implemented
-    expect(dbTurn.token_usage).toBeNull();
-
-    // 6. Assert DB state — items
-    const items = db.prepare('SELECT * FROM items WHERE turn_id = ? ORDER BY created_at ASC').all(turnId) as {
-      id: string;
-      type: string;
-      data: string;
-      status: string;
-    }[];
-    expect(items).toHaveLength(1);
-    expect(items[0].type).toBe('agent_message');
-    expect(items[0].status).toBe('completed');
-    expect(JSON.parse(items[0].data)).toEqual({ text: 'Hello! How can I help you today?' });
-
-    // 7. Assert WS broadcasts — order matters
-    expectBroadcastSequence(['turn:started', 'item:started', 'item:updated', 'item:completed', 'turn:completed']);
-
-    // 8. Assert turn:completed broadcast payload (no usage — real app-server)
-    const completedData = findBroadcast('turn:completed') as {
-      sessionId: string;
-      turnId: string;
-      hasUnreviewed: boolean;
-    };
-    expect(completedData.sessionId).toBe(sessionId);
-    expect(completedData.turnId).toBe(turnId);
-    expect(completedData.hasUnreviewed).toBe(true);
-
-    // 9. Title generation is fire-and-forget — wait for it
-    await new Promise((r) => setTimeout(r, 500));
-    const dbSessionTitled = db.prepare('SELECT title FROM sessions WHERE id = ?').get(sessionId) as {
-      title: string | null;
-    };
-    expect(dbSessionTitled.title).toBe('Simple Hello Chat');
-
-    // 10. Verify session:title broadcast
-    const titleData = findBroadcast('session:title') as { sessionId: string; title: string };
-    expect(titleData.sessionId).toBe(sessionId);
-    expect(titleData.title).toBe('Simple Hello Chat');
-  });
-});

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

@@ -1,16 +0,0 @@
-/**
- * Provider registration — imports providers and registers them.
- *
- * Imported for side effects in `index.ts`:
- *   import './providers/index.ts';
- */
-
-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('repoburg', repoburgProvider);

package/agent-pane/backend/src/providers/registry.test.ts

@@ -1,92 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import type { RuntimeProvider } from './runtime-provider.ts';
-
-// Use dynamic import to get a fresh module instance per test.
-// vi.resetModules() ensures the registry Map starts empty each time.
-
-function makeMockProvider(): RuntimeProvider {
-  return {
-    startTurn: vi.fn().mockResolvedValue(undefined),
-    interruptTurn: vi.fn().mockResolvedValue(true),
-    clearThread: vi.fn(),
-    clearAllThreads: vi.fn(),
-    getModels: vi.fn().mockResolvedValue([]),
-    shutdown: vi.fn().mockResolvedValue(undefined),
-  };
-}
-
-describe('Provider registry', () => {
-  let registry: typeof import('./registry.ts');
-
-  beforeEach(async () => {
-    vi.resetModules();
-    registry = await import('./registry.ts');
-  });
-
-  describe('registerProvider + getProvider', () => {
-    it('registers and retrieves a provider', () => {
-      const mock = makeMockProvider();
-      registry.registerProvider('test', mock);
-      expect(registry.getProvider('test')).toBe(mock);
-    });
-
-    it('throws for unregistered provider', () => {
-      expect(() => registry.getProvider('unknown')).toThrow('Unknown provider: unknown');
-    });
-
-    it('overwrites previous registration with same ID', () => {
-      const mock1 = makeMockProvider();
-      const mock2 = makeMockProvider();
-      registry.registerProvider('test', mock1);
-      registry.registerProvider('test', mock2);
-      expect(registry.getProvider('test')).toBe(mock2);
-    });
-  });
-
-  describe('hasProvider', () => {
-    it('returns true for registered provider', () => {
-      registry.registerProvider('test', makeMockProvider());
-      expect(registry.hasProvider('test')).toBe(true);
-    });
-
-    it('returns false for unregistered provider', () => {
-      expect(registry.hasProvider('unknown')).toBe(false);
-    });
-  });
-
-  describe('clearAllProviders', () => {
-    it('calls clearAllThreads on all registered providers', () => {
-      const mock1 = makeMockProvider();
-      const mock2 = makeMockProvider();
-      registry.registerProvider('p1', mock1);
-      registry.registerProvider('p2', mock2);
-
-      registry.clearAllProviders();
-
-      expect(mock1.clearAllThreads).toHaveBeenCalledTimes(1);
-      expect(mock2.clearAllThreads).toHaveBeenCalledTimes(1);
-    });
-
-    it('does nothing when no providers registered', () => {
-      expect(() => registry.clearAllProviders()).not.toThrow();
-    });
-  });
-
-  describe('shutdownAllProviders', () => {
-    it('calls shutdown on all registered providers', async () => {
-      const mock1 = makeMockProvider();
-      const mock2 = makeMockProvider();
-      registry.registerProvider('p1', mock1);
-      registry.registerProvider('p2', mock2);
-
-      await registry.shutdownAllProviders();
-
-      expect(mock1.shutdown).toHaveBeenCalledTimes(1);
-      expect(mock2.shutdown).toHaveBeenCalledTimes(1);
-    });
-
-    it('does nothing when no providers registered', async () => {
-      await expect(registry.shutdownAllProviders()).resolves.toBeUndefined();
-    });
-  });
-});

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

@@ -1,43 +0,0 @@
-/**
- * Provider registry — Map-based dispatch.
- *
- * Routes call `getProvider(session.runtime_type).startTurn(...)`.
- * No if/else branching in route handlers.
- */
-
-import type { RuntimeProvider } from './runtime-provider.ts';
-
-const providers = new Map<string, RuntimeProvider>();
-
-/** Register a provider by its runtime type ID. */
-export function registerProvider(id: string, provider: RuntimeProvider): void {
-  providers.set(id, provider);
-}
-
-/** Get a provider by runtime type. Throws if not registered. */
-export function getProvider(runtimeType: string): RuntimeProvider {
-  const provider = providers.get(runtimeType);
-  if (!provider) {
-    throw new Error(`Unknown provider: ${runtimeType}`);
-  }
-  return provider;
-}
-
-/** Check if a provider is registered. */
-export function hasProvider(runtimeType: string): boolean {
-  return providers.has(runtimeType);
-}
-
-/** Clear all in-memory state for all providers. Used in test cleanup. */
-export function clearAllProviders(): void {
-  for (const provider of providers.values()) {
-    provider.clearAllThreads();
-  }
-}
-
-/** Graceful shutdown for all registered providers. */
-export async function shutdownAllProviders(): Promise<void> {
-  for (const provider of providers.values()) {
-    await provider.shutdown();
-  }
-}

package/agent-pane/backend/src/providers/runtime-provider.ts

@@ -1,49 +0,0 @@
-/**
- * Runtime provider interface — one interface for all providers.
- *
- * Each provider (Codex, Claude, etc.) implements this interface.
- * Routes dispatch via the registry Map — no if/else branching.
- */
-
-import type { Session, Turn } from '../db/schema.ts';
-import type { ModelInfo, ProviderSlashCommand } from '@agentpane/shared';
-
-/** Runtime provider — turn lifecycle, cleanup, metadata, and shutdown. */
-export interface RuntimeProvider {
-  /** Start a turn. Fire-and-forget — events stream via WebSocket. */
-  startTurn(session: Session, turn: Turn): Promise<void>;
-  /** Cancel a running turn. Returns true if a turn was cancelled. */
-  interruptTurn(sessionId: string): Promise<boolean>;
-  /** Remove session from in-memory state. Used after rewind/branch/model-change. */
-  clearThread(sessionId: string): void;
-  /** Remove a specific thread's branched session entry. Used when a thread is deleted. */
-  clearThreadBranch?(sessionId: string, threadId: string): void;
-  /** Clear all in-memory state. Used in test cleanup. */
-  clearAllThreads(): void;
-  /** Fetch available models for this provider. */
-  getModels(): Promise<ModelInfo[]>;
-  /** Fetch provider-native slash commands (e.g. Claude CLI `/compact`, `/clear`).
-   *  Optional — providers without a command surface omit it and return `[]`. */
-  getCommands?(): Promise<ProviderSlashCommand[]>;
-  /** Fork the provider-native session at a branch point.
-   *  Returns the new provider-native session ID, or null if there is no thread to fork.
-   *  Optional — providers without fork support omit it. */
-  forkSession?(session: Session, targetTurn: Turn): Promise<string | null>;
-  /** Truncate the runtime session's history IN PLACE after the target turn
-   *  (platform-parity rewind: hard delete). Throws on failure — the caller
-   *  must NOT apply any local rewind when this fails.
-   *  Optional — providers without in-place truncation omit it (e.g. Claude
-   *  uses forkSession instead). */
-  rewindRuntime?(session: Session, targetTurn: Turn): Promise<void>;
-  /** Change the model for a running session without restarting the CLI process.
-   *  Only supported in streaming-input mode (Claude). If the session hasn't
-   *  started yet, the new model is read from the DB on next startTurn.
-   *  Optional — providers without mid-session model switching omit it. */
-  setModel?(sessionId: string, model: string): Promise<void>;
-  /** Stop a running background task (e.g. Monitor) by task ID.
-   *  Emits a task_notification with status 'stopped'.
-   *  Optional — providers without background task support omit it. */
-  stopTask?(sessionId: string, taskId: string): Promise<void>;
-  /** Graceful shutdown — close processes, release resources. */
-  shutdown(): Promise<void>;
-}

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

@@ -1,122 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mapActionToItem, parseSelectionGroups } from './action-mapping.ts';
-import type { RepoburgAction } from './repoburg-client.ts';
-
-function askUserAction(selections: string | null): RepoburgAction {
-  return {
-    id: 'a1',
-    action_type: 'ask_user',
-    status: 'CONFIRMED_KEPT',
-    selections,
-    order_of_execution: 0,
-  };
-}
-
-function subagentAction(status: string, output = ''): RepoburgAction {
-  return {
-    id: 'act-1',
-    action_type: 'invoke_subagent',
-    status,
-    arguments: JSON.stringify({ agent_name: 'explore-codebase', prompt: 'Find auth files' }),
-    order_of_execution: 0,
-    executionLogs: [{ output }],
-  };
-}
-
-describe('mapActionToItem — invoke_subagent', () => {
-  it('maps to a completed background_task card (snapshot/reload shape)', () => {
-    const mapped = mapActionToItem(subagentAction('CONFIRMED_KEPT', 'auth files found'));
-    expect(mapped).not.toBeNull();
-    expect(mapped!.type).toBe('background_task');
-    expect(mapped!.status).toBe('completed');
-    expect(mapped!.data).toMatchObject({
-      task_type: 'subagent',
-      subagent_type: 'explore-codebase',
-      description: 'Find auth files',
-      status: 'completed',
-      summary: 'auth files found',
-      last_tool_name: null,
-      token_count: null,
-    });
-  });
-
-  it('maps a failed invoke_subagent to a failed background_task with the error as summary', () => {
-    const action = {
-      ...subagentAction('EXECUTION_FAILED'),
-      executionLogs: [{ error_message: 'boom' }],
-    };
-    const mapped = mapActionToItem(action);
-    expect(mapped!.status).toBe('failed');
-    expect(mapped!.data).toMatchObject({ status: 'failed', summary: 'boom' });
-  });
-});
-describe('parseSelectionGroups', () => {
-  it('parses canonical [{question, selections[]}] groups', () => {
-    const raw = JSON.stringify([
-      { question: 'Which database?', selections: ['Postgres', 'SQLite'] },
-      { question: 'Proceed?', selections: ['yes', 'no'] },
-    ]);
-    expect(parseSelectionGroups(raw)).toEqual([
-      { question: 'Which database?', selections: ['Postgres', 'SQLite'] },
-      { question: 'Proceed?', selections: ['yes', 'no'] },
-    ]);
-  });
-
-  it('coerces flat string arrays into single-option groups', () => {
-    expect(parseSelectionGroups(JSON.stringify(['Yes', 'No']))).toEqual([
-      { question: '', selections: ['Yes'] },
-      { question: '', selections: ['No'] },
-    ]);
-  });
-
-  it('drops invalid entries and non-string options', () => {
-    const raw = JSON.stringify([
-      { question: 'Q', selections: ['ok', 42] },
-      null,
-      { question: 'No options', selections: [] },
-    ]);
-    expect(parseSelectionGroups(raw)).toEqual([{ question: 'Q', selections: ['ok'] }]);
-  });
-
-  it('returns [] for malformed JSON, null, and non-array payloads', () => {
-    expect(parseSelectionGroups('not json')).toEqual([]);
-    expect(parseSelectionGroups(null)).toEqual([]);
-    expect(parseSelectionGroups('{"question":"q"}')).toEqual([]);
-  });
-});
-
-describe('mapActionToItem — ask_user', () => {
-  it('maps to an ask_user item with parsed groups', () => {
-    const raw = JSON.stringify([
-      { question: 'Which database?', selections: ['Postgres', 'SQLite'] },
-    ]);
-    const mapped = mapActionToItem(askUserAction(raw));
-    expect(mapped).not.toBeNull();
-    expect(mapped!.type).toBe('ask_user');
-    expect(mapped!.status).toBe('completed');
-    expect(mapped!.data).toEqual({
-      question: '',
-      groups: [{ question: 'Which database?', selections: ['Postgres', 'SQLite'] }],
-    });
-  });
-
-  it('falls back to a plain-text question card on malformed selections', () => {
-    const mapped = mapActionToItem(askUserAction('Plain question?'));
-    expect(mapped).not.toBeNull();
-    expect(mapped!.type).toBe('ask_user');
-    expect(mapped!.data).toEqual({ question: 'Plain question?', groups: [] });
-  });
-
-  it('maps without selections to a question card with the raw payload as text', () => {
-    const mapped = mapActionToItem(askUserAction('Which one?\n["A","B"]'));
-    expect(mapped).not.toBeNull();
-    expect(mapped!.data).toEqual({ question: 'Which one?\n["A","B"]', groups: [] });
-  });
-
-  it('maps a failed ask_user action to a failed item', () => {
-    const raw = JSON.stringify([{ question: 'Q?', selections: ['a', 'b'] }]);
-    const action = { ...askUserAction(raw), status: 'EXECUTION_FAILED' };
-    const mapped = mapActionToItem(action);
-    expect(mapped!.status).toBe('failed');
-  });
-});