repoburg 1.3.199 → 1.3.201

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

@@ -0,0 +1,537 @@
+/**
+ * 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/providers.test.ts

@@ -15,11 +15,28 @@ describe('Provider routes', () => {
       const res = await app.inject({ method: 'GET', url: '/api/providers' });
       expect(res.statusCode).toBe(200);
       const providers = res.json();
-      expect(providers).toHaveLength(2);
+      expect(providers).toHaveLength(3);
       expect(providers[0].id).toBe('codex');
       expect(providers[0].available).toBe(true);
       expect(providers[1].id).toBe('claude');
       expect(providers[1].available).toBe(true);
+      expect(providers[2].id).toBe('repoburg');
+      expect(providers[2].available).toBe(true);
+    });
+
+    it('repoburg provider has correct capabilities', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/providers' });
+      const repoburg = res.json().find((p: { id: string }) => p.id === 'repoburg');
+      expect(repoburg.label).toBe('Repoburg');
+      expect(repoburg.capabilities.dynamicModels).toBe(true);
+      expect(repoburg.capabilities.skills).toBe(false);
+      expect(repoburg.capabilities.plugins).toBe(false);
+      expect(repoburg.capabilities.mcpServers).toBe(false);
+      expect(repoburg.capabilities.imageAttachments).toBe(false);
+      expect(repoburg.capabilities.sandbox).toBe(false);
+      expect(repoburg.capabilities.webSearch).toBe(false);
+      expect(repoburg.capabilities.networkAccess).toBe(false);
+      expect(repoburg.capabilities.fileReferences).toBe(false);
     });
 
     it('codex provider has all capabilities enabled', async () => {

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

@@ -38,7 +38,25 @@ const CLAUDE_PROVIDER: ProviderDefinition = {
   },
 };
 
-const PROVIDERS: ProviderDefinition[] = [CODEX_PROVIDER, CLAUDE_PROVIDER];
+/** Repoburg provider — the repoburg backend's full agent engine via HTTP/WS. */
+const REPOBURG_PROVIDER: ProviderDefinition = {
+  id: 'repoburg',
+  label: 'Repoburg',
+  available: true,
+  capabilities: {
+    dynamicModels: true,
+    skills: false,
+    plugins: false,
+    mcpServers: false,
+    imageAttachments: false,
+    sandbox: false,
+    webSearch: false,
+    networkAccess: false,
+    fileReferences: false,
+  },
+};
+
+const PROVIDERS: ProviderDefinition[] = [CODEX_PROVIDER, CLAUDE_PROVIDER, REPOBURG_PROVIDER];
 
 /** Register provider routes. */
 export async function registerProviderRoutes(fastify: FastifyInstance): Promise<void> {

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

@@ -87,6 +87,18 @@ export async function registerSessionRoutes(fastify: FastifyInstance): Promise<v
       }));
     }
 
+    // Restore persisted context-window usage so the status-bar counter survives reload.
+    const cuRow = db.prepare('SELECT context_usage FROM sessions WHERE id = ?').get(id) as
+      | { context_usage: string | null }
+      | undefined;
+    if (cuRow?.context_usage) {
+      try {
+        detail.contextUsage = JSON.parse(cuRow.context_usage) as SessionDetail['contextUsage'];
+      } catch {
+        // Corrupt JSON — leave contextUsage unset.
+      }
+    }
+
     return detail;
   });
 

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

@@ -72,16 +72,31 @@ export async function registerThreadRoutes(fastify: FastifyInstance): Promise<vo
       const provider = getProvider(session.runtime_type);
       if (provider.forkSession) {
         try {
-          const anchorTurn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as Turn | undefined;
-          if (anchorTurn) {
-            const forkedSessionId = await provider.forkSession(session, anchorTurn);
-            if (forkedSessionId) {
-              db.prepare('UPDATE discussion_threads SET external_thread_id = ? WHERE id = ?').run(forkedSessionId, threadId);
+          if (!session.external_thread_id) {
+            // No main session to fork from — the thread will start a fresh
+            // isolated session (startTurn skips the resume fallback), so the
+            // main session is never contaminated.
+            console.warn(`[threads] cannot fork for thread ${threadId}: session ${sessionId} has no external_thread_id — thread will start a fresh isolated session`);
+          } else {
+            const anchorTurn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as Turn | undefined;
+            if (anchorTurn) {
+              const forkedSessionId = await provider.forkSession(session, anchorTurn);
+              if (forkedSessionId) {
+                db.prepare('UPDATE discussion_threads SET external_thread_id = ? WHERE id = ?').run(forkedSessionId, threadId);
+                console.log(`[threads] forked to ${forkedSessionId} for thread ${threadId} (session ${sessionId})`);
+              } else {
+                // forkSession returned null — thread will start a fresh isolated
+                // session in startTurn (NOT the main session), so isolation holds.
+                console.warn(`[threads] forkSession returned null for thread ${threadId} (external_thread_id=${session.external_thread_id}, upToMessageId=${anchorTurn.external_turn_id}) — thread will start a fresh isolated session`);
+              }
+            } else {
+              console.warn(`[threads] anchor turn ${turnId} not found for thread ${threadId} — cannot fork`);
             }
           }
         } catch (err) {
           console.error(`[threads] forkSession failed for thread ${threadId}:`, err);
-          // Non-fatal — thread falls back to main session conversation
+          // Non-fatal — thread falls back to a fresh isolated session (NOT the
+          // main session) so the main conversation is never contaminated.
         }
       }