repoburg 1.3.201 → 1.3.204

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

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

@@ -1,262 +0,0 @@
-/**
- * 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 },
-    );
-  });
-}