repoburg 1.3.201 → 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,43 +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>;
-  /** 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.ts

@@ -1,216 +0,0 @@
-/**
- * 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 });
-}