repoburg 1.3.201 → 1.3.204

package/agent-pane/backend/src/repoburg/turn-projector.ts

@@ -1,537 +0,0 @@
-/**
- * Turn projector — maps the agent-runtime message stream (Claude-Code-style)
- * onto agent-pane items and turn lifecycle.
- *
- * Projection (idempotent upsert by external ids):
- *  - stream_event(text/thinking) → agent_message / reasoning items (live deltas)
- *  - assistant                  → completes the round's text/thoughts items
- *  - user(tool_result)          → file_change / command_execution / mcp_tool_call
- *                                 / web_search items from the action data
- *  - result                     → terminal: turn completed / failed / cancelled
- *
- * Watch-dog (Claude Code stream-watchdog analog): no `result` within
- * RESULT_TIMEOUT after the last MESSAGE (heartbeats do not reset it) →
- * HTTP snapshot reconcile (GET /sessions/:id/inputs incl. aiActions) fills
- * missing rounds; a still-running session re-arms the watchdog up to
- * MAX_RESULT_EXTENSIONS times, then the turn fails with a timeout error.
- */
-
-import { getDb } from '../db/index.ts';
-import { broadcast } from '../ws/index.ts';
-import type { Item } from '../db/schema.ts';
-import type { RepoburgRuntimeClient, RepoburgSessionInput } from './repoburg-client.ts';
-import {
-  completeItem,
-  insertItem,
-  mapActionToItem,
-  mapUsage,
-  setSessionStatus,
-} from './action-mapping.ts';
-import type {
-  AgentRuntimeMessage,
-  AssistantMessage,
-  ResultMessage,
-  StreamEventMessage,
-  UserMessage,
-} from './agent-runtime-client.ts';
-
-/** No result message within this window after the last message → reconcile. */
-export const RESULT_TIMEOUT_MS = 15 * 60_000;
-/** Reconcile extensions while the backend reports the session still running. */
-export const MAX_RESULT_EXTENSIONS = 3;
-
-/** Per-round projected state. */
-interface RoundInfo {
-  messageItemId: string | null;
-  reasoningItemId: string | null;
-  messageExternalId: string;
-  reasoningExternalId: string;
-  text: string;
-  thoughts: string;
-  finalPlain: string | null;
-}
-
-export interface ProjectorDeps {
-  agentPaneSessionId: string;
-  turnId: string;
-  repoburgSessionId: string;
-  client: RepoburgRuntimeClient;
-  /** Optional hook: called once when the turn reaches a terminal state. */
-  onFinished?: () => void;
-}
-
-export class TurnProjector {
-  private readonly rounds = new Map<string, RoundInfo>();
-  private done = false;
-  private resultTimer: ReturnType<typeof setTimeout> | null = null;
-  private extensions = 0;
-
-  constructor(private readonly deps: ProjectorDeps) {
-    this.armResultWatchdog();
-  }
-
-  get isDone(): boolean {
-    return this.done;
-  }
-
-  /** Main entry — dispatch one agent-runtime message. */
-  handle(message: AgentRuntimeMessage): void {
-    if (this.done) return;
-    switch (message.type) {
-      case 'system':
-        break; // init — connection marker only
-      case 'stream_event':
-        this.handleStreamEvent(message);
-        break;
-      case 'assistant':
-        this.handleAssistant(message);
-        break;
-      case 'user':
-        this.handleUser(message);
-        break;
-      case 'result':
-        this.handleResult(message);
-        break;
-    }
-  }
-
-  /** Reset the result watchdog (any MESSAGE resets it; heartbeats do not). */
-  touch(): void {
-    if (this.done) return;
-    this.armResultWatchdog();
-  }
-
-  /** Stop the projector (turn finalized externally). Clears timers. */
-  close(): void {
-    this.clearWatchdog();
-    this.done = true;
-  }
-
-  // -------------------------------------------------------------------------
-  // Message handlers
-  // -------------------------------------------------------------------------
-
-  private round(inputId: string): RoundInfo {
-    let info = this.rounds.get(inputId);
-    if (!info) {
-      info = {
-        messageItemId: null,
-        reasoningItemId: null,
-        messageExternalId: `${inputId}-text`,
-        reasoningExternalId: `${inputId}-thoughts`,
-        text: '',
-        thoughts: '',
-        finalPlain: null,
-      };
-      this.rounds.set(inputId, info);
-    }
-    return info;
-  }
-
-  private handleStreamEvent(msg: StreamEventMessage): void {
-    const db = getDb();
-    const info = this.round(msg.inputId);
-    const kind = msg.delta.type === 'thinking' ? 'thoughts' : 'text';
-
-    if (kind === 'text') info.text += msg.delta.text;
-    else info.thoughts += msg.delta.text;
-
-    const externalId = kind === 'text' ? info.messageExternalId : info.reasoningExternalId;
-    const type: Item['type'] = kind === 'text' ? 'agent_message' : 'reasoning';
-    const itemId = kind === 'text' ? info.messageItemId : info.reasoningItemId;
-
-    if (!itemId) {
-      const item = insertItem(
-        db,
-        this.deps.agentPaneSessionId,
-        this.deps.turnId,
-        externalId,
-        type,
-        { text: kind === 'text' ? info.text : info.thoughts },
-        'in_progress',
-        'item:started',
-      );
-      if (kind === 'text') info.messageItemId = item.id;
-      else info.reasoningItemId = item.id;
-    } else {
-      // Subsequent chunks stream as deltas (frontend matches by external id).
-      broadcast('item:delta', {
-        sessionId: this.deps.agentPaneSessionId,
-        turnId: this.deps.turnId,
-        itemId: externalId,
-        delta: msg.delta.text,
-      });
-    }
-    this.touch();
-  }
-
-  private handleAssistant(msg: AssistantMessage): void {
-    const info = this.round(msg.inputId);
-
-    // The assistant message is the AUTHORITATIVE round content — replace the
-    // accumulated deltas (they may be partial when deltas were off/missed).
-    const text = msg.content
-      .filter((b) => b.type === 'text')
-      .map((b) => (b as { text: string }).text)
-      .join('');
-    const thinking = msg.content
-      .filter((b) => b.type === 'thinking')
-      .map((b) => (b as { thinking: string }).thinking)
-      .join('');
-    if (text) info.text = text;
-    if (thinking) info.thoughts = thinking;
-
-    // Complete (or create) the round's items — deltas may have been off/missed.
-    this.upsertCompletedTextItem(info, 'message', info.text);
-    this.upsertCompletedTextItem(info, 'reasoning', info.thoughts);
-    this.touch();
-  }
-
-  /** Complete a round's text/thoughts item — creates it when deltas were
-   *  off or missed, otherwise completes the streamed in_progress item. */
-  private upsertCompletedTextItem(
-    info: RoundInfo,
-    kind: 'message' | 'reasoning',
-    text: string,
-  ): void {
-    if (!text) return;
-    const db = getDb();
-    const externalId = kind === 'message' ? info.messageExternalId : info.reasoningExternalId;
-    const itemId = kind === 'message' ? info.messageItemId : info.reasoningItemId;
-    const type: Item['type'] = kind === 'message' ? 'agent_message' : 'reasoning';
-
-    if (itemId) {
-      const itemRow = db.prepare('SELECT * FROM items WHERE id = ?').get(itemId) as
-        | Item
-        | undefined;
-      if (itemRow) {
-        completeItem(db, this.deps.agentPaneSessionId, this.deps.turnId, itemRow, { text }, 'completed');
-        return;
-      }
-    }
-    // Idempotent: skip when an item with this external id already exists
-    // (e.g. replayed after reconnect).
-    const existing = db
-      .prepare('SELECT id FROM items WHERE turn_id = ? AND external_item_id = ?')
-      .get(this.deps.turnId, externalId);
-    if (existing) return;
-    const item = insertItem(
-      db,
-      this.deps.agentPaneSessionId,
-      this.deps.turnId,
-      externalId,
-      type,
-      { text },
-      'completed',
-      'item:completed',
-    );
-    if (kind === 'message') info.messageItemId = item.id;
-    else info.reasoningItemId = item.id;
-  }
-
-  private handleUser(msg: UserMessage): void {
-    const db = getDb();
-    for (const block of msg.content) {
-      const info = this.round(msg.inputId);
-      // Synthesize the RepoburgAction shape from the tool_result payload —
-      // failed actions carry their text as the error, successful as output.
-      const action = {
-        ...block.action,
-        executionLogs: [
-          {
-            output: block.is_error ? '' : block.content,
-            error_message: block.is_error ? block.content : null,
-          },
-        ],
-      };
-      if (action.action_type === 'final') info.finalPlain = action.plain ?? null;
-
-      const externalId = `${msg.inputId}-action-${action.id}`;
-      const mapped = mapActionToItem(action);
-      if (!mapped) continue;
-
-      // Idempotent upsert — skip when already projected (reconnect replay
-      // or snapshot overlap).
-      const existing = db
-        .prepare('SELECT id FROM items WHERE turn_id = ? AND external_item_id = ?')
-        .get(this.deps.turnId, externalId);
-      if (existing) continue;
-
-      insertItem(
-        db,
-        this.deps.agentPaneSessionId,
-        this.deps.turnId,
-        externalId,
-        mapped.type,
-        mapped.data,
-        mapped.status,
-        'item:completed',
-      );
-    }
-    this.touch();
-  }
-
-  private handleResult(msg: ResultMessage): void {
-    switch (msg.subtype) {
-      case 'success':
-        this.finishSuccess(msg);
-        break;
-      case 'aborted':
-        this.finishAborted();
-        break;
-      case 'error_during_execution':
-      default:
-        this.finishFailed((msg.errors ?? []).join('; ') || 'Agent turn failed.');
-        break;
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Terminal states
-  // -------------------------------------------------------------------------
-
-  private finishSuccess(msg: ResultMessage): void {
-    const db = getDb();
-    const now = new Date().toISOString();
-    const lastRound = [...this.rounds.values()].pop();
-
-    const responseText = msg.result || lastRound?.text || lastRound?.finalPlain || '';
-    const usage = msg.usage
-      ? mapUsage({
-          input: msg.usage.input_tokens,
-          cached: msg.usage.cache_read_input_tokens,
-          output: msg.usage.output_tokens,
-        })
-      : null;
-
-    this.closeOpenItems('completed');
-    db.prepare(
-      'UPDATE turns SET status = ?, agent_response = ?, token_usage = ?, updated_at = ? WHERE id = ?',
-    ).run('completed', responseText || null, usage ? JSON.stringify(usage) : null, now, this.deps.turnId);
-    setSessionStatus(db, this.deps.agentPaneSessionId, 0, 'active', now, true);
-
-    broadcast('turn:completed', {
-      sessionId: this.deps.agentPaneSessionId,
-      turnId: this.deps.turnId,
-      ...(usage ? { usage } : {}),
-      hasUnreviewed: true,
-    });
-    void this.syncTitle();
-    this.finalize();
-  }
-
-  /** Fire-and-forget: copy the runtime session title once (new sessions). */
-  private async syncTitle(): Promise<void> {
-    try {
-      const db = getDb();
-      const session = db.prepare('SELECT title FROM sessions WHERE id = ?').get(
-        this.deps.agentPaneSessionId,
-      ) as { title: string | null } | undefined;
-      if (!session || session.title) return;
-
-      const runtimeSession = await this.deps.client.getSession(this.deps.repoburgSessionId);
-      const title = (runtimeSession.session_title || '').trim();
-      if (!title) return;
-
-      const now = new Date().toISOString();
-      db.prepare('UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?').run(
-        title,
-        now,
-        this.deps.agentPaneSessionId,
-      );
-      broadcast('session:title', { sessionId: this.deps.agentPaneSessionId, title });
-    } catch {
-      // Title sync is best-effort.
-    }
-  }
-
-  private finishFailed(error: string): void {
-    const db = getDb();
-    const now = new Date().toISOString();
-    this.closeOpenItems('failed');
-    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
-      'failed',
-      error,
-      now,
-      this.deps.turnId,
-    );
-    setSessionStatus(db, this.deps.agentPaneSessionId, 0, 'failed', now);
-    broadcast('turn:failed', {
-      sessionId: this.deps.agentPaneSessionId,
-      turnId: this.deps.turnId,
-      error,
-    });
-    this.finalize();
-  }
-
-  private finishAborted(): void {
-    const db = getDb();
-    const now = new Date().toISOString();
-    this.closeOpenItems('completed');
-    db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run(
-      'aborted',
-      now,
-      this.deps.turnId,
-    );
-    setSessionStatus(db, this.deps.agentPaneSessionId, 0, 'active', now);
-    broadcast('turn:cancelled', {
-      sessionId: this.deps.agentPaneSessionId,
-      turnId: this.deps.turnId,
-    });
-    this.finalize();
-  }
-
-  private finalize(): void {
-    this.clearWatchdog();
-    this.done = true;
-    this.deps.onFinished?.();
-  }
-
-  /** Close every still in_progress item of this turn with the given status. */
-  private closeOpenItems(status: Item['status']): void {
-    const db = getDb();
-    const now = new Date().toISOString();
-    db.prepare('UPDATE items SET status = ?, updated_at = ? WHERE turn_id = ? AND status = ?').run(
-      status,
-      now,
-      this.deps.turnId,
-      'in_progress',
-    );
-  }
-
-  // -------------------------------------------------------------------------
-  // Watch-dog + snapshot reconcile
-  // -------------------------------------------------------------------------
-
-  private armResultWatchdog(): void {
-    if (this.done) return;
-    this.clearWatchdog();
-    this.resultTimer = setTimeout(() => {
-      void this.reconcileFromSnapshot();
-    }, RESULT_TIMEOUT_MS);
-  }
-
-  private clearWatchdog(): void {
-    if (this.resultTimer) {
-      clearTimeout(this.resultTimer);
-      this.resultTimer = null;
-    }
-  }
-
-  /** Snapshot reconcile: project missing rounds from the runtime's HTTP
-   *  snapshot, then complete the turn when the session stopped running. */
-  private async reconcileFromSnapshot(): Promise<void> {
-    if (this.done) return;
-    const { client, repoburgSessionId } = this.deps;
-    try {
-      const [inputs, session] = await Promise.all([
-        client.getSessionInputs(repoburgSessionId),
-        client.getSession(repoburgSessionId),
-      ]);
-      if (this.done) return; // A result arrived while fetching.
-
-      for (const input of inputs) {
-        if (input.role === 'model') this.projectSnapshotRound(input);
-      }
-
-      if (!session.is_running) {
-        // The loop is over — finish from the snapshot's last round.
-        const modelInputs = inputs.filter((i) => i.role === 'model');
-        const last = modelInputs[modelInputs.length - 1];
-        const lastRound = [...this.rounds.values()].pop();
-        const responseText =
-          lastRound?.text ||
-          lastRound?.finalPlain ||
-          extractFinalPlain(last) ||
-          last?.raw_llm_response ||
-          '';
-        const usage = last
-          ? mapUsage({
-              input: last.input_token_count ?? 0,
-              cached: last.cached_token_count ?? 0,
-              output: last.output_token_count ?? 0,
-            })
-          : null;
-        const db = getDb();
-        const now = new Date().toISOString();
-        this.closeOpenItems('completed');
-        db.prepare(
-          'UPDATE turns SET status = ?, agent_response = ?, token_usage = ?, updated_at = ? WHERE id = ?',
-        ).run('completed', responseText || null, usage ? JSON.stringify(usage) : null, now, this.deps.turnId);
-        setSessionStatus(db, this.deps.agentPaneSessionId, 0, 'active', now, true);
-        broadcast('turn:completed', {
-          sessionId: this.deps.agentPaneSessionId,
-          turnId: this.deps.turnId,
-          ...(usage ? { usage } : {}),
-          hasUnreviewed: true,
-        });
-        void this.syncTitle();
-        this.finalize();
-        return;
-      }
-
-      // Still running — re-arm or give up.
-      if (this.extensions < MAX_RESULT_EXTENSIONS) {
-        this.extensions += 1;
-        this.armResultWatchdog();
-      } else {
-        this.finishFailed(
-          `No result within ${(RESULT_TIMEOUT_MS / 60_000) * (MAX_RESULT_EXTENSIONS + 1)} minutes — the runtime session is still running. Check repoburg logs.`,
-        );
-      }
-    } catch (err) {
-      console.error('[repoburg] snapshot reconcile failed:', err);
-      if (this.extensions < MAX_RESULT_EXTENSIONS) {
-        this.extensions += 1;
-        this.armResultWatchdog();
-      } else {
-        this.finishFailed(`Snapshot reconcile failed: ${(err as Error).message}`);
-      }
-    }
-  }
-
-  /** Project one round from the snapshot (idempotent — live-projected
-   *  rounds already exist and are skipped). */
-  private projectSnapshotRound(input: RepoburgSessionInput): void {
-    if (!input.raw_llm_response && !input.thoughts && !input.aiActions?.length) return;
-    const info = this.round(input.id);
-    info.text = info.text || (input.raw_llm_response ?? '');
-    info.thoughts = info.thoughts || (input.thoughts ?? '');
-
-    this.upsertCompletedTextItem(info, 'message', info.text);
-    this.upsertCompletedTextItem(info, 'reasoning', info.thoughts);
-
-    const actions = [...(input.aiActions ?? [])].sort(
-      (a, b) => (a.order_of_execution ?? 0) - (b.order_of_execution ?? 0),
-    );
-    const db = getDb();
-    for (const action of actions) {
-      if (action.action_type === 'final') info.finalPlain = action.plain ?? null;
-      const mapped = mapActionToItem(action);
-      if (!mapped) continue;
-      const externalId = `${input.id}-action-${action.id}`;
-      const existing = db
-        .prepare('SELECT id FROM items WHERE turn_id = ? AND external_item_id = ?')
-        .get(this.deps.turnId, externalId);
-      if (existing) continue;
-      insertItem(
-        db,
-        this.deps.agentPaneSessionId,
-        this.deps.turnId,
-        externalId,
-        mapped.type,
-        mapped.data,
-        mapped.status,
-        'item:completed',
-      );
-    }
-  }
-}
-
-/** Extract the plain text of a final/html_final action from a snapshot input. */
-function extractFinalPlain(input: RepoburgSessionInput | undefined): string | null {
-  const action = input?.aiActions?.find(
-    (a) => a.action_type === 'final' || a.action_type === 'html_final',
-  );
-  return action?.plain ?? null;
-}

package/agent-pane/backend/src/routes/files.ts

@@ -1,31 +0,0 @@
-import type { FastifyInstance } from 'fastify';
-import { getSharedAppServer } from '../codex/shared-app-server.ts';
-import type { FileSearchResult } from '../codex/app-server-types.ts';
-
-/** Register file search routes. */
-export async function registerFileRoutes(fastify: FastifyInstance): Promise<void> {
-  // GET /api/files/search?q=...&cwd=... — fuzzy file search via app-server
-  fastify.get<{ Querystring: { q?: string; cwd?: string } }>('/api/files/search', async (request) => {
-    const { q = '', cwd = process.cwd() } = request.query;
-
-    if (!q.trim()) {
-      return { entries: [], truncated: false };
-    }
-
-    try {
-      const result = await getSharedAppServer().request<FileSearchResult>('fuzzyFileSearch', {
-        query: q,
-        roots: [cwd],
-      });
-
-      const entries = (result.results ?? []).map((r) => ({
-        path: r.path,
-        kind: r.match_type,
-      }));
-
-      return { entries, truncated: false };
-    } catch {
-      return { entries: [], truncated: false };
-    }
-  });
-}

package/agent-pane/backend/src/routes/mcp.ts

@@ -1,33 +0,0 @@
-import type { FastifyInstance } from 'fastify';
-import type { Extension } from '@agentpane/shared';
-import { getSharedAppServer } from '../codex/shared-app-server.ts';
-import type { McpListResult, AppServerMcpServer } from '../codex/app-server-types.ts';
-
-/** Map an app-server MCP server to the shared Extension type. */
-function mapMcpServer(server: AppServerMcpServer): Extension {
-  return {
-    id: server.name,
-    name: server.serverInfo?.title ?? server.name,
-    description: server.serverInfo?.description ?? '',
-    type: 'mcp-server',
-    enabled: true,
-    metadata: {
-      version: server.serverInfo?.version,
-      authStatus: server.authStatus,
-      hasTools: Boolean(server.tools && Object.keys(server.tools).length > 0),
-    },
-  };
-}
-
-/** Register MCP routes. */
-export async function registerMcpRoutes(fastify: FastifyInstance): Promise<void> {
-  // GET /api/mcp — list all MCP servers from the app-server
-  fastify.get('/api/mcp', async () => {
-    const result = await getSharedAppServer().request<McpListResult>('mcpServerStatus/list', {
-      detail: 'toolsAndAuthOnly',
-    });
-
-    const servers: Extension[] = (result.data ?? []).map(mapMcpServer);
-    return servers;
-  });
-}

package/agent-pane/backend/src/routes/models.test.ts

@@ -1,92 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import Fastify, { type FastifyInstance } from 'fastify';
-import type { ModelInfo } from '@agentpane/shared';
-
-// Mock registry to return a mock provider with getModels()
-const mocks = vi.hoisted(() => ({
-  getModels: vi.fn().mockResolvedValue([]),
-}));
-
-vi.mock('../providers/registry.ts', () => ({
-  getProvider: vi.fn(() => ({
-    getModels: mocks.getModels,
-    startTurn: vi.fn(),
-    interruptTurn: vi.fn(),
-    clearThread: vi.fn(),
-    clearAllThreads: vi.fn(),
-    shutdown: vi.fn(),
-  })),
-  hasProvider: vi.fn(() => true),
-}));
-
-import { registerModelRoutes } from './models.ts';
-import { hasProvider } from '../providers/registry.ts';
-
-const MOCK_MODELS: ModelInfo[] = [
-  {
-    slug: 'gpt-5.6-sol',
-    displayName: 'GPT-5.6-Sol',
-    description: 'Flagship model',
-    defaultReasoning: 'low',
-    reasoningLevels: [
-      { effort: 'low', label: 'Low' },
-      { effort: 'high', label: 'High' },
-    ],
-  },
-  {
-    slug: 'gpt-5.4',
-    displayName: 'GPT-5.4',
-    description: 'Everyday model',
-    defaultReasoning: 'medium',
-    reasoningLevels: [
-      { effort: 'low', label: 'Low' },
-      { effort: 'medium', label: 'Medium' },
-    ],
-  },
-];
-
-describe('Model routes', () => {
-  let app: FastifyInstance;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    vi.mocked(hasProvider).mockReturnValue(true);
-    mocks.getModels.mockResolvedValue(MOCK_MODELS);
-    app = Fastify();
-    await registerModelRoutes(app);
-  });
-
-  describe('GET /api/providers/:id/models', () => {
-    it('returns model list for codex', async () => {
-      const res = await app.inject({ method: 'GET', url: '/api/providers/codex/models' });
-      expect(res.statusCode).toBe(200);
-      const models = res.json();
-      expect(models).toHaveLength(2);
-
-      expect(models[0].slug).toBe('gpt-5.6-sol');
-      expect(models[0].displayName).toBe('GPT-5.6-Sol');
-      expect(models[0].description).toBe('Flagship model');
-      expect(models[0].defaultReasoning).toBe('low');
-      expect(models[0].reasoningLevels).toEqual([
-        { effort: 'low', label: 'Low' },
-        { effort: 'high', label: 'High' },
-      ]);
-    });
-
-    it('returns 404 for unregistered provider', async () => {
-      // Override hasProvider to return false for this test
-      const { hasProvider } = await import('../providers/registry.ts');
-      vi.mocked(hasProvider).mockReturnValue(false);
-      const res = await app.inject({ method: 'GET', url: '/api/providers/unknown/models' });
-      expect(res.statusCode).toBe(404);
-      expect(res.json()).toEqual({ error: 'No models available for provider: unknown' });
-    });
-
-    it('returns empty array when provider getModels fails', async () => {
-      mocks.getModels.mockResolvedValue([]);
-      const res = await app.inject({ method: 'GET', url: '/api/providers/codex/models' });
-      expect(res.statusCode).toBe(200);
-      expect(res.json()).toEqual([]);
-    });
-  });
-});