repoburg 1.3.198 → 1.3.201

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

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