repoburg 1.3.201 → 1.3.204

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

@@ -1,271 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest';
-import path from 'node:path';
-import {
-  resolveBackendUrl,
-  daemonBaseUrl,
-  clearResolverCache,
-  invalidateBackend,
-  type DaemonService,
-} from './backend-resolver.ts';
-
-/** Build a daemon service row. */
-function service(partial: Partial<DaemonService> & { port: number }): DaemonService {
-  return {
-    name: partial.name ?? `svc-${partial.port}`,
-    path: partial.path ?? '/tmp/does-not-match',
-    port: partial.port,
-    status: partial.status ?? 'running',
-    pid: partial.pid ?? null,
-  };
-}
-
-/** JSON Response helper. */
-const jsonResponse = (body: unknown, status = 200): Response =>
-  new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
-
-/** Route table for the daemon + backend endpoints. */
-function mockFetchRoutes(routes: Array<{ match: (url: string, method: string) => boolean; respond: () => Response | Promise<Response> }>): Mock {
-  const mock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
-    const url = String(input);
-    const method = init?.method ?? 'GET';
-    for (const route of routes) {
-      if (route.match(url, method)) return route.respond();
-    }
-    return jsonResponse({ error: 'not found' }, 404);
-  });
-  vi.stubGlobal('fetch', mock);
-  return mock;
-}
-
-describe('backend-resolver', () => {
-  const DAEMON = 'http://localhost:9998';
-
-  beforeEach(() => {
-    delete process.env.REPOBURG_BACKEND_URL;
-    delete process.env.REPOBURG_DAEMON_URL;
-    clearResolverCache();
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.useRealTimers();
-  });
-
-  it('daemonBaseUrl defaults to 9998 and honors REPOBURG_DAEMON_URL', () => {
-    expect(daemonBaseUrl()).toBe('http://localhost:9998');
-    process.env.REPOBURG_DAEMON_URL = 'http://localhost:9999/';
-    expect(daemonBaseUrl()).toBe('http://localhost:9999');
-    delete process.env.REPOBURG_DAEMON_URL;
-  });
-
-  it('REPOBURG_BACKEND_URL bypasses the daemon entirely', async () => {
-    process.env.REPOBURG_BACKEND_URL = 'http://localhost:1234/';
-    const fetchMock = mockFetchRoutes([]);
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(resolved?.baseUrl).toBe('http://localhost:1234');
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it('throws a clear error when the daemon is unreachable', async () => {
-    const fetchMock = vi.fn().mockRejectedValue(new Error('fetch failed'));
-    vi.stubGlobal('fetch', fetchMock);
-    await expect(resolveBackendUrl('/tmp/proj')).rejects.toThrow(
-      /daemon not reachable at http:\/\/localhost:9998/,
-    );
-  });
-
-  it('returns a healthy running service matching the project path', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(resolved).toEqual({ baseUrl: 'http://localhost:3402', port: 3402, name: 'proj' });
-    expect(fetchMock).toHaveBeenCalledTimes(3); // daemon health + list + backend health
-  });
-
-  it('reuses the cached resolution without re-listing daemon services', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    await resolveBackendUrl('/tmp/proj');
-    await resolveBackendUrl('/tmp/proj');
-    // Second call: only the cached backend health probe — no daemon calls.
-    expect(fetchMock).toHaveBeenCalledTimes(4);
-    expect(fetchMock.mock.calls.every(([u]) => !String(u).includes('/services'))).toBe(false);
-  });
-
-  it('restarts a running service whose backend died, then returns it', async () => {
-    const abs = path.resolve('/tmp/proj');
-    let backendDead = true;
-    const restartMock = vi.fn();
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      {
-        match: (u) => u === 'http://localhost:3402/health',
-        respond: () => {
-          if (backendDead) return jsonResponse({ error: 'dead' }, 500);
-          return jsonResponse({ status: 'ok' });
-        },
-      },
-      {
-        match: (u, m) => u === `${DAEMON}/services/proj/restart` && m === 'POST',
-        respond: () => {
-          restartMock();
-          backendDead = false;
-          return jsonResponse(service({ path: abs, port: 3402, name: 'proj' }));
-        },
-      },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(restartMock).toHaveBeenCalledTimes(1);
-    expect(resolved?.baseUrl).toBe('http://localhost:3402');
-  });
-
-  it('restarts a stopped service for the path', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj', status: 'stopped' })]),
-      },
-      {
-        match: (u, m) => u === `${DAEMON}/services/proj/restart` && m === 'POST',
-        respond: () => jsonResponse(service({ path: abs, port: 3402, name: 'proj' })),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(resolved?.baseUrl).toBe('http://localhost:3402');
-    expect(fetchMock.mock.calls.some(([u, i]) => String(u).endsWith('/services/proj/restart') && (i as RequestInit)?.method === 'POST')).toBe(true);
-  });
-
-  it('starts a new backend via the daemon when no service matches', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      { match: (u) => u === `${DAEMON}/services`, respond: () => jsonResponse([]) },
-      {
-        match: (u, m) => u === `${DAEMON}/services/start` && m === 'POST',
-        respond: () => jsonResponse(service({ path: abs, port: 3410, name: 'proj' }), 201),
-      },
-      { match: (u) => u === 'http://localhost:3410/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    const resolved = await resolveBackendUrl('/tmp/proj');
-    expect(resolved).toEqual({ baseUrl: 'http://localhost:3410', port: 3410, name: 'proj' });
-
-    const startCall = fetchMock.mock.calls.find(([u]) => String(u).endsWith('/services/start'));
-    expect(JSON.parse((startCall![1] as RequestInit).body as string)).toEqual({ path: abs });
-  });
-
-  it('surfaces the daemon message when start fails (e.g. 401 unauthorized)', async () => {
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      { match: (u) => u === `${DAEMON}/services`, respond: () => jsonResponse([]) },
-      {
-        match: (u) => u === `${DAEMON}/services/start`,
-        respond: () => jsonResponse({ error: 'Unauthorized', message: 'Please run repoburg login' }, 401),
-      },
-    ]);
-
-    await expect(resolveBackendUrl('/tmp/proj')).rejects.toThrow(/Please run repoburg login/);
-  });
-
-  it('autoStart=false returns null for stopped or missing services, resolves running ones', async () => {
-    const abs = path.resolve('/tmp/proj');
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj', status: 'stopped' })]),
-      },
-    ]);
-    expect(await resolveBackendUrl('/tmp/proj', { autoStart: false })).toBeNull();
-    expect(await resolveBackendUrl('/tmp/other', { autoStart: false })).toBeNull();
-
-    clearResolverCache();
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-    const resolved = await resolveBackendUrl('/tmp/proj', { autoStart: false });
-    expect(resolved?.baseUrl).toBe('http://localhost:3402');
-  });
-
-  it('autoStart=false returns null when the running backend is unhealthy (no restart)', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ error: 'dead' }, 500) },
-    ]);
-
-    expect(await resolveBackendUrl('/tmp/proj', { autoStart: false })).toBeNull();
-    expect(fetchMock.mock.calls.some(([u]) => String(u).includes('restart'))).toBe(false);
-  });
-
-  it('invalidateBackend drops the cache entry so the daemon is re-consulted', async () => {
-    const abs = path.resolve('/tmp/proj');
-    const fetchMock = mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      {
-        match: (u) => u === `${DAEMON}/services`,
-        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
-      },
-      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok' }) },
-    ]);
-
-    const first = await resolveBackendUrl('/tmp/proj');
-    invalidateBackend(first!.baseUrl);
-    await resolveBackendUrl('/tmp/proj');
-    // Re-consulted the daemon after invalidation: 3 (first flow) + 3 (second flow).
-    expect(fetchMock).toHaveBeenCalledTimes(6);
-  });
-
-  it('throws when a freshly started backend never becomes healthy', async () => {
-    vi.useFakeTimers();
-    const abs = path.resolve('/tmp/proj');
-    mockFetchRoutes([
-      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
-      { match: (u) => u === `${DAEMON}/services`, respond: () => jsonResponse([]) },
-      {
-        match: (u) => u === `${DAEMON}/services/start`,
-        respond: () => jsonResponse(service({ path: abs, port: 3410, name: 'proj' }), 201),
-      },
-      { match: (u) => u === 'http://localhost:3410/health', respond: () => jsonResponse({ error: 'dead' }, 500) },
-    ]);
-
-    const promise = resolveBackendUrl('/tmp/proj');
-    const assertion = expect(promise).rejects.toThrow(/did not become healthy within 30s/);
-    await vi.advanceTimersByTimeAsync(31_000);
-    await assertion;
-  });
-});

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

@@ -1,246 +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;
-}
-
-/** 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). */
-async function backendHealthy(baseUrl: string): Promise<boolean> {
-  try {
-    await fetchJson(`${baseUrl}/health`, undefined, 2000);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** Wait until the backend on baseUrl reports healthy. */
-async function waitForHealthy(baseUrl: string, name: string): Promise<void> {
-  const deadline = Date.now() + HEALTH_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    if (await backendHealthy(baseUrl)) 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.
-  const cached = resolvedCache.get(absPath);
-  if (cached && (await backendHealthy(cached.baseUrl))) {
-    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))) {
-      return cache(absPath, match);
-    }
-    if (!autoStart) return null;
-    // Healthy check failed — the process died. Restart via the daemon.
-    await restartService(daemon, match.name);
-    await waitForHealthy(serviceBaseUrl(match), match.name);
-    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);
-    return cache(absPath, match);
-  }
-
-  // No service for this path yet — start one.
-  const service = await startService(daemon, absPath);
-  await waitForHealthy(serviceBaseUrl(service), service.name);
-  return cache(absPath, service);
-}

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

@@ -1,159 +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('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/,
-    );
-  });
-});