repoburg 1.3.202 → 1.3.204

package/agent-pane/backend/src/claude/claude-types.ts

@@ -1,45 +0,0 @@
-/**
- * Type re-exports and interfaces for the Claude provider.
- *
- * Re-exports needed types from `@anthropic-ai/claude-agent-sdk` so the
- * provider file does not import the SDK directly.
- */
-
-import type {
-  Query,
-  SDKMessage,
-  Options,
-  ModelInfo as SdkModelInfo,
-  SDKControlInitializeResponse,
-  EffortLevel,
-  SDKUserMessage,
-} from '@anthropic-ai/claude-agent-sdk';
-
-export type { Query, SDKMessage, Options, EffortLevel, SdkModelInfo, SDKControlInitializeResponse, SDKUserMessage };
-
-/** Structural type for the PromptQueue — avoids circular imports. */
-export interface PromptQueueLike {
-  push(message: SDKUserMessage): void;
-  close(): void;
-}
-
-/** Per-session Claude query instance + streaming-input state. */
-export interface ClaudeSessionEntry {
-  query: Query;
-  sessionId: string | null;       // Claude session ID from SDKSystemMessage init
-  turnId: string | null;           // current AgentPane turn ID
-  cwd: string;                     // session working directory — used to construct Monitor output paths
-  promptQueue: PromptQueueLike;    // async iterable feeding user messages to the CLI
-  messageLoop: Promise<void> | null; // background for-await loop consuming SDK messages
-  /** Thread ID if this entry is for a branched thread conversation (null = main session). */
-  threadId?: string | null;
-}
-
-/** Map SDK effort values to UI labels. */
-export const EFFORT_LABELS: Record<string, string> = {
-  low: 'Low',
-  medium: 'Medium',
-  high: 'High',
-  xhigh: 'Extra High',
-  max: 'Max',
-};

package/agent-pane/backend/src/codex/app-server-client.test.ts

@@ -1,183 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { PassThrough } from 'node:stream';
-import { EventEmitter } from 'node:events';
-
-// Mock child_process.spawn to return a fake process with controllable streams
-const mockStdin = new PassThrough();
-const mockStdout = new PassThrough();
-const mockStderr = new PassThrough();
-const mockProc = new EventEmitter() as EventEmitter & {
-  stdin: PassThrough;
-  stdout: PassThrough;
-  stderr: PassThrough;
-  kill: ReturnType<typeof vi.fn>;
-  pid: number;
-};
-mockProc.stdin = mockStdin;
-mockProc.stdout = mockStdout;
-mockProc.stderr = mockStderr;
-mockProc.kill = vi.fn();
-mockProc.pid = 12345;
-
-vi.mock('node:child_process', () => ({
-  spawn: vi.fn(() => mockProc),
-}));
-
-import { AppServerClient } from './app-server-client.ts';
-
-// Capture lines written to stdin
-let stdinLines: string[] = [];
-mockStdin.on('data', (chunk: Buffer) => {
-  const text = chunk.toString();
-  for (const line of text.split('\n')) {
-    if (line.trim()) stdinLines.push(line);
-  }
-});
-
-/** Push a JSON-RPC response line to the mock stdout. */
-function pushResponse(id: number, result: unknown): void {
-  mockStdout.push(JSON.stringify({ id, result }) + '\n');
-}
-
-/** Push a JSON-RPC notification to the mock stdout. */
-function pushNotification(method: string, params: unknown): void {
-  mockStdout.push(JSON.stringify({ method, params }) + '\n');
-}
-
-describe('AppServerClient', () => {
-  let client: AppServerClient;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    stdinLines = [];
-    mockProc.removeAllListeners();
-    mockProc.kill = vi.fn();
-    // Re-attach exit handler support
-    client = new AppServerClient({ cwd: '/tmp' });
-  });
-
-  afterEach(async () => {
-    await client.close();
-  });
-
-  it('initialize sends request and notification', async () => {
-    const initPromise = client.initialize();
-
-    // Wait for the initialize request to be written
-    await new Promise((r) => setTimeout(r, 10));
-
-    // First line should be the initialize request
-    const initReq = JSON.parse(stdinLines[0]);
-    expect(initReq.method).toBe('initialize');
-    expect(initReq.id).toBe(1);
-    expect(initReq.params.clientInfo.name).toBe('agentpane');
-
-    // Send initialize response
-    pushResponse(1, {
-      userAgent: 'test/0.147.0',
-      codexHome: '/tmp/.codex',
-      platformFamily: 'unix',
-      platformOs: 'macos',
-    });
-
-    const result = await initPromise;
-    expect(result.userAgent).toBe('test/0.147.0');
-
-    // Second line should be the initialized notification
-    const initNotify = JSON.parse(stdinLines[1]);
-    expect(initNotify.method).toBe('initialized');
-    expect(initNotify.id).toBeUndefined();
-  });
-
-  it('request resolves with result when matching response arrives', async () => {
-    const promise = client.request('model/list', {});
-
-    await new Promise((r) => setTimeout(r, 10));
-    const req = JSON.parse(stdinLines[0]);
-    expect(req.method).toBe('model/list');
-
-    pushResponse(req.id, { data: [{ id: 'gpt-5', displayName: 'GPT-5' }], nextCursor: null });
-
-    const result = await promise;
-    expect(result).toEqual({ data: [{ id: 'gpt-5', displayName: 'GPT-5' }], nextCursor: null });
-  });
-
-  it('request rejects on error response', async () => {
-    const promise = client.request('unknown/method', {});
-
-    await new Promise((r) => setTimeout(r, 10));
-    const req = JSON.parse(stdinLines[0]);
-
-    mockStdout.push(JSON.stringify({ id: req.id, error: { code: -32600, message: 'Invalid request' } }) + '\n');
-
-    await expect(promise).rejects.toThrow('JSON-RPC error -32600: Invalid request');
-  });
-
-  it('notify sends notification without expecting response', async () => {
-    client.notify('initialized');
-
-    await new Promise((r) => setTimeout(r, 10));
-    const msg = JSON.parse(stdinLines[0]);
-    expect(msg.method).toBe('initialized');
-    expect(msg.id).toBeUndefined();
-  });
-
-  it('onNotification handler is called when notification arrives', async () => {
-    const handler = vi.fn();
-    client.onNotification('item/completed', handler);
-
-    pushNotification('item/completed', { threadId: 't1', turnId: 'turn1', item: { id: 'i1', type: 'agent_message' } });
-
-    await new Promise((r) => setTimeout(r, 10));
-    expect(handler).toHaveBeenCalledTimes(1);
-    expect(handler).toHaveBeenCalledWith({
-      threadId: 't1',
-      turnId: 'turn1',
-      item: { id: 'i1', type: 'agent_message' },
-    });
-  });
-
-  it('process exit rejects all pending requests', async () => {
-    const promise1 = client.request('slow/method', {});
-    const promise2 = client.request('another/method', {});
-
-    await new Promise((r) => setTimeout(r, 10));
-
-    // Simulate process exit
-    mockProc.emit('exit', 1, null);
-
-    await expect(promise1).rejects.toThrow('App-server process exited');
-    await expect(promise2).rejects.toThrow('App-server process exited');
-  });
-
-  it('malformed JSON is ignored without crash', async () => {
-    pushNotification('item/completed', { item: { id: 'i1' } });
-
-    // Push malformed JSON line
-    mockStdout.push('not valid json\n');
-
-    // Should not crash — next valid message still works
-    const handler = vi.fn();
-    client.onNotification('test/method', handler);
-    pushNotification('test/method', { ok: true });
-
-    await new Promise((r) => setTimeout(r, 10));
-    expect(handler).toHaveBeenCalledTimes(1);
-  });
-
-  it('close rejects pending requests and kills process', async () => {
-    const promise = client.request('slow/method', {});
-
-    await new Promise((r) => setTimeout(r, 10));
-    await client.close();
-
-    await expect(promise).rejects.toThrow('AppServerClient closed');
-    expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
-  });
-
-  it('isClosed returns true after close', async () => {
-    expect(client.isClosed()).toBe(false);
-    await client.close();
-    expect(client.isClosed()).toBe(true);
-  });
-});

package/agent-pane/backend/src/codex/app-server-client.ts

@@ -1,247 +0,0 @@
-/** JSON-RPC 2.0 client over stdio for the Codex app-server. */
-
-import { spawn, type ChildProcess } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import type { InitializeParams, InitializeResult } from './app-server-types.ts';
-
-/** Request timeout in milliseconds. */
-const REQUEST_TIMEOUT_MS = 30_000;
-
-/** Pending request entry. */
-interface PendingRequest {
-  resolve: (value: unknown) => void;
-  reject: (error: Error) => void;
-  timer: ReturnType<typeof setTimeout>;
-}
-
-/** Options for constructing an AppServerClient. */
-export interface AppServerClientOptions {
-  /** Path to the codex binary. Defaults to 'codex'. */
-  binaryPath?: string;
-  /** Working directory for the app-server process. */
-  cwd: string;
-  /** Environment variables for the child process. */
-  env?: Record<string, string>;
-  /** Additional launch args (e.g. ['--config', 'key=value']). */
-  launchArgs?: string[];
-  /** Client info sent in the initialize handshake. */
-  clientInfo?: { name: string; title: string; version: string };
-}
-
-/**
- * JSON-RPC 2.0 client that communicates with `codex app-server` over stdio.
- *
- * Each message is one JSON object per line. Requests have an `id` field;
- * notifications do not. Responses are matched by `id`.
- */
-export class AppServerClient {
-  private readonly proc: ChildProcess;
-  private nextId = 1;
-  private readonly pending = new Map<number, PendingRequest>();
-  private readonly notificationHandlers = new Map<string, Array<(params: unknown) => void>>();
-  private readonly requestHandlers = new Map<string, Array<(params: unknown) => Promise<unknown>>>();
-  private buffer = '';
-  private closed = false;
-  private readonly clientInfo: { name: string; title: string; version: string };
-  readonly events = new EventEmitter();
-
-  constructor(options: AppServerClientOptions) {
-    const binary = options.binaryPath ?? 'codex';
-    const args = ['app-server', ...(options.launchArgs ?? [])];
-
-    this.proc = spawn(binary, args, {
-      cwd: options.cwd,
-      env: { ...process.env, ...options.env },
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    this.clientInfo = options.clientInfo ?? { name: 'agentpane', title: 'AgentPane', version: '1.0.0' };
-
-    this.proc.stdout?.setEncoding('utf-8');
-    this.proc.stdout?.on('data', (chunk: string) => this.onStdoutData(chunk));
-    this.proc.stderr?.on('data', (chunk: Buffer) => {
-      // Log stderr lines for debugging — app-server may emit diagnostic info
-      const text = chunk.toString().trim();
-      if (text) console.error('[app-server] stderr:', text);
-    });
-
-    this.proc.on('exit', (code, signal) => {
-      this.onProcessExit(code, signal);
-    });
-
-    // Handle spawn errors (e.g. binary not found → ENOENT). Without this listener,
-    // an unhandled 'error' event crashes the entire process. See onProcessError.
-    this.proc.on('error', (err: Error) => {
-      this.onProcessError(err);
-    });
-  }
-
-  /** Perform the initialize handshake. Must be called before any other method. */
-  async initialize(): Promise<InitializeResult> {
-    const params: InitializeParams = {
-      clientInfo: this.clientInfo,
-      capabilities: { experimentalApi: true },
-    };
-    const result = await this.request<InitializeResult>('initialize', params);
-    this.notify('initialized');
-    return result;
-  }
-
-  /** Send a JSON-RPC request and wait for the response. */
-  request<T>(method: string, params?: unknown): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      if (this.closed) {
-        reject(new Error('AppServerClient is closed'));
-        return;
-      }
-
-      const id = this.nextId++;
-      const message = JSON.stringify({ id, method, params }) + '\n';
-
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`Request '${method}' (id=${id}) timed out after ${REQUEST_TIMEOUT_MS}ms`));
-      }, REQUEST_TIMEOUT_MS);
-
-      this.pending.set(id, {
-        resolve: resolve as (value: unknown) => void,
-        reject,
-        timer,
-      });
-
-      this.write(message);
-    });
-  }
-
-  /** Send a JSON-RPC notification (no response expected). */
-  notify(method: string, params?: unknown): void {
-    if (this.closed) return;
-    const message = JSON.stringify({ method, params }) + '\n';
-    this.write(message);
-  }
-
-  /** Register a handler for a server→client notification. */
-  onNotification(method: string, handler: (params: unknown) => void): void {
-    const handlers = this.notificationHandlers.get(method) ?? [];
-    handlers.push(handler);
-    this.notificationHandlers.set(method, handlers);
-  }
-
-  /** Register a handler for a server→client request. */
-  onRequest(method: string, handler: (params: unknown) => Promise<unknown>): void {
-    const handlers = this.requestHandlers.get(method) ?? [];
-    handlers.push(handler);
-    this.requestHandlers.set(method, handlers);
-  }
-
-  /** Check if the client is closed (process exited or close() called). */
-  isClosed(): boolean {
-    return this.closed;
-  }
-
-  /** Close the client and kill the app-server process. */
-  async close(): Promise<void> {
-    if (this.closed) return;
-    this.closed = true;
-
-    // Reject all pending requests
-    for (const [id, entry] of this.pending) {
-      clearTimeout(entry.timer);
-      entry.reject(new Error('AppServerClient closed'));
-      this.pending.delete(id);
-    }
-
-    // Kill the process
-    this.proc.kill('SIGTERM');
-  }
-
-  // --- Internal methods ---
-
-  private write(message: string): void {
-    this.proc.stdin?.write(message);
-  }
-
-  private onStdoutData(chunk: string): void {
-    this.buffer += chunk;
-    const lines = this.buffer.split('\n');
-    this.buffer = lines.pop() ?? '';
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      this.handleMessage(trimmed);
-    }
-  }
-
-  private handleMessage(raw: string): void {
-    let msg: Record<string, unknown>;
-    try {
-      msg = JSON.parse(raw) as Record<string, unknown>;
-    } catch {
-      // Ignore malformed JSON lines
-      return;
-    }
-
-    // Response to a request (has `id` + `result` or `error`)
-    if ('id' in msg && typeof msg.id === 'number') {
-      const pending = this.pending.get(msg.id);
-      if (!pending) return;
-
-      clearTimeout(pending.timer);
-      this.pending.delete(msg.id);
-
-      if (msg.error) {
-        const err = msg.error as { code: number; message: string };
-        pending.reject(new Error(`JSON-RPC error ${err.code}: ${err.message}`));
-      } else {
-        pending.resolve(msg.result);
-      }
-      return;
-    }
-
-    // Notification (has `method` but no `id`)
-    if ('method' in msg && typeof msg.method === 'string') {
-      const handlers = this.notificationHandlers.get(msg.method);
-      if (handlers) {
-        for (const handler of handlers) {
-          handler(msg.params);
-        }
-      }
-      this.events.emit('notification', msg.method, msg.params);
-      return;
-    }
-  }
-
-  private onProcessExit(code: number | null, signal: NodeJS.Signals | null): void {
-    if (this.closed) return;
-    this.closed = true;
-
-    const reason = signal ? `signal ${signal}` : `code ${code}`;
-    const error = new Error(`App-server process exited (${reason})`);
-
-    for (const [, entry] of this.pending) {
-      clearTimeout(entry.timer);
-      entry.reject(error);
-    }
-    this.pending.clear();
-
-    this.events.emit('closed', reason);
-  }
-
-  /** Handle a spawn/runtime error on the child process (e.g. ENOENT when the
-   *  binary is missing). Rejects pending requests and emits 'closed' so callers
-   *  can fail gracefully instead of crashing the whole process. */
-  private onProcessError(err: Error): void {
-    if (this.closed) return;
-    this.closed = true;
-
-    for (const [, entry] of this.pending) {
-      clearTimeout(entry.timer);
-      entry.reject(err);
-    }
-    this.pending.clear();
-
-    this.events.emit('closed', err.message);
-  }
-}
-