repoburg 1.3.188 → 1.3.196

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

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

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

@@ -0,0 +1,259 @@
+/** TypeScript interfaces for the Codex app-server JSON-RPC protocol. */
+
+// --- Skill metadata (from `skills/list`) ---
+
+export interface AppServerSkill {
+  name: string;
+  description: string;
+  path: string;
+  scope: 'user' | 'repo' | 'system' | 'admin';
+  enabled: boolean;
+  displayName?: string;
+  shortDescription?: string;
+  interface?: {
+    displayName?: string;
+    shortDescription?: string;
+    brandColor?: string;
+    defaultPrompt?: string;
+    iconSmall?: string | null;
+    iconLarge?: string | null;
+  };
+}
+
+export interface SkillsListResult {
+  data: Array<{
+    cwd: string;
+    skills: AppServerSkill[];
+    errors: string[];
+  }>;
+}
+
+// --- Model metadata (from `model/list`) ---
+
+export interface AppServerModel {
+  id: string;
+  model: string;
+  displayName: string;
+  description: string;
+  defaultReasoningEffort: string;
+  supportedReasoningEfforts: Array<{
+    reasoningEffort: string;
+    description: string;
+  }>;
+  inputModalities?: string[];
+  isDefault?: boolean;
+  hidden?: boolean;
+}
+
+export interface ModelListResult {
+  data: AppServerModel[];
+  nextCursor: string | null;
+}
+
+// --- Plugin metadata (from `plugin/list`) ---
+
+export interface AppServerPlugin {
+  id: string;
+  name: string;
+  installed: boolean;
+  enabled: boolean;
+  availability: string;
+  localVersion?: string | null;
+  version?: string | null;
+  interface?: {
+    displayName?: string;
+    shortDescription?: string;
+    longDescription?: string;
+    brandColor?: string;
+    developerName?: string;
+    category?: string;
+  };
+}
+
+export interface PluginListResult {
+  marketplaces: Array<{
+    name: string;
+    plugins: AppServerPlugin[];
+  }>;
+}
+
+// --- MCP server metadata (from `mcpServerStatus/list`) ---
+
+export interface AppServerMcpServer {
+  name: string;
+  serverInfo?: {
+    name?: string;
+    title?: string | null;
+    version?: string;
+    description?: string | null;
+  };
+  authStatus?: string;
+  tools?: Record<string, unknown>;
+}
+
+export interface McpListResult {
+  data: AppServerMcpServer[];
+}
+
+// --- File search (from `fuzzyFileSearch`) ---
+
+export interface AppServerFileSearchResult {
+  file_name: string;
+  path: string;
+  match_type: 'file' | 'directory';
+  score: number;
+  root: string;
+}
+
+export interface FileSearchResult {
+  results: AppServerFileSearchResult[];
+}
+
+// --- Thread / Turn ---
+
+export interface ThreadStartParams {
+  cwd: string;
+  approvalPolicy: string;
+  sandbox: string;
+  model?: string;
+}
+
+export interface ThreadStartResult {
+  thread: { id: string };
+}
+
+export interface ThreadResumeParams {
+  threadId: string;
+  cwd: string;
+  approvalPolicy: string;
+  sandbox: string;
+  model?: string;
+}
+
+export interface TurnStartParams {
+  threadId: string;
+  input: Array<{ type: 'text'; text: string } | { type: 'image'; url: string }>;
+  approvalPolicy: string;
+  sandbox: { type: 'read-only' | 'workspace-write' | 'danger-full-access' };
+  model?: string;
+  effort?: string;
+}
+
+export interface TurnStartResult {
+  turn: { id: string };
+}
+
+export interface TurnInterruptParams {
+  threadId: string;
+  turnId: string;
+}
+
+// --- Notification params ---
+
+export interface ItemNotification {
+  threadId: string;
+  turnId: string;
+  item: AppServerItem;
+}
+
+export interface TurnCompletedNotification {
+  threadId: string;
+  turnId: string;
+  usage?: unknown;
+}
+
+export interface TurnFailedNotification {
+  threadId: string;
+  turnId: string;
+  error: { message: string };
+}
+
+/** Params for `item/agentMessage/delta` — incremental text fragment. */
+export interface AgentMessageDeltaNotification {
+  threadId: string;
+  turnId: string;
+  itemId: string;
+  delta: string;
+}
+
+/** CamelCase token usage from app-server (needs mapping to snake_case TokenUsage). */
+export interface AppServerTokenUsageData {
+  totalTokens: number;
+  inputTokens: number;
+  cachedInputTokens: number;
+  cacheWriteInputTokens: number;
+  outputTokens: number;
+  reasoningOutputTokens: number;
+}
+
+/** Params for `thread/tokenUsage/updated` — token usage for a turn. */
+export interface TokenUsageNotification {
+  threadId: string;
+  turnId: string;
+  tokenUsage: {
+    total: AppServerTokenUsageData;
+    last: AppServerTokenUsageData;
+    modelContextWindow: number;
+  };
+}
+
+/** Map app-server camelCase token usage to shared snake_case TokenUsage. */
+export function mapTokenUsage(data: AppServerTokenUsageData): {
+  input_tokens: number;
+  cached_input_tokens: number;
+  cache_write_input_tokens: number;
+  output_tokens: number;
+  reasoning_output_tokens: number;
+} {
+  return {
+    input_tokens: data.inputTokens,
+    cached_input_tokens: data.cachedInputTokens,
+    cache_write_input_tokens: data.cacheWriteInputTokens,
+    output_tokens: data.outputTokens,
+    reasoning_output_tokens: data.reasoningOutputTokens,
+  };
+}
+
+// --- Generic item type (replaces SDK ThreadItem) ---
+
+export interface AppServerItem {
+  id: string;
+  type: string;
+  text?: string;
+  summary?: unknown[];
+  content?: unknown[];
+  command?: string;
+  aggregated_output?: string;
+  exit_code?: number | null;
+  status?: 'in_progress' | 'completed' | 'failed';
+  changes?: unknown;
+  server?: string;
+  tool?: string;
+  arguments?: unknown;
+  result?: unknown;
+  error?: string | null;
+  query?: string;
+  items?: unknown[];
+  message?: string;
+  [key: string]: unknown;
+}
+
+// --- Initialize handshake ---
+
+export interface InitializeParams {
+  clientInfo: {
+    name: string;
+    title: string;
+    version: string;
+  };
+  capabilities: {
+    experimentalApi: boolean;
+  };
+}
+
+export interface InitializeResult {
+  userAgent: string;
+  codexHome: string;
+  platformFamily: string;
+  platformOs: string;
+}

package/agent-pane/backend/src/codex/codex-provider-runtime-config.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// Mock the codex-provider module to get access to getThreadOptions
+// We mock everything except getThreadOptions which we want to test
+
+vi.mock('../db/index.ts', () => ({
+  getDb: vi.fn(),
+  initDb: vi.fn(),
+}));
+
+vi.mock('../ws/index.ts', () => ({
+  broadcast: vi.fn(),
+  initWs: vi.fn(),
+  handleUpgrade: vi.fn(),
+  getWss: vi.fn(),
+}));
+
+vi.mock('./item-mapper.ts', () => ({
+  mapItemData: vi.fn(),
+  getItemStatus: vi.fn(),
+}));
+
+// Import after mocks are set up
+import type { Session } from '@agentpane/shared';
+
+// We need to test getThreadOptions indirectly since it's not exported.
+// Instead, we test the behavior by checking that runtime_config is parsed correctly.
+// Since getThreadOptions is private, we test the parsing logic here.
+
+describe('SessionRuntimeConfig parsing', () => {
+  function parseRuntimeConfig(session: Pick<Session, 'runtime_config'>): Record<string, unknown> | null {
+    if (!session.runtime_config) return null;
+    try {
+      return JSON.parse(session.runtime_config) as Record<string, unknown>;
+    } catch {
+      return null;
+    }
+  }
+
+  it('returns null when runtime_config is null', () => {
+    expect(parseRuntimeConfig({ runtime_config: null })).toBeNull();
+  });
+
+  it('returns parsed config when valid JSON', () => {
+    const config = { sandboxMode: 'read-only', webSearchMode: 'live', networkAccessEnabled: true };
+    expect(parseRuntimeConfig({ runtime_config: JSON.stringify(config) })).toEqual(config);
+  });
+
+  it('returns null when invalid JSON', () => {
+    expect(parseRuntimeConfig({ runtime_config: 'invalid json' })).toBeNull();
+  });
+
+  it('returns empty object when runtime_config is empty string JSON', () => {
+    expect(parseRuntimeConfig({ runtime_config: '{}' })).toEqual({});
+  });
+});

package/agent-pane/backend/src/codex/codex-provider.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// Mock the app-server client to avoid spawning real processes
+vi.mock('../codex/app-server-client.ts', () => ({
+  AppServerClient: vi.fn().mockImplementation(() => ({
+    initialize: vi.fn().mockResolvedValue(undefined),
+    request: vi.fn().mockResolvedValue({ data: [] }),
+    onNotification: vi.fn(),
+    close: vi.fn().mockResolvedValue(undefined),
+    isClosed: vi.fn().mockReturnValue(false),
+    events: { once: vi.fn(), on: vi.fn() },
+  })),
+}));
+
+// Mock the shared app-server to avoid spawning a real process
+vi.mock('../codex/shared-app-server.ts', () => ({
+  getSharedAppServer: vi.fn().mockReturnValue({
+    request: vi.fn().mockResolvedValue({ data: [] }),
+  }),
+  closeSharedAppServer: vi.fn().mockResolvedValue(undefined),
+}));
+
+// Mock broadcast to avoid WebSocket setup
+vi.mock('../ws/index.ts', () => ({
+  broadcast: vi.fn(),
+}));
+
+import { codexProvider } from './codex-provider.ts';
+import type { RuntimeProvider } from '../providers/runtime-provider.ts';
+
+describe('codexProvider', () => {
+  it('implements all RuntimeProvider methods', () => {
+    const provider: RuntimeProvider = codexProvider;
+    expect(typeof provider.startTurn).toBe('function');
+    expect(typeof provider.interruptTurn).toBe('function');
+    expect(typeof provider.clearThread).toBe('function');
+    expect(typeof provider.clearAllThreads).toBe('function');
+    expect(typeof provider.getModels).toBe('function');
+    expect(typeof provider.shutdown).toBe('function');
+  });
+
+  it('getModels returns an array', async () => {
+    const models = await codexProvider.getModels();
+    expect(Array.isArray(models)).toBe(true);
+  });
+
+  it('shutdown calls closeSharedAppServer and clearAllThreads', async () => {
+    await codexProvider.shutdown();
+    // No error thrown — shutdown completed
+    // closeSharedAppServer and clearAllThreads are mocked, so this just verifies no crash
+  });
+
+  it('clearAllThreads does not throw', () => {
+    expect(() => codexProvider.clearAllThreads()).not.toThrow();
+  });
+
+  it('clearThread does not throw for unknown session', () => {
+    expect(() => codexProvider.clearThread('nonexistent')).not.toThrow();
+  });
+});