repoburg 1.3.202 → 1.3.209

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

@@ -1,261 +0,0 @@
-/**
- * Resolves the repoburg backend instance for a project path via the
- * platform daemon (default http://localhost:9998).
- *
- * The daemon is the platform's process manager (PM2): it spawns one
- * repoburg-backend per workspace with PORT (3400-3999) and
- * REPOBURG_PROJECT_PATH. AgentPane never spawns backends itself.
- *
- * Resolution order:
- *  1. REPOBURG_BACKEND_URL env → direct URL (dev override, daemon skipped)
- *  2. cached resolution re-verified healthy
- *  3. daemon GET /services → healthy running service for the path
- *  4. daemon restart → stopped/dead service for the path
- *  5. daemon POST /services/start → no service yet
- *
- * License auth: the daemon's file-based fallback (~/.repoburg/token.jwt)
- * authorizes same-machine callers without a token.
- */
-
-import path from 'node:path';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** Daemon service row (GET /services). */
-export interface DaemonService {
-  name: string;
-  path: string;
-  port: number;
-  status: 'running' | 'stopped' | 'errored';
-  pid: number | null;
-}
-
-/** Root backend /health payload (projectPath is additive — absent on pre-v2 builds). */
-interface HealthPayload {
-  status: string;
-  projectPath?: string;
-}
-
-/** A resolved backend instance to connect to. */
-export interface ResolvedBackend {
-  baseUrl: string;
-  port: number;
-  name: string;
-}
-
-export interface ResolveOptions {
-  /** false = never start/restart; return null when no healthy instance runs. */
-  autoStart?: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Configuration
-// ---------------------------------------------------------------------------
-
-/** Health probe interval/timeout for freshly started backends (ms). */
-const HEALTH_POLL_INTERVAL_MS = 1000;
-const HEALTH_TIMEOUT_MS = 30_000;
-
-/** Daemon base URL. */
-export function daemonBaseUrl(): string {
-  return (process.env.REPOBURG_DAEMON_URL || 'http://localhost:9998').replace(/\/+$/, '');
-}
-
-// ---------------------------------------------------------------------------
-// HTTP helpers
-// ---------------------------------------------------------------------------
-
-class HttpError extends Error {
-  constructor(
-    readonly status: number,
-    readonly body: string,
-    readonly url: string,
-  ) {
-    super(`${url} failed: ${status} ${body}`);
-  }
-}
-
-/** JSON GET/POST with a timeout. Throws HttpError on non-OK responses. */
-async function fetchJson<T>(url: string, init?: RequestInit, timeoutMs = 5000): Promise<T> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  let response: Response;
-  try {
-    response = await fetch(url, { ...init, signal: controller.signal });
-  } finally {
-    clearTimeout(timer);
-  }
-  const text = await response.text();
-  if (!response.ok) {
-    throw new HttpError(response.status, text, url);
-  }
-  try {
-    return JSON.parse(text) as T;
-  } catch {
-    throw new Error(`Unexpected non-JSON response from ${url}`);
-  }
-}
-
-/** Extract a human message from a daemon HttpError body. */
-function daemonErrorMessage(err: unknown): string {
-  if (err instanceof HttpError) {
-    try {
-      const parsed = JSON.parse(err.body) as { message?: string; error?: string };
-      return parsed.message || parsed.error || err.body;
-    } catch {
-      return err.body;
-    }
-  }
-  return (err as Error).message;
-}
-
-// ---------------------------------------------------------------------------
-// Resolution
-// ---------------------------------------------------------------------------
-
-/** Cached resolutions per resolved project path. */
-const resolvedCache = new Map<string, ResolvedBackend>();
-
-/** Test hook — clear the resolution cache. */
-export function clearResolverCache(): void {
-  resolvedCache.clear();
-}
-
-/** Drop cached resolutions pointing at the given base URL (dead backend). */
-export function invalidateBackend(baseUrl: string): void {
-  for (const [key, value] of resolvedCache) {
-    if (value.baseUrl === baseUrl) resolvedCache.delete(key);
-  }
-}
-
-/**
- * Probe a backend's /health endpoint (short timeout). With expectedPath, a
- * projectPath mismatch means unhealthy: the backend serves a different
- * workspace than the daemon row claims (mis-mapped service).
- */
-async function backendHealthy(baseUrl: string, expectedPath?: string): Promise<boolean> {
-  try {
-    const health = await fetchJson<HealthPayload>(`${baseUrl}/health`, undefined, 2000);
-    if (health.status !== 'ok') return false;
-    if (expectedPath && health.projectPath) {
-      return path.resolve(health.projectPath) === path.resolve(expectedPath);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** Wait until the backend on baseUrl reports healthy (for expectedPath). */
-async function waitForHealthy(baseUrl: string, name: string, expectedPath?: string): Promise<void> {
-  const deadline = Date.now() + HEALTH_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    if (await backendHealthy(baseUrl, expectedPath)) return;
-    await new Promise((resolve) => setTimeout(resolve, HEALTH_POLL_INTERVAL_MS));
-  }
-  throw new Error(
-    `Backend '${name}' on ${baseUrl} did not become healthy within ${HEALTH_TIMEOUT_MS / 1000}s. Check daemon logs: repoburg logs ${name}`,
-  );
-}
-
-function serviceBaseUrl(service: DaemonService): string {
-  return `http://localhost:${service.port}`;
-}
-
-/** Ask the daemon to (re)start the named service. */
-async function restartService(daemon: string, name: string): Promise<void> {
-  try {
-    await fetchJson<DaemonService>(`${daemon}/services/${name}/restart`, { method: 'POST' });
-  } catch (err) {
-    throw new Error(`Daemon failed to restart backend '${name}': ${daemonErrorMessage(err)}`);
-  }
-}
-
-/** Ask the daemon to start a backend for the project path. */
-async function startService(daemon: string, projectPath: string): Promise<DaemonService> {
-  try {
-    return await fetchJson<DaemonService>(`${daemon}/services/start`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ path: projectPath }),
-    });
-  } catch (err) {
-    throw new Error(`Daemon failed to start backend for ${projectPath}: ${daemonErrorMessage(err)}`);
-  }
-}
-
-function cache(absPath: string, service: DaemonService): ResolvedBackend {
-  const resolved: ResolvedBackend = {
-    baseUrl: serviceBaseUrl(service),
-    port: service.port,
-    name: service.name,
-  };
-  resolvedCache.set(absPath, resolved);
-  return resolved;
-}
-
-/**
- * Resolve the backend instance for a project path.
- * Throws on unreachable daemon / start failure; returns null only when
- * autoStart=false and no healthy instance is running.
- */
-export async function resolveBackendUrl(
-  projectPath: string,
-  opts: ResolveOptions = {},
-): Promise<ResolvedBackend | null> {
-  const autoStart = opts.autoStart !== false;
-
-  // 1. Explicit env override — direct connection, daemon skipped.
-  const envUrl = process.env.REPOBURG_BACKEND_URL;
-  if (envUrl) {
-    return { baseUrl: envUrl.replace(/\/+$/, ''), port: 0, name: 'REPOBURG_BACKEND_URL' };
-  }
-
-  const absPath = path.resolve(projectPath);
-  const daemon = daemonBaseUrl();
-
-  // 2. Cached resolution, re-verified healthy (and serving this workspace).
-  const cached = resolvedCache.get(absPath);
-  if (cached && (await backendHealthy(cached.baseUrl, absPath))) {
-    return cached;
-  }
-
-  // 3. Daemon must be reachable.
-  try {
-    await fetchJson(`${daemon}/health`, undefined, 3000);
-  } catch {
-    throw new Error(
-      `Repoburg daemon not reachable at ${daemon}. Start it with 'repoburg-daemon', or set REPOBURG_BACKEND_URL to a running backend.`,
-    );
-  }
-
-  const services = await fetchJson<DaemonService[]>(`${daemon}/services`);
-  const match = services.find((s) => s.path === absPath);
-
-  if (match && match.status === 'running') {
-    if (await backendHealthy(serviceBaseUrl(match), absPath)) {
-      return cache(absPath, match);
-    }
-    if (!autoStart) return null;
-    // Unhealthy or serving a different workspace — the process is wrong
-    // for this path. Restart via the daemon.
-    await restartService(daemon, match.name);
-    await waitForHealthy(serviceBaseUrl(match), match.name, absPath);
-    return cache(absPath, match);
-  }
-
-  if (!autoStart) return null; // stopped/errored/missing — left to the first turn.
-
-  if (match) {
-    await restartService(daemon, match.name);
-    await waitForHealthy(serviceBaseUrl(match), match.name, absPath);
-    return cache(absPath, match);
-  }
-
-  // No service for this path yet — start one.
-  const service = await startService(daemon, absPath);
-  await waitForHealthy(serviceBaseUrl(service), service.name, absPath);
-  return cache(absPath, service);
-}

package/agent-pane/backend/src/repoburg/repoburg-client.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { RepoburgHttpClient } from './repoburg-client.ts';
-
-describe('RepoburgHttpClient (HTTP control surface)', () => {
-  const client = new RepoburgHttpClient('http://repoburg.test');
-
-  const fetchMock = vi.fn();
-  const originalFetch = globalThis.fetch;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    globalThis.fetch = fetchMock as never;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  function ok(body: unknown): Response {
-    return { ok: true, status: 200, text: () => Promise.resolve(JSON.stringify(body)) } as never;
-  }
-
-  function error(status: number, body: unknown): Response {
-    const text = typeof body === 'string' ? body : JSON.stringify(body);
-    return { ok: false, status, text: () => Promise.resolve(text) } as never;
-  }
-
-  it('createSession POSTs the DTO', async () => {
-    fetchMock.mockResolvedValue(ok({ id: 'rs-1' }));
-
-    const session = await client.createSession({
-      session_title: 'T',
-      model_id: 'ollama/glm-5.3:cloud',
-      reasoning_effort: 'high',
-    });
-
-    expect(session.id).toBe('rs-1');
-    expect(fetchMock).toHaveBeenCalledWith(
-      'http://repoburg.test/sessions',
-      expect.objectContaining({
-        method: 'POST',
-        body: JSON.stringify({
-          session_title: 'T',
-          model_id: 'ollama/glm-5.3:cloud',
-          reasoning_effort: 'high',
-        }),
-      }),
-    );
-  });
-
-  it('patchSession PATCHes the DTO', async () => {
-    fetchMock.mockResolvedValue(ok({ id: 'rs-1' }));
-
-    await client.patchSession('rs-1', { model_id: 'ollama/b' });
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      'http://repoburg.test/sessions/rs-1',
-      expect.objectContaining({
-        method: 'PATCH',
-        body: JSON.stringify({ model_id: 'ollama/b' }),
-      }),
-    );
-  });
-
-  it('getSession returns the session incl. is_running', async () => {
-    fetchMock.mockResolvedValue(ok({ id: 'rs-1', session_title: 'T', is_running: true }));
-
-    const session = await client.getSession('rs-1');
-
-    expect(session).toEqual({ id: 'rs-1', session_title: 'T', is_running: true });
-    expect(fetchMock).toHaveBeenCalledWith(
-      'http://repoburg.test/sessions/rs-1',
-      expect.objectContaining({ method: 'GET', body: undefined }),
-    );
-  });
-
-  it('createInput POSTs user_prompt + execution_strategy', async () => {
-    fetchMock.mockResolvedValue(ok({ id: 'in-1' }));
-
-    await client.createInput('rs-1', {
-      user_prompt: 'hello',
-      execution_strategy: 'auto_apply',
-    });
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      'http://repoburg.test/sessions/rs-1/inputs',
-      expect.objectContaining({
-        method: 'POST',
-        body: JSON.stringify({ user_prompt: 'hello', execution_strategy: 'auto_apply' }),
-      }),
-    );
-  });
-
-  it('getSessionInputs GETs the full snapshot', async () => {
-    fetchMock.mockResolvedValue(ok([{ id: 'in-1', role: 'user' }, { id: 'in-2', role: 'model' }]));
-
-    const inputs = await client.getSessionInputs('rs-1');
-
-    expect(inputs).toHaveLength(2);
-    expect(fetchMock).toHaveBeenCalledWith(
-      'http://repoburg.test/sessions/rs-1/inputs',
-      expect.objectContaining({ method: 'GET', body: undefined }),
-    );
-  });
-
-  it('cancel POSTs the streaming cancel endpoint', async () => {
-    fetchMock.mockResolvedValue(ok({ success: true, cancelled: true }));
-
-    const result = await client.cancel('rs-1');
-
-    expect(result).toEqual({ success: true, cancelled: true });
-    expect(fetchMock).toHaveBeenCalledWith(
-      'http://repoburg.test/streaming/rs-1/cancel',
-      expect.objectContaining({ method: 'POST', body: undefined }),
-    );
-  });
-
-  it('getModels unwraps the {models} envelope', async () => {
-    fetchMock.mockResolvedValue(ok({ models: [{ id: 'ollama/glm-5.3:cloud', name: 'glm-5.3:cloud' }] }));
-
-    const models = await client.getModels();
-
-    expect(models).toEqual([{ id: 'ollama/glm-5.3:cloud', name: 'glm-5.3:cloud' }]);
-  });
-
-  it('getModels tolerates a missing envelope', async () => {
-    fetchMock.mockResolvedValue(ok({}));
-
-    const models = await client.getModels();
-
-    expect(models).toEqual([]);
-  });
-it('deleteInputsUntilHere DELETEs the anchor until-here endpoint (204 empty body)', async () => {
-    // The root endpoint replies 204 No Content — must resolve, not throw.
-    fetchMock.mockResolvedValue({ ok: true, status: 204, text: () => Promise.resolve('') } as never);
-
-    await client.deleteInputsUntilHere('rs-1', 'in-9');
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      'http://repoburg.test/sessions/rs-1/inputs/in-9/until-here',
-      expect.objectContaining({ method: 'DELETE', body: undefined }),
-    );
-  });
-
-  it('deleteInputsUntilHere surfaces the 400 summary-in-range error', async () => {
-    fetchMock.mockResolvedValue(
-      error(400, { message: 'Summaries can only be discarded, not deleted.' }),
-    );
-
-    await expect(client.deleteInputsUntilHere('rs-1', 'in-9')).rejects.toThrow(
-      'DELETE /sessions/rs-1/inputs/in-9/until-here failed: 400 {"message":"Summaries can only be discarded, not deleted."}',
-    );
-  });
-
-  it('throws with status + body text on non-OK responses', async () => {
-    fetchMock.mockResolvedValue(error(400, 'Bad request'));
-
-    await expect(client.createInput('rs-1', { user_prompt: 'x', execution_strategy: 'auto_apply' }))
-      .rejects.toThrow('POST /sessions/rs-1/inputs failed: 400 Bad request');
-  });
-
-  it('detects HTML error pages (wrong server) with a clear message', async () => {
-    fetchMock.mockResolvedValue(error(500, '<!doctype html><html><body>500</body></html>'));
-
-    await expect(client.getSession('rs-1')).rejects.toThrow(
-      /HTML response from http:\/\/repoburg\.test — the URL points to the wrong server/,
-    );
-  });
-
-  it('detects non-JSON success responses (wrong server)', async () => {
-    fetchMock.mockResolvedValue(
-      ok(undefined) as never,
-    );
-    fetchMock.mockResolvedValue({ ok: true, status: 200, text: () => Promise.resolve('not json') } as never);
-
-    await expect(client.getModels()).rejects.toThrow(
-      /non-JSON response from http:\/\/repoburg\.test — the URL points to the wrong server/,
-    );
-  });
-});

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

@@ -1,194 +0,0 @@
-/**
- * Repoburg backend runtime client — HTTP-only control surface.
- *
- *   POST /sessions                          create a runtime session
- *   PATCH /sessions/:id                     update model / reasoning
- *   GET  /sessions/:id                      fetch session (title + is_running)
- *   POST /sessions/:id/inputs               start an agent turn
- *   GET  /sessions/:id/inputs               full snapshot (inputs + actions)
- *   GET  /sessions/:id/inputs/:inputId/actions-with-logs
- *   POST /streaming/:sessionId/cancel       abort the in-flight LLM call
- *   GET  /llm-provider/models               model catalog
- *
- * The MESSAGE STREAM lives on the separate agent-runtime SSE channel
- * (agent-runtime-client.ts) — this client is control + snapshot only.
- *
- * Base URL: supplied by the caller — resolved per workspace via the
- * platform daemon (backend-resolver.ts); REPOBURG_BACKEND_URL overrides.
- */
-
-// ---------------------------------------------------------------------------
-// Runtime API types (mirror the backend's DTOs/entities — read-only subset)
-// ---------------------------------------------------------------------------
-
-export interface RepoburgModel {
-  id: string;
-  name: string;
-}
-
-export interface RepoburgSessionDto {
-  session_title?: string;
-  model_id?: string;
-  reasoning_effort?: string;
-}
-
-export interface RepoburgSession {
-  id: string;
-  session_title?: string | null;
-  model_id?: string | null;
-  is_running?: boolean | null;
-}
-
-export interface RepoburgCreateInputDto {
-  user_prompt: string;
-  /** Per-input execution strategy. `auto_apply` keeps actions autonomous. */
-  execution_strategy: string;
-}
-
-export interface RepoburgExecutionLog {
-  output?: string | null;
-  error_message?: string | null;
-}
-
-export interface RepoburgAction {
-  id: string;
-  action_type: string;
-  file_path?: string | null;
-  command_string?: string | null;
-  status: string;
-  server_name?: string | null;
-  tool_name?: string | null;
-  arguments?: string | null;
-  plain?: string | null;
-  /** Raw selections JSON string (ask_user/final) — parsed by the client. */
-  selections?: string | null;
-  reason?: string | null;
-  order_of_execution?: number;
-  executionLogs?: RepoburgExecutionLog[];
-}
-
-export interface RepoburgSessionInput {
-  id: string;
-  session_id: string;
-  role?: string;
-  user_prompt?: string | null;
-  raw_llm_response?: string | null;
-  thoughts?: string | null;
-  input_token_count?: number | null;
-  output_token_count?: number | null;
-  cached_token_count?: number | null;
-  error_message?: string | null;
-  aiActions?: RepoburgAction[];
-}
-
-/** Interface — the provider depends on this, not on the HTTP implementation. */
-export interface RepoburgRuntimeClient {
-  createSession(dto: RepoburgSessionDto): Promise<RepoburgSession>;
-  patchSession(id: string, dto: Partial<RepoburgSessionDto>): Promise<RepoburgSession>;
-  getSession(id: string): Promise<RepoburgSession>;
-  createInput(sessionId: string, dto: RepoburgCreateInputDto): Promise<RepoburgSessionInput>;
-  getInputWithActions(sessionId: string, inputId: string): Promise<RepoburgSessionInput>;
-  /** Full snapshot: all inputs of the session with actions + logs (ASC). */
-  getSessionInputs(sessionId: string): Promise<RepoburgSessionInput[]>;
-  /** Hard-delete every input AFTER the anchor (platform rewind parity). */
-  deleteInputsUntilHere(sessionId: string, anchorInputId: string): Promise<void>;
-  cancel(sessionId: string): Promise<{ success: boolean; cancelled: boolean }>;
-  getModels(): Promise<RepoburgModel[]>;
-}
-
-// ---------------------------------------------------------------------------
-// HTTP implementation
-// ---------------------------------------------------------------------------
-
-/** Default base URL of the repoburg backend. */
-export function defaultRepoburgBaseUrl(): string {
-  return process.env.REPOBURG_BACKEND_URL || 'http://localhost:3000';
-}
-
-/** Detect an HTML response body (error page served by the wrong server). */
-function isHtml(text: string): boolean {
-  return /^\s*<(?:!doctype|html)/i.test(text);
-}
-
-/** HTTP client for the repoburg runtime control API (stateless fetch). */
-export class RepoburgHttpClient implements RepoburgRuntimeClient {
-  private readonly baseUrl: string;
-
-  constructor(baseUrl: string = defaultRepoburgBaseUrl()) {
-    this.baseUrl = baseUrl.replace(/\/+$/, '');
-  }
-
-  /** Perform a JSON request. Throws a concise error on non-OK/non-JSON responses. */
-  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
-    const response = await fetch(`${this.baseUrl}${path}`, {
-      method,
-      headers: { 'Content-Type': 'application/json' },
-      body: body === undefined ? undefined : JSON.stringify(body),
-    });
-    const text = await response.text();
-    if (!response.ok) {
-      if (isHtml(text)) {
-        // An HTML error page means the URL does not serve the repoburg API.
-        throw new Error(
-          `${method} ${path} failed: ${response.status} HTML response from ${this.baseUrl} — the URL points to the wrong server`,
-        );
-      }
-      throw new Error(`${method} ${path} failed: ${response.status} ${text}`);
-    }
-    // Success with no payload — e.g. 204 No Content from the until-here delete.
-    if (text.length === 0) return undefined as unknown as T;
-    try {
-      return JSON.parse(text) as T;
-    } catch {
-      throw new Error(
-        `${method} ${path} failed: non-JSON response from ${this.baseUrl} — the URL points to the wrong server`,
-      );
-    }
-  }
-
-  async createSession(dto: RepoburgSessionDto): Promise<RepoburgSession> {
-    return this.request<RepoburgSession>('POST', '/sessions', dto);
-  }
-
-  async patchSession(id: string, dto: Partial<RepoburgSessionDto>): Promise<RepoburgSession> {
-    return this.request<RepoburgSession>('PATCH', `/sessions/${id}`, dto);
-  }
-
-  async getSession(id: string): Promise<RepoburgSession> {
-    return this.request<RepoburgSession>('GET', `/sessions/${id}`);
-  }
-
-  async createInput(sessionId: string, dto: RepoburgCreateInputDto): Promise<RepoburgSessionInput> {
-    return this.request<RepoburgSessionInput>('POST', `/sessions/${sessionId}/inputs`, dto);
-  }
-
-  async getInputWithActions(sessionId: string, inputId: string): Promise<RepoburgSessionInput> {
-    return this.request<RepoburgSessionInput>(
-      'GET',
-      `/sessions/${sessionId}/inputs/${inputId}/actions-with-logs`,
-    );
-  }
-
-  async getSessionInputs(sessionId: string): Promise<RepoburgSessionInput[]> {
-    return this.request<RepoburgSessionInput[]>('GET', `/sessions/${sessionId}/inputs`);
-  }
-
-  async deleteInputsUntilHere(sessionId: string, anchorInputId: string): Promise<void> {
-    await this.request<unknown>(
-      'DELETE',
-      `/sessions/${sessionId}/inputs/${anchorInputId}/until-here`,
-    );
-  }
-
-  async cancel(sessionId: string): Promise<{ success: boolean; cancelled: boolean }> {
-    return this.request<{ success: boolean; cancelled: boolean }>(
-      'POST',
-      `/streaming/${sessionId}/cancel`,
-    );
-  }
-
-  async getModels(): Promise<RepoburgModel[]> {
-    const result = await this.request<{ models: RepoburgModel[] }>('GET', '/llm-provider/models');
-    return result.models ?? [];
-  }
-}