repoburg 1.3.202 → 1.3.204

package/agent-pane/backend/src/codex/codex-provider.ts

@@ -1,619 +0,0 @@
-import type { SessionRuntimeConfig, ModelInfo } from '@agentpane/shared';
-import { v4 as uuidv4 } from 'uuid';
-import type Database from 'better-sqlite3';
-import { getDb } from '../db/index.ts';
-import { broadcast } from '../ws/index.ts';
-import { mapItemData, getItemStatus } from './item-mapper.ts';
-import { AppServerClient } from './app-server-client.ts';
-import type {
-  ItemNotification,
-  TurnFailedNotification,
-  ThreadStartResult,
-  TurnStartResult,
-  AppServerItem,
-  AgentMessageDeltaNotification,
-  TokenUsageNotification,
-  ModelListResult,
-} from './app-server-types.ts';
-import { mapTokenUsage } from './app-server-types.ts';
-import { getSharedAppServer, closeSharedAppServer } from './shared-app-server.ts';
-import type { Session, Turn, Item, ItemStatus } from '../db/schema.ts';
-import type { RuntimeProvider } from '../providers/runtime-provider.ts';
-
-/** Per-session app-server client + thread state. */
-interface SessionEntry {
-  client: AppServerClient;
-  threadId: string;
-  turnId: string | null;
-}
-
-const sessionMap = new Map<string, SessionEntry>();
-
-/** Update the running state and status of a session. */
-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,
-    );
-  }
-}
-
-/** Parse runtime_config JSON from the session row. Returns null on parse failure. */
-function parseRuntimeConfig(session: Session): SessionRuntimeConfig | null {
-  if (!session.runtime_config) return null;
-  try {
-    return JSON.parse(session.runtime_config) as SessionRuntimeConfig;
-  } catch {
-    return null;
-  }
-}
-
-/** Map runtime config sandbox mode to app-server sandbox type string (kebab-case). */
-function sandboxType(config: SessionRuntimeConfig | null): 'read-only' | 'workspace-write' | 'danger-full-access' {
-  switch (config?.sandboxMode) {
-    case 'read-only':
-      return 'read-only';
-    case 'danger-full-access':
-      return 'danger-full-access';
-    default:
-      return 'workspace-write';
-  }
-}
-
-/** Convert app-server camelCase item type to DB snake_case item type. */
-function normalizeItemType(type: string): string {
-  const map: Record<string, string> = {
-    agentMessage: 'agent_message',
-    userMessage: 'user_message',
-    agentReasoning: 'reasoning',
-    commandExecution: 'command_execution',
-    fileChange: 'file_change',
-    mcpToolCall: 'mcp_tool_call',
-    webSearch: 'web_search',
-    todoList: 'todo_list',
-    error: 'error',
-  };
-  return map[type] ?? type;
-}
-
-/** Check if an item type should be skipped (not stored in DB). */
-function shouldSkipItem(type: string): boolean {
-  return type === 'userMessage' || type === 'user_message';
-}
-
-/** Check if a reasoning item has empty content (app-server sends summary: [], content: []). */
-function isEmptyReasoning(item: AppServerItem): boolean {
-  const summary = Array.isArray(item.summary) ? item.summary : [];
-  const content = Array.isArray(item.content) ? item.content : [];
-  const text = item.text ?? '';
-  return summary.length === 0 && content.length === 0 && text.length === 0;
-}
-
-/** Create or resume a thread for the session via a per-session app-server client. */
-async function getOrCreateThread(session: Session): Promise<SessionEntry> {
-  const existing = sessionMap.get(session.id);
-  if (existing) return existing;
-
-  const cwd = session.cwd ?? process.cwd();
-  const client = new AppServerClient({ cwd });
-  await client.initialize();
-
-  const config = parseRuntimeConfig(session);
-  const sandbox = sandboxType(config);
-
-  let threadId: string;
-
-  if (session.external_thread_id) {
-    const result = await client.request<ThreadStartResult>('thread/resume', {
-      threadId: session.external_thread_id,
-      cwd,
-      approvalPolicy: 'never',
-      sandbox,
-      model: session.model ?? undefined,
-    });
-    threadId = result.thread.id;
-  } else {
-    const result = await client.request<ThreadStartResult>('thread/start', {
-      cwd,
-      approvalPolicy: 'never',
-      sandbox,
-      model: session.model ?? undefined,
-    });
-    threadId = result.thread.id;
-
-    // Save the thread ID to the database
-    const db = getDb();
-    const now = new Date().toISOString();
-    db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
-      threadId,
-      now,
-      session.id,
-    );
-  }
-
-  const entry: SessionEntry = { client, threadId, turnId: null };
-  sessionMap.set(session.id, entry);
-  return entry;
-}
-
-/** Start a Codex turn. Fire-and-forget — streams events via WS. */
-export async function startTurn(session: Session, turn: Turn): Promise<void> {
-  const db = getDb();
-
-  // Phase 1: create or resume thread
-  let entry: SessionEntry;
-  try {
-    entry = await getOrCreateThread(session);
-  } catch (err) {
-    const errMsg = `Failed to create app-server thread: ${(err as Error).message}`;
-    const now = new Date().toISOString();
-    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
-      'failed',
-      errMsg,
-      now,
-      turn.id,
-    );
-    setSessionStatus(db, session.id, 0, 'failed', now);
-    broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
-    return;
-  }
-
-  // Phase 2: update status
-  entry.turnId = turn.id;
-  const now = new Date().toISOString();
-  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('running', now, turn.id);
-  setSessionStatus(db, session.id, 1, 'running', now);
-  broadcast('turn:started', { sessionId: session.id, turnId: turn.id });
-
-  // Phase 3: register notification handlers and send turn/start
-  const { client, threadId } = entry;
-  const config = parseRuntimeConfig(session);
-  const sandbox = sandboxType(config);
-
-  // Flag to prevent duplicate handler execution after turn ends
-  let turnDone = false;
-
-  // Register handlers for this turn (scoped by threadId — one active turn per session)
-  const handleItemStarted = (params: unknown) => {
-    if (turnDone) return;
-    const p = params as ItemNotification;
-    if (p.threadId !== threadId) return;
-    handleItemEvent(p, session.id, turn.id, 'in_progress', 'item:started');
-  };
-  const handleItemUpdated = (params: unknown) => {
-    if (turnDone) return;
-    const p = params as ItemNotification;
-    if (p.threadId !== threadId) return;
-    handleItemEvent(p, session.id, turn.id, 'in_progress', 'item:updated');
-  };
-  const handleItemCompleted = (params: unknown) => {
-    if (turnDone) return;
-    const p = params as ItemNotification;
-    if (p.threadId !== threadId) return;
-    const status = getItemStatus(p.item);
-    handleItemEvent(p, session.id, turn.id, status, 'item:completed');
-  };
-  const handleTurnCompleted = (params: unknown) => {
-    if (turnDone) return;
-    const p = params as { threadId: string; turn?: { id: string; status: string }; usage?: unknown };
-    if (p.threadId !== threadId) return;
-    turnDone = true;
-    const db = getDb();
-    const now = new Date().toISOString();
-    // Token usage may be in params (mock) or already saved via thread/tokenUsage/updated (real app-server).
-    // When p.usage is undefined, preserve existing token_usage (set by thread/tokenUsage/updated handler).
-    if (p.usage !== undefined) {
-      db.prepare('UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?').run(
-        'completed',
-        JSON.stringify(p.usage),
-        now,
-        turn.id,
-      );
-      broadcast('turn:completed', { sessionId: session.id, turnId: turn.id, usage: p.usage, hasUnreviewed: true });
-    } else {
-      db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('completed', now, turn.id);
-      broadcast('turn:completed', { sessionId: session.id, turnId: turn.id, hasUnreviewed: true });
-    }
-    setSessionStatus(db, session.id, 0, 'active', now, true);
-    syncThreadTitle(session.id);
-  };
-  const handleTurnFailed = (params: unknown) => {
-    if (turnDone) return;
-    const p = params as TurnFailedNotification;
-    if (p.threadId !== threadId) return;
-    turnDone = true;
-    const db = getDb();
-    const now = new Date().toISOString();
-    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
-      'failed',
-      p.error.message,
-      now,
-      turn.id,
-    );
-    setSessionStatus(db, session.id, 0, 'failed', now);
-    broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: p.error.message });
-  };
-
-  // Stream incremental text deltas to frontend — no DB write per delta (performance).
-  // The final text is written by handleItemEvent on item/completed.
-  const handleAgentMessageDelta = (params: unknown) => {
-    if (turnDone) return;
-    const p = params as AgentMessageDeltaNotification;
-    if (p.threadId !== threadId) return;
-    broadcast('item:delta', {
-      sessionId: session.id,
-      turnId: turn.id,
-      itemId: p.itemId,
-      delta: p.delta,
-    });
-  };
-
-  // Save token usage from thread/tokenUsage/updated — no turnDone guard (may arrive before or after turn/completed).
-  const handleTokenUsageUpdated = (params: unknown) => {
-    const p = params as TokenUsageNotification;
-    if (p.threadId !== threadId) return;
-    const usage = mapTokenUsage(p.tokenUsage.total);
-    const db = getDb();
-    const now = new Date().toISOString();
-    db.prepare('UPDATE turns SET token_usage = ?, updated_at = ? WHERE id = ?').run(
-      JSON.stringify(usage),
-      now,
-      turn.id,
-    );
-    broadcast('turn:tokenUsage', { sessionId: session.id, turnId: turn.id, usage });
-  };
-
-  // Note: onNotification adds to a list, so we register before sending turn/start
-  client.onNotification('item/started', handleItemStarted);
-  client.onNotification('item/updated', handleItemUpdated);
-  client.onNotification('item/completed', handleItemCompleted);
-  client.onNotification('item/agentMessage/delta', handleAgentMessageDelta);
-  client.onNotification('turn/completed', handleTurnCompleted);
-  client.onNotification('turn/failed', handleTurnFailed);
-  client.onNotification('thread/tokenUsage/updated', handleTokenUsageUpdated);
-
-  // Phase 4: send turn/start
-  try {
-    await client.request<TurnStartResult>('turn/start', {
-      threadId,
-      input: [{ type: 'text', text: turn.user_prompt }],
-      approvalPolicy: 'never',
-      sandbox: { type: sandbox },
-      model: session.model ?? undefined,
-      effort: session.model_reasoning_effort ?? undefined,
-    });
-
-    // The turn runs asynchronously — events arrive via notifications
-    // If the process closes unexpectedly, handle cleanup
-    client.events.once('closed', () => {
-      const db = getDb();
-      const now = new Date().toISOString();
-      const currentTurn = db.prepare('SELECT status FROM turns WHERE id = ?').get(turn.id) as
-        | { status: string }
-        | undefined;
-      if (currentTurn && currentTurn.status === 'running') {
-        db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
-          'failed',
-          'App-server process closed unexpectedly',
-          now,
-          turn.id,
-        );
-        setSessionStatus(db, session.id, 0, 'failed', now);
-        broadcast('turn:failed', {
-          sessionId: session.id,
-          turnId: turn.id,
-          error: 'App-server process closed unexpectedly',
-        });
-      }
-    });
-  } catch (err) {
-    const errMsg = (err as Error).message;
-    const now2 = new Date().toISOString();
-    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
-      'failed',
-      errMsg,
-      now2,
-      turn.id,
-    );
-    setSessionStatus(db, session.id, 0, 'failed', now2);
-    broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
-    turnDone = true;
-  }
-}
-
-/** Handle an item notification — insert or update DB row and broadcast. */
-function handleItemEvent(
-  params: ItemNotification,
-  sessionId: string,
-  turnId: string,
-  status: ItemStatus,
-  broadcastEvent: string,
-): void {
-  const db = getDb();
-  const now = new Date().toISOString();
-  const item = params.item;
-
-  // Skip user messages — they are not agent output
-  if (shouldSkipItem(item.type)) return;
-
-  // Skip reasoning items with empty content — app-server sends summary: [], content: []
-  // These have no displayable text and would render as empty cards
-  if ((item.type === 'reasoning' || item.type === 'agentReasoning') && isEmptyReasoning(item)) return;
-
-  const data = mapItemData(item);
-  const normalizedType = normalizeItemType(item.type);
-
-  // Try to update existing row
-  const result = db
-    .prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
-    .run(JSON.stringify(data), status, now, item.id, turnId);
-
-  let itemId: string;
-  let createdAt: string;
-
-  if (result.changes === 0) {
-    // Item not in DB yet — insert
-    itemId = uuidv4();
-    createdAt = now;
-    db.prepare(
-      'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
-    ).run(itemId, turnId, item.id, normalizedType as Item['type'], JSON.stringify(data), status, now, now);
-  } else {
-    const row = db
-      .prepare('SELECT id, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
-      .get(item.id, turnId) as { id: string; created_at: string };
-    itemId = row.id;
-    createdAt = row.created_at;
-  }
-
-  // Update turn-level fields on item completion
-  if (status === 'completed' || status === 'in_progress') {
-    if (item.type === 'agentMessage' || item.type === 'agent_message') {
-      db.prepare('UPDATE turns SET agent_response = ?, updated_at = ? WHERE id = ?').run(item.text, now, turnId);
-    }
-    if (item.type === 'reasoning' || item.type === 'agentReasoning') {
-      const summary = Array.isArray(item.summary) ? (item.summary as string[]).join('\n') : '';
-      const thoughts = summary || item.text || '';
-      if (thoughts) {
-        db.prepare('UPDATE turns SET thoughts = ?, updated_at = ? WHERE id = ?').run(thoughts, now, turnId);
-      }
-    }
-  }
-
-  const wsItem: Item = {
-    id: itemId,
-    turn_id: turnId,
-    external_item_id: item.id,
-    type: normalizedType as Item['type'],
-    data,
-    status,
-    created_at: createdAt,
-    updated_at: now,
-  };
-
-  broadcast(broadcastEvent, { sessionId, turnId, item: wsItem });
-}
-
-/** Cancel a running turn by session ID. Returns true if a turn was cancelled. */
-export async function interruptTurn(sessionId: string): Promise<boolean> {
-  const entry = sessionMap.get(sessionId);
-  if (!entry || !entry.turnId) return false;
-
-  try {
-    await entry.client.request('turn/interrupt', {
-      threadId: entry.threadId,
-      turnId: entry.turnId,
-    });
-
-    // Update DB and broadcast — the app-server may not send a turn/failed notification
-    const db = getDb();
-    const now = new Date().toISOString();
-    db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('aborted', now, entry.turnId);
-    setSessionStatus(db, sessionId, 0, 'active', now);
-    broadcast('turn:cancelled', { sessionId, turnId: entry.turnId });
-
-    // Clear turn ID so further notifications are ignored
-    entry.turnId = null;
-
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** Remove a session's app-server client from the in-memory map. Used after rewind/branch. */
-export function clearThread(sessionId: string): void {
-  const entry = sessionMap.get(sessionId);
-  if (entry) {
-    entry.client.close().catch(() => {
-      // Ignore close errors
-    });
-    sessionMap.delete(sessionId);
-  }
-}
-
-/** Clear all session entries. Used in test cleanup. */
-export function clearAllThreads(): void {
-  for (const [, entry] of sessionMap) {
-    entry.client.close().catch(() => {});
-  }
-  sessionMap.clear();
-  titleGenerating.clear();
-}
-
-// --- Title generation ---
-
-/** Tracks sessions currently generating titles — prevents duplicate throwaway threads. */
-const titleGenerating = new Set<string>();
-
-/** Generate a title for the session using a throwaway app-server thread. */
-function syncThreadTitle(sessionId: string): void {
-  const db = getDb();
-  const session = db.prepare('SELECT title FROM sessions WHERE id = ?').get(sessionId) as
-    | { title: string | null }
-    | undefined;
-  if (!session || session.title !== null) return;
-  if (titleGenerating.has(sessionId)) return;
-
-  const turn = db
-    .prepare('SELECT user_prompt, agent_response FROM turns WHERE session_id = ? ORDER BY created_at ASC LIMIT 1')
-    .get(sessionId) as { user_prompt: string; agent_response: string | null } | undefined;
-  if (!turn) return;
-
-  titleGenerating.add(sessionId);
-  generateTitleAsync(sessionId, turn.user_prompt, turn.agent_response).finally(() => {
-    titleGenerating.delete(sessionId);
-  });
-}
-
-/** Create a throwaway app-server thread, ask for a title, update the session. */
-async function generateTitleAsync(
-  sessionId: string,
-  userPrompt: string,
-  agentResponse: string | null,
-): Promise<void> {
-  let client: AppServerClient | null = null;
-  try {
-    client = new AppServerClient({ cwd: process.cwd() });
-    await client.initialize();
-
-    const initResult = await client.request<ThreadStartResult>('thread/start', {
-      cwd: process.cwd(),
-      approvalPolicy: 'never',
-      sandbox: 'read-only',
-    });
-    const threadId = initResult.thread.id;
-
-    const truncatedPrompt = userPrompt.slice(0, 500);
-    const truncatedResponse = (agentResponse || '').slice(0, 500);
-    const titlePrompt = `Generate a concise 3-5 word title for this conversation. Reply with only the title, nothing else.\n\nUser asked: "${truncatedPrompt}"\n\nAgent responded: "${truncatedResponse}"`;
-
-    // Set up promise to capture the title response
-    let titleResolve!: (value: string) => void;
-    let titleReject!: (error: Error) => void;
-    const titlePromise = new Promise<string>((resolve, reject) => {
-      titleResolve = resolve;
-      titleReject = reject;
-    });
-
-    // Capture agent_message text from item/completed
-    let titleResponse = '';
-    client.onNotification('item/completed', (params: unknown) => {
-      const p = params as ItemNotification;
-      if (p.threadId !== threadId) return;
-      if ((p.item.type === 'agentMessage' || p.item.type === 'agent_message') && p.item.text) {
-        titleResponse = p.item.text;
-      }
-    });
-
-    // Resolve on turn/completed
-    client.onNotification('turn/completed', (params: unknown) => {
-      const p = params as { threadId: string };
-      if (p.threadId !== threadId) return;
-      titleResolve(titleResponse);
-    });
-
-    // Reject on turn/failed
-    client.onNotification('turn/failed', (params: unknown) => {
-      const p = params as TurnFailedNotification;
-      if (p.threadId !== threadId) return;
-      titleReject(new Error(p.error.message));
-    });
-
-    // Set a timeout (30s)
-    const timeout = setTimeout(() => {
-      titleReject(new Error('Title generation timed out'));
-    }, 30_000);
-
-    // Send turn/start — events arrive via notifications
-    await client.request<TurnStartResult>('turn/start', {
-      threadId,
-      input: [{ type: 'text', text: titlePrompt }],
-      approvalPolicy: 'never',
-      sandbox: { type: 'read-only' },
-    });
-
-    const title = await titlePromise;
-    clearTimeout(timeout);
-
-    const cleanTitle = title.trim().replace(/^["']|["']$/g, '').slice(0, 100);
-
-    if (cleanTitle) {
-      const db = getDb();
-      const now = new Date().toISOString();
-      db.prepare('UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?').run(cleanTitle, now, sessionId);
-      broadcast('session:title', { sessionId, title: cleanTitle });
-    }
-  } catch {
-    // Silently skip on error — session keeps null title
-  } finally {
-    if (client) {
-      await client.close().catch(() => {});
-    }
-  }
-}
-
-// --- Provider interface ---
-
-/** Map SDK effort values to UI labels. */
-const EFFORT_LABELS: Record<string, string> = {
-  minimal: 'Minimal',
-  low: 'Low',
-  medium: 'Medium',
-  high: 'High',
-  xhigh: 'Extra High',
-  max: 'Max',
-  ultra: 'Ultra',
-};
-
-/** Fetch available models from the shared app-server and map to ModelInfo[]. */
-async function getModels(): Promise<ModelInfo[]> {
-  try {
-    const result = await getSharedAppServer().request<ModelListResult>('model/list', {});
-    return (result.data ?? []).map((m) => ({
-      slug: m.id,
-      displayName: m.displayName,
-      description: m.description,
-      defaultReasoning: m.defaultReasoningEffort,
-      reasoningLevels: (m.supportedReasoningEfforts ?? []).map((r) => ({
-        effort: r.reasoningEffort,
-        label: EFFORT_LABELS[r.reasoningEffort] ?? r.reasoningEffort,
-      })),
-    }));
-  } catch {
-    return [];
-  }
-}
-
-/** Graceful shutdown — close shared metadata process and all per-session clients. */
-async function shutdown(): Promise<void> {
-  await closeSharedAppServer();
-  clearAllThreads();
-}
-
-/** Codex provider — implements RuntimeProvider interface. */
-export const codexProvider: RuntimeProvider = {
-  startTurn,
-  interruptTurn,
-  clearThread,
-  clearAllThreads,
-  getModels,
-  shutdown,
-};