repoburg 1.3.199 → 1.3.202

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

@@ -0,0 +1,471 @@
+/**
+ * Repoburg provider — drives the repoburg backend's full agent engine
+ * through TWO channels:
+ *
+ *  - CONTROL (HTTP): session create/patch, input, cancel, models — via
+ *    RepoburgHttpClient (repoburg-client.ts).
+ *  - MESSAGES (SSE): the agent-runtime stream (agent-runtime-client.ts) —
+ *    Claude-Code-style ordered messages projected onto agent-pane items by
+ *    TurnProjector (turn-projector.ts). The terminal `result` message ends
+ *    the turn; ordering is guaranteed by the backend's emission points.
+ *
+ * The repoburg session UUID is persisted in `sessions.external_thread_id`.
+ * Backend lifecycle: the backend instance per workspace is resolved via the
+ * platform daemon (backend-resolver.ts) — started/restarted on demand; the
+ * user never starts a repoburg backend manually.
+ */
+
+import type Database from 'better-sqlite3';
+import type { ModelInfo } from '@agentpane/shared';
+import { getDb } from '../db/index.ts';
+import { broadcast } from '../ws/index.ts';
+import { RepoburgHttpClient } from './repoburg-client.ts';
+import type { RepoburgRuntimeClient } from './repoburg-client.ts';
+import { resolveBackendUrl, invalidateBackend } from './backend-resolver.ts';
+import { setSessionStatus } from './action-mapping.ts';
+import { TurnProjector } from './turn-projector.ts';
+import { streamAgentRuntimeMessages } from './agent-runtime-client.ts';
+import type { Session, Turn } from '../db/schema.ts';
+import type { RuntimeProvider } from '../providers/runtime-provider.ts';
+
+// ---------------------------------------------------------------------------
+// Reasoning-effort mapping (root enum ↔ Ollama think levels)
+// ---------------------------------------------------------------------------
+
+/** Reasoning levels offered for non-Ollama runtime models (full root enum). */
+const REASONING_LEVELS: { effort: string; label: string }[] = [
+  { effort: 'low', label: 'Low' },
+  { effort: 'medium', label: 'Medium' },
+  { effort: 'high', label: 'High' },
+  { effort: 'xhigh', label: 'Extra High' },
+];
+
+/** Ollama `think` accepts only low|medium|high|max|bool — xhigh/minimal/none
+ *  are rejected with 400. Offer only the expressible levels. */
+const OLLAMA_REASONING_LEVELS = REASONING_LEVELS.filter((l) => l.effort !== 'xhigh');
+
+/** Map an agent-pane reasoning level onto a root-backend ReasoningEffort the
+ *  runtime's LLM accepts. The root backend forwards reasoning_effort verbatim
+ *  into the provider call (Ollama `think`), so unsafe levels are clamped or
+ *  omitted: ollama xhigh→high, minimal/none→omit; other providers verbatim. */
+export function mapReasoningEffort(
+  modelId: string | null | undefined,
+  effort: string | null | undefined,
+): string | undefined {
+  if (!effort) return undefined;
+  if (!['xhigh', 'high', 'medium', 'low', 'minimal', 'none'].includes(effort)) return undefined;
+  if (modelId?.startsWith('ollama/')) {
+    if (effort === 'xhigh') return 'high';
+    if (effort === 'low' || effort === 'medium' || effort === 'high') return effort;
+    return undefined; // minimal/none are not expressible via Ollama `think`
+  }
+  return effort;
+}
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+
+/** One running agent-pane turn on a repoburg session. */
+interface ActiveTurn {
+  turnId: string;
+  projector: TurnProjector;
+  /** Aborts the current SSE connection (stall watchdog / interrupt). */
+  sseAbort: AbortController;
+  /** true once the user interrupted — stream loop stops reconnecting. */
+  cancelled: boolean;
+}
+
+/** Per-agent-pane-session runtime state. */
+interface SessionEntry {
+  agentPaneSessionId: string;
+  repoburgSessionId: string;
+  client: RepoburgRuntimeClient;
+  baseUrl: string;
+  /** Last model id pushed to the runtime session (mid-session change detection). */
+  modelId: string | null;
+  /** Last mapped reasoning effort pushed to the runtime session. */
+  reasoningEffort: string | undefined;
+  activeTurn: ActiveTurn | null;
+}
+
+const sessionMap = new Map<string, SessionEntry>();
+
+/** Bytes-level stream watchdog: no bytes (message OR heartbeat) within this
+ *  window → abort the SSE connection and reconnect. */
+const STALLED_STREAM_MS = 60_000;
+
+/** Connection-level failures that mean the backend URL must be re-resolved. */
+function isConnectionError(err: unknown): boolean {
+  const message = String((err as Error)?.message ?? '');
+  return /fetch failed|ECONNREFUSED|ENOTFOUND|ECONNRESET|ETIMEDOUT|EHOSTUNREACH|socket hang up/i.test(
+    message,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Session management
+// ---------------------------------------------------------------------------
+
+/** Create or reuse the runtime session for an agent-pane session. */
+async function ensureSession(
+  session: Session,
+  client: RepoburgRuntimeClient,
+  baseUrl: string,
+): Promise<SessionEntry> {
+  const existing = sessionMap.get(session.id);
+  if (existing) return existing;
+
+  if (session.external_thread_id) {
+    const entry: SessionEntry = {
+      agentPaneSessionId: session.id,
+      repoburgSessionId: session.external_thread_id,
+      client,
+      baseUrl,
+      modelId: session.model ?? null,
+      // undefined forces a re-push on the next turn — heals sessions created
+      // before unsafe effort values (e.g. ollama xhigh) were clamped.
+      reasoningEffort: undefined,
+      activeTurn: null,
+    };
+    sessionMap.set(session.id, entry);
+    return entry;
+  }
+
+  // First turn — create a runtime session carrying model + reasoning config.
+  const mappedEffort = mapReasoningEffort(session.model, session.model_reasoning_effort);
+  const created = await client.createSession({
+    session_title: session.title ?? undefined,
+    model_id: session.model ?? undefined,
+    reasoning_effort: mappedEffort,
+  });
+
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
+    created.id,
+    now,
+    session.id,
+  );
+
+  const entry: SessionEntry = {
+    agentPaneSessionId: session.id,
+    repoburgSessionId: created.id,
+    client,
+    baseUrl,
+    modelId: session.model ?? null,
+    reasoningEffort: mappedEffort,
+    activeTurn: null,
+  };
+  sessionMap.set(session.id, entry);
+  return entry;
+}
+
+// ---------------------------------------------------------------------------
+// Turn lifecycle
+// ---------------------------------------------------------------------------
+
+/** Mark a turn failed and reset the session — used before a projector exists. */
+function failTurnBeforeStart(db: Database.Database, sessionId: string, turnId: string, error: string): void {
+  const now = new Date().toISOString();
+  db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
+    'failed',
+    error,
+    now,
+    turnId,
+  );
+  setSessionStatus(db, sessionId, 0, 'failed', now);
+  broadcast('turn:failed', { sessionId, turnId, error });
+}
+
+/** Fail the active turn — projector closed, stream stopped, state dropped. */
+function failTurn(entry: SessionEntry, error: string): void {
+  const active = entry.activeTurn;
+  if (!active) return;
+  entry.activeTurn = null;
+  active.projector.close();
+  active.sseAbort.abort();
+
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
+    'failed',
+    error,
+    now,
+    active.turnId,
+  );
+  db.prepare('UPDATE items SET status = ?, updated_at = ? WHERE turn_id = ? AND status = ?').run(
+    'failed',
+    now,
+    active.turnId,
+    'in_progress',
+  );
+  setSessionStatus(db, entry.agentPaneSessionId, 0, 'failed', now);
+  broadcast('turn:failed', { sessionId: entry.agentPaneSessionId, turnId: active.turnId, error });
+}
+
+/**
+ * SSE loop — consume the agent-runtime message stream until the projector
+ * finalizes the turn. Handles reconnects (connection drops) and the
+ * bytes-level stall watchdog (silent connection → abort + reconnect).
+ */
+async function runStreamLoop(entry: SessionEntry, projector: TurnProjector): Promise<void> {
+  while (entry.activeTurn?.projector === projector && !projector.isDone) {
+    const active = entry.activeTurn;
+    const controller = new AbortController();
+    active.sseAbort = controller;
+
+    // Bytes watchdog — heartbeats count as activity (server alive).
+    let stallTimer: ReturnType<typeof setTimeout> | null = null;
+    const resetStall = (): void => {
+      if (stallTimer) clearTimeout(stallTimer);
+      stallTimer = setTimeout(() => controller.abort(), STALLED_STREAM_MS);
+    };
+    resetStall();
+
+    const reason = await streamAgentRuntimeMessages(
+      entry.baseUrl,
+      entry.repoburgSessionId,
+      (message) => projector.handle(message),
+      { signal: controller.signal, onActivity: resetStall },
+    );
+
+    if (stallTimer) clearTimeout(stallTimer);
+
+    if (projector.isDone || entry.activeTurn?.projector !== projector) return;
+    if (reason === 'session-not-found') {
+      failTurn(entry, 'Repoburg session no longer exists on the backend.');
+      return;
+    }
+    if (reason === 'aborted') {
+      if (active.cancelled) return; // user interrupt — already finalized.
+      continue; // stall-forced abort → reconnect with a fresh signal.
+    }
+    // reason === 'result' implies projector.isDone (handled above).
+  }
+}
+
+/** Start a repoburg turn. Fire-and-forget — messages stream via SSE. */
+export async function startTurn(session: Session, turn: Turn): Promise<void> {
+  const db = getDb();
+
+  // Phase 0: resolve the workspace's backend instance (daemon-managed).
+  let client: RepoburgRuntimeClient;
+  let baseUrl: string;
+  try {
+    const resolved = await resolveBackendUrl(session.cwd ?? process.cwd());
+    if (!resolved) throw new Error('No repoburg backend resolved.');
+    baseUrl = resolved.baseUrl;
+    client = new RepoburgHttpClient(baseUrl);
+  } catch (err) {
+    failTurnBeforeStart(db, session.id, turn.id, `Failed to resolve repoburg backend: ${(err as Error).message}`);
+    return;
+  }
+
+  // Pinned-session cross-check (belt and braces): a daemon reshuffle may
+  // resolve a different URL than the one pinned in the session entry. The
+  // pinned entry wins until the session ends (deliberate) — log the mismatch.
+  const pinned = sessionMap.get(session.id);
+  if (pinned && pinned.baseUrl !== baseUrl) {
+    console.warn(
+      `[repoburg] resolved backend ${baseUrl} differs from pinned ${pinned.baseUrl} for session ${session.id} — keeping the pinned entry.`,
+    );
+  }
+
+  // Phase 1: ensure the runtime session exists.
+  let entry: SessionEntry;
+  try {
+    entry = await ensureSession(session, client, baseUrl);
+  } catch (err) {
+    if (isConnectionError(err)) invalidateBackend(baseUrl);
+    failTurnBeforeStart(db, session.id, turn.id, `Failed to create repoburg session: ${(err as Error).message}`);
+    return;
+  }
+
+  // Phase 2: push model/reasoning changes (mid-session switches in agent-pane).
+  const wantedModel = session.model ?? null;
+  const wantedEffort = mapReasoningEffort(session.model, session.model_reasoning_effort);
+  if (wantedModel !== entry.modelId || wantedEffort !== entry.reasoningEffort) {
+    try {
+      await entry.client.patchSession(entry.repoburgSessionId, {
+        model_id: wantedModel ?? undefined,
+        reasoning_effort: wantedEffort,
+      });
+      entry.modelId = wantedModel;
+      entry.reasoningEffort = wantedEffort;
+    } catch (err) {
+      console.error(`[repoburg] patchSession failed for ${entry.repoburgSessionId}:`, err);
+    }
+  }
+
+  // Phase 3: mark running + open the message stream.
+  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 });
+
+  const projector = new TurnProjector({
+    agentPaneSessionId: session.id,
+    turnId: turn.id,
+    repoburgSessionId: entry.repoburgSessionId,
+    client: entry.client,
+  });
+  entry.activeTurn = { turnId: turn.id, projector, sseAbort: new AbortController(), cancelled: false };
+
+  // Phase 4: consume the SSE message stream (reconnects internally).
+  runStreamLoop(entry, projector).catch((err) => {
+    console.error('[repoburg] stream loop crashed:', err);
+    failTurn(entry, `Stream loop failed: ${(err as Error).message}`);
+  });
+
+  // Phase 5: start the agent turn on the backend.
+  try {
+    // `auto_apply` keeps actions autonomous (agent-like). It is per-input, so
+    // the backend's global execution-strategy setting stays untouched.
+    await entry.client.createInput(entry.repoburgSessionId, {
+      user_prompt: turn.user_prompt,
+      execution_strategy: 'auto_apply',
+    });
+  } catch (err) {
+    if (isConnectionError(err)) invalidateBackend(entry.baseUrl);
+    failTurn(entry, (err as Error).message);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Provider interface
+// ---------------------------------------------------------------------------
+
+/** Cancel a running turn by agent-pane session id. Returns true if a turn was cancelled. */
+export async function interruptTurn(sessionId: string): Promise<boolean> {
+  const entry = sessionMap.get(sessionId);
+  const active = entry?.activeTurn;
+  if (!entry || !active) return false;
+
+  // Finalize locally at once — the backend's result{aborted} may follow on a
+  // stream we no longer consume.
+  active.cancelled = true;
+  entry.activeTurn = null;
+  active.projector.close();
+  active.sseAbort.abort();
+
+  // Best-effort abort of the in-flight LLM round. Note: this cannot stop
+  // mid-action execution on the runtime side.
+  entry.client
+    .cancel(entry.repoburgSessionId)
+    .catch((err) => console.error('[repoburg] cancel failed:', err));
+
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('aborted', now, active.turnId);
+  db.prepare('UPDATE items SET status = ?, updated_at = ? WHERE turn_id = ? AND status = ?').run(
+    'completed',
+    now,
+    active.turnId,
+    'in_progress',
+  );
+  setSessionStatus(db, sessionId, 0, 'active', now);
+  broadcast('turn:cancelled', { sessionId, turnId: active.turnId });
+
+  return true;
+}
+
+/** Drop a session's active stream (rewind/provider switch) and in-memory state. */
+export function clearThread(sessionId: string): void {
+  const entry = sessionMap.get(sessionId);
+  if (entry?.activeTurn) {
+    const active = entry.activeTurn;
+    entry.activeTurn = null;
+    active.projector.close();
+    active.sseAbort.abort();
+  }
+  sessionMap.delete(sessionId);
+}
+
+/** Parse a turn row's runtime_input_ids (JSON string in DB, array in typed Turn). */
+function parseRuntimeInputIds(turn: Turn): string[] {
+  const raw = (turn as Turn & { runtime_input_ids?: string | string[] | null }).runtime_input_ids;
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw === 'string' && raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return parsed as string[];
+    } catch {
+      // Corrupt JSON — no anchor.
+    }
+  }
+  return [];
+}
+
+/** Truncate the runtime session IN PLACE (platform-parity rewind): hard-delete
+ *  every runtime input after the target turn's LAST runtime input via the
+ *  until-here endpoint. Throws on failure — the caller skips the local rewind.
+ *  forkSession is intentionally NOT implemented for repoburg (a hard-deleted
+ *  session cannot be forked; truncation is the rewind primitive). */
+export async function rewindRuntime(session: Session, targetTurn: Turn): Promise<void> {
+  if (!session.external_thread_id) return; // no runtime session yet — nothing to truncate
+  const anchor = parseRuntimeInputIds(targetTurn).pop();
+  if (!anchor) {
+    throw new Error(
+      'Cannot truncate runtime history — the target turn has no runtime input ids (turn predates rewind support or never ran on repoburg).',
+    );
+  }
+  const entry = sessionMap.get(session.id);
+  let client = entry?.client ?? null;
+  if (!client) {
+    const resolved = await resolveBackendUrl(session.cwd ?? process.cwd());
+    if (!resolved) throw new Error('No repoburg backend resolved.');
+    client = new RepoburgHttpClient(resolved.baseUrl);
+  }
+  await client.deleteInputsUntilHere(session.external_thread_id, anchor);
+}
+
+/** Clear all session state. Used in test cleanup. */
+export function clearAllThreads(): void {
+  for (const entry of sessionMap.values()) {
+    if (entry.activeTurn) {
+      const active = entry.activeTurn;
+      entry.activeTurn = null;
+      active.projector.close();
+      active.sseAbort.abort();
+    }
+  }
+  sessionMap.clear();
+}
+
+/** Fetch available models from the runtime and map to ModelInfo[].
+ *  Never starts a backend (autoStart=false) — empty list until the first turn
+ *  brings a workspace backend up. */
+async function getModels(): Promise<ModelInfo[]> {
+  try {
+    const resolved = await resolveBackendUrl(process.cwd(), { autoStart: false });
+    if (!resolved) return [];
+    const models = await new RepoburgHttpClient(resolved.baseUrl).getModels();
+    return models.map((m) => ({
+      slug: m.id,
+      displayName: m.name,
+      description: 'Repoburg backend',
+      defaultReasoning: 'medium',
+      // Ollama rejects xhigh/minimal/none as `think` — offer only valid levels.
+      reasoningLevels: m.id.startsWith('ollama/') ? OLLAMA_REASONING_LEVELS : REASONING_LEVELS,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+/** Graceful shutdown — abort active streams and clear state. */
+async function shutdown(): Promise<void> {
+  clearAllThreads();
+}
+
+/** Repoburg provider — implements RuntimeProvider. */
+export const repoburgProvider: RuntimeProvider = {
+  startTurn,
+  interruptTurn,
+  clearThread,
+  clearAllThreads,
+  getModels,
+  rewindRuntime,
+  shutdown,
+};