repoburg 1.3.199 → 1.3.202

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

@@ -0,0 +1,180 @@
+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

@@ -0,0 +1,194 @@
+/**
+ * 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 ?? [];
+  }
+}