repoburg 1.3.199 → 1.3.201

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

@@ -0,0 +1,271 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  createSseParser,
+  parseSseFrame,
+  streamAgentRuntimeMessages,
+} from './agent-runtime-client.ts';
+import type { AgentRuntimeMessage } from './agent-runtime-client.ts';
+
+const enc = new TextEncoder();
+
+describe('parseSseFrame', () => {
+  it('extracts a single data line', () => {
+    expect(parseSseFrame('data: {"a":1}')).toBe('{"a":1}');
+  });
+
+  it('strips one optional space after the colon', () => {
+    expect(parseSseFrame('data: {"a":1}')).toBe('{"a":1}');
+    expect(parseSseFrame('data:{"a":1}')).toBe('{"a":1}');
+  });
+
+  it('ignores comment (heartbeat) lines and returns null when no data', () => {
+    expect(parseSseFrame(': ping')).toBeNull();
+    expect(parseSseFrame(': ping\ndata: x')).toBe('x');
+  });
+
+  it('joins multiple data lines with newlines', () => {
+    expect(parseSseFrame('data: a\ndata: b')).toBe('a\nb');
+  });
+});
+
+describe('createSseParser', () => {
+  it('splits complete frames and buffers partial ones across chunks', () => {
+    const parse = createSseParser();
+    expect(parse('data: {"type":"a"}\n\ndata: {"ty')).toEqual(['{"type":"a"}']);
+    expect(parse('pe":"b"}\n\n')).toEqual(['{"type":"b"}']);
+  });
+
+  it('handles CRLF line endings', () => {
+    const parse = createSseParser();
+    expect(parse('data: {"type":"a"}\r\n\r\n')).toEqual(['{"type":"a"}']);
+  });
+
+  it('ignores heartbeat-only frames', () => {
+    const parse = createSseParser();
+    expect(parse(': ping\n\n')).toEqual([]);
+  });
+});
+
+describe('streamAgentRuntimeMessages', () => {
+  const fetchMock = vi.fn();
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    globalThis.fetch = fetchMock as never;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  /** Build an SSE Response body from raw chunks. */
+  function sseBody(chunks: string[], onAbort?: (error: () => void) => void): ReadableStream<Uint8Array> {
+    return new ReadableStream<Uint8Array>({
+      start(controller) {
+        for (const c of chunks) controller.enqueue(enc.encode(c));
+        if (!onAbort) controller.close();
+        else onAbort(() => controller.error(new DOMException('Aborted', 'AbortError')));
+      },
+    });
+  }
+
+  function sseResponse(body: ReadableStream<Uint8Array>): Response {
+    return { ok: true, status: 200, body } as never;
+  }
+
+  const systemFrame = 'data: {"type":"system","subtype":"init","sessionId":"rs-1","modelId":null}\n\n';
+  const assistantFrame = 'data: {"type":"assistant","sessionId":"rs-1","inputId":"in-1","content":[]}\n\n';
+  const resultFrame =
+    'data: {"type":"result","subtype":"success","sessionId":"rs-1","is_error":false,"result":"done","num_rounds":1}\n\n';
+
+  it('delivers messages in order and stops at the terminal result', async () => {
+    fetchMock.mockResolvedValue(
+      sseResponse(sseBody([systemFrame, ': ping\n\n', assistantFrame, resultFrame])),
+    );
+    const messages: AgentRuntimeMessage[] = [];
+    const onActivity = vi.fn();
+
+    const reason = await streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      (m) => messages.push(m),
+      { onActivity, reconnectDelayMs: 1 },
+    );
+
+    expect(reason).toBe('result');
+    expect(messages.map((m) => m.type)).toEqual(['system', 'assistant', 'result']);
+    // Activity fired for the received bytes (chunk coalescing makes the exact
+    // read count implementation-dependent — at least once).
+    expect(onActivity.mock.calls.length).toBeGreaterThanOrEqual(1);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      'http://repoburg.test/agent-runtime/sessions/rs-1/messages?stream=1',
+      expect.objectContaining({ method: 'GET' }),
+    );
+  });
+
+  it('parses frames split across chunk boundaries', async () => {
+    fetchMock.mockResolvedValue(
+      sseResponse(
+        sseBody([
+          'data: {"type":"res',
+          'ult","subtype":"succ',
+          'ess","sessionId":"rs-1","is_error":false,"result":"d","num_rounds":1}\n\n',
+        ]),
+      ),
+    );
+    const messages: AgentRuntimeMessage[] = [];
+
+    const reason = await streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      (m) => messages.push(m),
+      { reconnectDelayMs: 1 },
+    );
+
+    expect(reason).toBe('result');
+    expect(messages).toHaveLength(1);
+    expect(messages[0].type).toBe('result');
+  });
+
+  it('reconnects after the server closes the stream without a result', async () => {
+    fetchMock
+      .mockResolvedValueOnce(sseResponse(sseBody([assistantFrame]))) // closes early
+      .mockResolvedValueOnce(sseResponse(sseBody([resultFrame])));
+    const messages: AgentRuntimeMessage[] = [];
+
+    const reason = await streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      (m) => messages.push(m),
+      { reconnectDelayMs: 1 },
+    );
+
+    expect(reason).toBe('result');
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(messages.map((m) => m.type)).toEqual(['assistant', 'result']);
+  });
+
+  it('reconnects after a fetch failure', async () => {
+    fetchMock
+      .mockRejectedValueOnce(new Error('ECONNREFUSED'))
+      .mockResolvedValueOnce(sseResponse(sseBody([resultFrame])));
+
+    const reason = await streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      () => {},
+      { reconnectDelayMs: 1 },
+    );
+
+    expect(reason).toBe('result');
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('reconnects on non-OK responses other than 404', async () => {
+    fetchMock
+      .mockResolvedValueOnce({ ok: false, status: 502 } as never)
+      .mockResolvedValueOnce(sseResponse(sseBody([resultFrame])));
+
+    const reason = await streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      () => {},
+      { reconnectDelayMs: 1 },
+    );
+
+    expect(reason).toBe('result');
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('returns session-not-found on 404 without retrying', async () => {
+    fetchMock.mockResolvedValue({ ok: false, status: 404 } as never);
+
+    const reason = await streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      () => {},
+      { reconnectDelayMs: 1 },
+    );
+
+    expect(reason).toBe('session-not-found');
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns aborted when the signal is already aborted', async () => {
+    const controller = new AbortController();
+    controller.abort();
+
+    const reason = await streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      () => {},
+      { signal: controller.signal, reconnectDelayMs: 1 },
+    );
+
+    expect(reason).toBe('aborted');
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('returns aborted when the signal aborts mid-stream', async () => {
+    const controller = new AbortController();
+    // Simulate real fetch semantics: aborting errors the body stream.
+    fetchMock.mockResolvedValue(
+      sseResponse(
+        sseBody([assistantFrame], (error) => {
+          controller.signal.addEventListener('abort', () => error());
+        }),
+      ),
+    );
+    const messages: AgentRuntimeMessage[] = [];
+
+    const promise = streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      (m) => messages.push(m),
+      { signal: controller.signal, reconnectDelayMs: 1 },
+    );
+    // Let the first chunk deliver, then abort.
+    await new Promise((r) => setTimeout(r, 10));
+    controller.abort();
+
+    const reason = await promise;
+
+    expect(reason).toBe('aborted');
+    expect(messages.map((m) => m.type)).toEqual(['assistant']);
+  });
+
+  it('skips malformed JSON frames without failing the stream', async () => {
+    fetchMock.mockResolvedValue(
+      sseResponse(sseBody(['data: not-json\n\n', resultFrame])),
+    );
+    const messages: AgentRuntimeMessage[] = [];
+
+    const reason = await streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      (m) => messages.push(m),
+      { reconnectDelayMs: 1 },
+    );
+
+    expect(reason).toBe('result');
+    expect(messages.map((m) => m.type)).toEqual(['result']);
+  });
+
+  it('requests deltas off (?stream=0) when deltas=false', async () => {
+    fetchMock.mockResolvedValue(sseResponse(sseBody([resultFrame])));
+
+    await streamAgentRuntimeMessages(
+      'http://repoburg.test',
+      'rs-1',
+      () => {},
+      { deltas: false, reconnectDelayMs: 1 },
+    );
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'http://repoburg.test/agent-runtime/sessions/rs-1/messages?stream=0',
+      expect.anything(),
+    );
+  });
+});

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

@@ -0,0 +1,262 @@
+/**
+ * Agent-runtime SSE client — consumes the root backend's agent-runtime
+ * message stream (Claude-Code-SDK-style ordered messages):
+ *   GET /agent-runtime/sessions/:sessionId/messages?stream=1
+ *
+ * One JSON message per SSE `data:` line; heartbeat comments (`: ping`) keep
+ * the connection alive and count as activity for the stream watchdog.
+ * The stream ends when the terminal `result` message arrives; connection
+ * drops before it trigger reconnect with backoff until aborted.
+ */
+
+// ---------------------------------------------------------------------------
+// Message types (mirror backend/src/agent-runtime/agent-runtime.types.ts)
+// ---------------------------------------------------------------------------
+
+export interface AgentRuntimeUsage {
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_input_tokens: number;
+  cache_creation_input_tokens: number;
+}
+
+export interface AgentRuntimeActionInfo {
+  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;
+  order_of_execution: number;
+}
+
+export type AgentRuntimeContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'thinking'; thinking: string }
+  | {
+      type: 'tool_use';
+      id: string;
+      name: string;
+      input: Record<string, unknown> | null;
+    };
+
+export interface AgentRuntimeToolResultBlock {
+  type: 'tool_result';
+  tool_use_id: string;
+  content: string;
+  is_error: boolean;
+  action: AgentRuntimeActionInfo;
+}
+
+export interface SystemInitMessage {
+  type: 'system';
+  subtype: 'init';
+  sessionId: string;
+  modelId: string | null;
+}
+
+export interface StreamEventMessage {
+  type: 'stream_event';
+  sessionId: string;
+  inputId: string;
+  delta: { type: 'text' | 'thinking'; text: string };
+}
+
+export interface AssistantMessage {
+  type: 'assistant';
+  sessionId: string;
+  inputId: string;
+  content: AgentRuntimeContentBlock[];
+  usage?: AgentRuntimeUsage;
+}
+
+export interface UserMessage {
+  type: 'user';
+  sessionId: string;
+  inputId: string;
+  content: AgentRuntimeToolResultBlock[];
+}
+
+export interface ResultMessage {
+  type: 'result';
+  subtype: 'success' | 'error_during_execution' | 'aborted';
+  sessionId: string;
+  is_error: boolean;
+  result: string;
+  usage?: AgentRuntimeUsage;
+  num_rounds: number;
+  errors?: string[];
+}
+
+export type AgentRuntimeMessage =
+  | SystemInitMessage
+  | StreamEventMessage
+  | AssistantMessage
+  | UserMessage
+  | ResultMessage;
+
+// ---------------------------------------------------------------------------
+// SSE stream consumer
+// ---------------------------------------------------------------------------
+
+export type MessageHandler = (message: AgentRuntimeMessage) => void;
+
+export interface StreamOptions {
+  /** Aborting closes the connection and stops reconnect attempts. */
+  signal?: AbortSignal;
+  /** false = request the stream without deltas (?stream=0). Default true. */
+  deltas?: boolean;
+  /** Called on ANY received bytes (message or heartbeat) — watchdog reset. */
+  onActivity?: () => void;
+  /** Backoff between reconnect attempts (ms). Default 2000. */
+  reconnectDelayMs?: number;
+}
+
+/** Why the stream ended. */
+export type StreamEndReason = 'result' | 'aborted' | 'session-not-found';
+
+/** Parse one SSE frame (already split on blank line) into its data payload.
+ *  Comment (`:`) and non-data lines are ignored; multiple `data:` lines join. */
+export function parseSseFrame(frame: string): string | null {
+  const dataLines: string[] = [];
+  for (const line of frame.split('\n')) {
+    const trimmed = line.replace(/\r$/, '');
+    if (trimmed.startsWith(':')) continue; // heartbeat comment
+    if (trimmed.startsWith('data:')) {
+      dataLines.push(trimmed.slice(5).replace(/^ /, ''));
+    }
+  }
+  if (dataLines.length === 0) return null;
+  return dataLines.join('\n');
+}
+
+/** Split a raw chunk stream into complete SSE frames. Yields data payloads. */
+export function createSseParser(): (chunk: string) => string[] {
+  let buffer = '';
+  return (chunk: string) => {
+    // Normalize CRLF line endings — frames split on blank LF lines.
+    buffer += chunk.replace(/\r\n/g, '\n');
+    const payloads: string[] = [];
+    let boundary: number;
+    while ((boundary = buffer.indexOf('\n\n')) !== -1) {
+      const frame = buffer.slice(0, boundary);
+      buffer = buffer.slice(boundary + 2);
+      const data = parseSseFrame(frame);
+      if (data !== null) payloads.push(data);
+    }
+    return payloads;
+  };
+}
+
+/**
+ * Consume the agent-runtime message stream for one session until the
+ * terminal `result` message, an abort, or a missing session (404).
+ * Connection drops reconnect with backoff; `onActivity` fires on every
+ * received frame so callers can run a stream watchdog.
+ */
+export async function streamAgentRuntimeMessages(
+  baseUrl: string,
+  sessionId: string,
+  onMessage: MessageHandler,
+  opts: StreamOptions = {},
+): Promise<StreamEndReason> {
+  const deltas = opts.deltas !== false;
+  const delayMs = opts.reconnectDelayMs ?? 2000;
+  const url = `${baseUrl.replace(/\/+$/, '')}/agent-runtime/sessions/${sessionId}/messages?stream=${deltas ? 1 : 0}`;
+
+  for (;;) {
+    if (opts.signal?.aborted) return 'aborted';
+
+    let response: Response;
+    try {
+      response = await fetch(url, { method: 'GET', signal: opts.signal });
+    } catch (err) {
+      if (opts.signal?.aborted || (err as Error).name === 'AbortError') {
+        return 'aborted';
+      }
+      await reconnectDelay(delayMs, opts.signal);
+      continue;
+    }
+
+    if (response.status === 404) return 'session-not-found';
+    if (!response.ok || !response.body) {
+      await reconnectDelay(delayMs, opts.signal);
+      continue;
+    }
+
+    // Read the body frame by frame.
+    const reason: StreamEndReason | null = await readBody(
+      response.body,
+      onMessage,
+      opts,
+    );
+    if (reason !== null) {
+      await response.body.cancel().catch(() => {});
+      return reason;
+    }
+
+    // Server closed the stream without a result — reconnect.
+    await reconnectDelay(delayMs, opts.signal);
+  }
+}
+
+/** Read one response body to its end. Returns a terminal reason or null
+ *  (body ended without result / was aborted → caller reconnects). */
+async function readBody(
+  body: ReadableStream<Uint8Array>,
+  onMessage: MessageHandler,
+  opts: StreamOptions,
+): Promise<StreamEndReason | null> {
+  const parse = createSseParser();
+  const decoder = new TextDecoder();
+  const reader = body.getReader();
+
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) return null;
+      opts.onActivity?.();
+      for (const payload of parse(decoder.decode(value, { stream: true }))) {
+        let message: AgentRuntimeMessage | null = null;
+        try {
+          message = JSON.parse(payload) as AgentRuntimeMessage;
+        } catch {
+          continue; // Malformed frame — skip.
+        }
+        if (!message || typeof message.type !== 'string') continue;
+        onMessage(message);
+        if (message.type === 'result') return 'result';
+      }
+    }
+  } catch (err) {
+    if (opts.signal?.aborted || (err as Error).name === 'AbortError') {
+      return 'aborted';
+    }
+    return null; // Read error — caller reconnects.
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+      // Reader already released.
+    }
+  }
+}
+
+/** Wait the reconnect delay; resolve early when the signal aborts. */
+function reconnectDelay(delayMs: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve();
+    const timer = setTimeout(resolve, delayMs);
+    signal?.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true },
+    );
+  });
+}