repoburg 1.3.188 → 1.3.196

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

@@ -0,0 +1,482 @@
+/**
+ * Claude provider — implements the RuntimeProvider interface.
+ *
+ * Uses `@anthropic-ai/claude-agent-sdk` `query()` function directly.
+ * The SDK spawns the Claude CLI internally — no manual subprocess.
+ *
+ * Same WebSocket event protocol as Codex:
+ *   turn:started, item:started, item:completed, item:delta,
+ *   turn:completed, turn:tokenUsage, turn:failed, turn:cancelled
+ *
+ * Frontend needs zero changes.
+ */
+
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import type { SDKMessage, Options, ModelInfo as SdkModelInfo, Query } from '@anthropic-ai/claude-agent-sdk';
+import type { ModelInfo, TokenUsage } from '@agentpane/shared';
+import { v4 as uuidv4 } from 'uuid';
+import type Database from 'better-sqlite3';
+import { getDb } from '../db/index.ts';
+import { broadcast } from '../ws/index.ts';
+import { mapAssistantContent, mapPartialDelta, mapUsage, type ItemDescriptor } from './claude-message-mapper.ts';
+import { EFFORT_LABELS, type ClaudeSessionEntry } from './claude-types.ts';
+import type { Session, Turn, Item, ItemStatus } from '../db/schema.ts';
+import type { RuntimeProvider } from '../providers/runtime-provider.ts';
+
+/** Per-session Claude query instances. */
+const sessionMap = new Map<string, ClaudeSessionEntry>();
+
+/** Sessions currently generating titles — prevents duplicate throwaway queries. */
+const titleGenerating = new Set<string>();
+
+/** Cached model list from the SDK. */
+let cachedModels: ModelInfo[] | null = null;
+
+// ---------------------------------------------------------------------------
+// DB helpers (same pattern as codex-provider)
+// ---------------------------------------------------------------------------
+
+/** Update the running state and status of a session. */
+function setSessionStatus(
+  db: Database.Database,
+  sessionId: string,
+  isRunning: 0 | 1,
+  status: string,
+  now: string,
+  hasUnreviewed = false,
+): void {
+  if (hasUnreviewed) {
+    db.prepare('UPDATE sessions SET is_running = ?, status = ?, has_unreviewed = 1, updated_at = ? WHERE id = ?').run(
+      isRunning, status, now, sessionId,
+    );
+  } else {
+    db.prepare('UPDATE sessions SET is_running = ?, status = ?, updated_at = ? WHERE id = ?').run(
+      isRunning, status, now, sessionId,
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// startTurn
+// ---------------------------------------------------------------------------
+
+/** Start a Claude turn. Fire-and-forget — streams events via WS. */
+async function startTurn(session: Session, turn: Turn): Promise<void> {
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  // Update turn + session status
+  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('running', now, turn.id);
+  setSessionStatus(db, session.id, 1, 'running', now);
+  broadcast('turn:started', { sessionId: session.id, turnId: turn.id });
+
+  // Build options
+  const options: Options = {
+    cwd: session.cwd ?? process.cwd(),
+    model: session.model ?? undefined,
+    permissionMode: 'bypassPermissions',
+    allowDangerouslySkipPermissions: true,
+    includePartialMessages: true,
+    ...(process.env.CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.CLAUDE_BIN } : {}),
+    ...(session.model_reasoning_effort ? { effort: session.model_reasoning_effort as Options['effort'] } : {}),
+    ...(session.external_thread_id ? { resume: session.external_thread_id } : {}),
+  };
+
+  let q;
+  try {
+    q = query({ prompt: turn.user_prompt, options });
+  } catch (err) {
+    const errMsg = `Failed to start Claude query: ${(err as Error).message}`;
+    const now2 = new Date().toISOString();
+    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run('failed', errMsg, now2, turn.id);
+    setSessionStatus(db, session.id, 0, 'failed', now2);
+    broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
+    return;
+  }
+
+  const entry: ClaudeSessionEntry = { query: q, sessionId: null, turnId: turn.id };
+  sessionMap.set(session.id, entry);
+
+  // Iterate the async generator
+  try {
+    for await (const message of q) {
+      await handleMessage(message, session.id, turn.id, entry, db);
+    }
+
+    // If turn is still running after generator ends, mark as completed
+    const currentTurn = db.prepare('SELECT status FROM turns WHERE id = ?').get(turn.id) as { status: string } | undefined;
+    if (currentTurn && currentTurn.status === 'running') {
+      completeTurn(db, session.id, turn.id, null);
+    }
+  } catch (err) {
+    const errMsg = (err as Error).message;
+    const now2 = new Date().toISOString();
+    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run('failed', errMsg, now2, turn.id);
+    setSessionStatus(db, session.id, 0, 'failed', now2);
+    broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
+  } finally {
+    // Remove from session map if turn is done (not just idle)
+    if (entry.turnId === null) {
+      sessionMap.delete(session.id);
+    }
+  }
+}
+
+/** Handle a single SDK message — dispatch to the correct handler. */
+async function handleMessage(
+  message: SDKMessage,
+  sessionId: string,
+  turnId: string,
+  entry: ClaudeSessionEntry,
+  db: Database.Database,
+): Promise<void> {
+  switch (message.type) {
+    case 'system': {
+      if ('subtype' in message && message.subtype === 'init') {
+        // Save Claude session ID for resume
+        entry.sessionId = message.session_id;
+        const now = new Date().toISOString();
+        db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
+          message.session_id, now, sessionId,
+        );
+      }
+      break;
+    }
+
+    case 'assistant': {
+      handleAssistantMessage(message, sessionId, turnId, db);
+      break;
+    }
+
+    case 'stream_event': {
+      handleStreamEvent(message, sessionId, turnId);
+      break;
+    }
+
+    case 'result': {
+      handleResultMessage(message, sessionId, turnId, db);
+      break;
+    }
+
+    // Skip user messages — tool outputs not captured in initial implementation.
+    default:
+      break;
+  }
+}
+
+/** Handle SDKAssistantMessage — map content blocks to items. */
+function handleAssistantMessage(
+  message: SDKMessage & { type: 'assistant' },
+  sessionId: string,
+  turnId: string,
+  db: Database.Database,
+): void {
+  const content = message.message.content;
+  const messageId = message.uuid;
+  const descriptors = mapAssistantContent(content, messageId);
+
+  for (const desc of descriptors) {
+    upsertItem(db, desc, sessionId, turnId, 'completed', 'item:completed');
+
+    // Update turn-level fields
+    const now = new Date().toISOString();
+    if (desc.type === 'agent_message') {
+      const text = (desc.data as { text: string }).text;
+      db.prepare('UPDATE turns SET agent_response = ?, updated_at = ? WHERE id = ?').run(text, now, turnId);
+    }
+    if (desc.type === 'reasoning') {
+      const text = (desc.data as { text: string }).text;
+      if (text) {
+        db.prepare('UPDATE turns SET thoughts = ?, updated_at = ? WHERE id = ?').run(text, now, turnId);
+      }
+    }
+  }
+}
+
+/** Handle SDKPartialAssistantMessage — broadcast streaming deltas. */
+function handleStreamEvent(
+  message: SDKMessage & { type: 'stream_event' },
+  sessionId: string,
+  turnId: string,
+): void {
+  const delta = mapPartialDelta(message.event);
+  if (!delta) return;
+
+  // Broadcast text deltas to frontend — no DB write per delta (performance).
+  if (delta.kind === 'text') {
+    broadcast('item:delta', {
+      sessionId,
+      turnId,
+      itemId: message.uuid,
+      delta: delta.text,
+    });
+  }
+  // thinking_delta not broadcast as item:delta — reasoning captured from complete thinking block.
+}
+
+/** Handle SDKResultMessage — complete the turn. */
+function handleResultMessage(
+  message: SDKMessage & { type: 'result' },
+  sessionId: string,
+  turnId: string,
+  db: Database.Database,
+): void {
+  if (message.subtype === 'success') {
+    const usage = mapUsage(message.usage);
+    completeTurn(db, sessionId, turnId, usage);
+  } else {
+    // Error result
+    const errorMsg = message.errors?.join('; ') ?? 'Claude turn failed';
+    const now = new Date().toISOString();
+    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run('failed', errorMsg, now, turnId);
+    setSessionStatus(db, sessionId, 0, 'failed', now);
+    broadcast('turn:failed', { sessionId, turnId, error: errorMsg });
+  }
+
+  // Generate title after turn completes
+  syncThreadTitle(sessionId);
+}
+
+/** Complete a turn — set status, broadcast turn:completed. */
+function completeTurn(db: Database.Database, sessionId: string, turnId: string, usage: TokenUsage | null): void {
+  const now = new Date().toISOString();
+  if (usage) {
+    db.prepare('UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?').run(
+      'completed', JSON.stringify(usage), now, turnId,
+    );
+    broadcast('turn:completed', { sessionId, turnId, usage, hasUnreviewed: true });
+  } else {
+    db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('completed', now, turnId);
+    broadcast('turn:completed', { sessionId, turnId, hasUnreviewed: true });
+  }
+  setSessionStatus(db, sessionId, 0, 'active', now, true);
+}
+
+/** Insert or update an item in the DB and broadcast. */
+function upsertItem(
+  db: Database.Database,
+  desc: ItemDescriptor,
+  sessionId: string,
+  turnId: string,
+  status: ItemStatus,
+  broadcastEvent: string,
+): void {
+  const now = new Date().toISOString();
+
+  // Try to update existing row
+  const result = db
+    .prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
+    .run(JSON.stringify(desc.data), status, now, desc.externalId, turnId);
+
+  let itemId: string;
+  let createdAt: string;
+
+  if (result.changes === 0) {
+    itemId = uuidv4();
+    createdAt = now;
+    db.prepare(
+      'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+    ).run(itemId, turnId, desc.externalId, desc.type as Item['type'], JSON.stringify(desc.data), status, now, now);
+  } else {
+    const row = db
+      .prepare('SELECT id, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
+      .get(desc.externalId, turnId) as { id: string; created_at: string };
+    itemId = row.id;
+    createdAt = row.created_at;
+  }
+
+  const wsItem: Item = {
+    id: itemId,
+    turn_id: turnId,
+    external_item_id: desc.externalId,
+    type: desc.type as Item['type'],
+    data: desc.data,
+    status,
+    created_at: createdAt,
+    updated_at: now,
+  };
+
+  broadcast(broadcastEvent, { sessionId, turnId, item: wsItem });
+}
+
+// ---------------------------------------------------------------------------
+// interruptTurn
+// ---------------------------------------------------------------------------
+
+/** Cancel a running turn by session ID. Returns true if a turn was cancelled. */
+async function interruptTurn(sessionId: string): Promise<boolean> {
+  const entry = sessionMap.get(sessionId);
+  if (!entry || !entry.turnId) return false;
+
+  try {
+    await entry.query.interrupt();
+
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('aborted', now, entry.turnId);
+    setSessionStatus(db, sessionId, 0, 'active', now);
+    broadcast('turn:cancelled', { sessionId, turnId: entry.turnId });
+
+    entry.turnId = null;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// clearThread / clearAllThreads
+// ---------------------------------------------------------------------------
+
+/** Remove a session's Claude query from the in-memory map. */
+function clearThread(sessionId: string): void {
+  const entry = sessionMap.get(sessionId);
+  if (entry) {
+    entry.query.close();
+    sessionMap.delete(sessionId);
+  }
+}
+
+/** Clear all session entries. Used in test cleanup. */
+export function clearAllThreads(): void {
+  for (const [, entry] of sessionMap) {
+    entry.query.close();
+  }
+  sessionMap.clear();
+  titleGenerating.clear();
+}
+
+// ---------------------------------------------------------------------------
+// getModels
+// ---------------------------------------------------------------------------
+
+/** Fetch available models from the Claude SDK and map to AgentPane ModelInfo[]. */
+async function getModels(): Promise<ModelInfo[]> {
+  if (cachedModels) return cachedModels;
+
+  try {
+    const q = query({
+      prompt: '',
+      options: {
+        cwd: process.cwd(),
+        permissionMode: 'bypassPermissions',
+        allowDangerouslySkipPermissions: true,
+      },
+    });
+
+    const initResult = await q.initializationResult();
+    q.close();
+
+    cachedModels = (initResult.models ?? []).map((m: SdkModelInfo) => ({
+      slug: m.value,
+      displayName: m.displayName,
+      description: m.description,
+      defaultReasoning: m.supportedEffortLevels?.[0] ?? 'medium',
+      reasoningLevels: (m.supportedEffortLevels ?? []).map((e) => ({
+        effort: e,
+        label: EFFORT_LABELS[e] ?? e,
+      })),
+    }));
+
+    return cachedModels;
+  } catch {
+    return [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// shutdown
+// ---------------------------------------------------------------------------
+
+/** Graceful shutdown — close all query instances. */
+async function shutdown(): Promise<void> {
+  clearAllThreads();
+}
+
+// ---------------------------------------------------------------------------
+// Title generation
+// ---------------------------------------------------------------------------
+
+/** Generate a title for the session using a throwaway Claude query. */
+function syncThreadTitle(sessionId: string): void {
+  const db = getDb();
+  const session = db.prepare('SELECT title FROM sessions WHERE id = ?').get(sessionId) as
+    | { title: string | null }
+    | undefined;
+  if (!session || session.title !== null) return;
+  if (titleGenerating.has(sessionId)) return;
+
+  const turn = db
+    .prepare('SELECT user_prompt, agent_response FROM turns WHERE session_id = ? ORDER BY created_at ASC LIMIT 1')
+    .get(sessionId) as { user_prompt: string; agent_response: string | null } | undefined;
+  if (!turn) return;
+
+  titleGenerating.add(sessionId);
+  generateTitleAsync(sessionId, turn.user_prompt, turn.agent_response).finally(() => {
+    titleGenerating.delete(sessionId);
+  });
+}
+
+/** Create a throwaway Claude query, ask for a title, update the session. */
+async function generateTitleAsync(
+  sessionId: string,
+  userPrompt: string,
+  agentResponse: string | null,
+): Promise<void> {
+  let q: Query | null = null;
+  try {
+    const truncatedPrompt = userPrompt.slice(0, 500);
+    const truncatedResponse = (agentResponse ?? '').slice(0, 500);
+    const titlePrompt = `Generate a concise 3-5 word title for this conversation. Reply with only the title, nothing else.\n\nUser asked: "${truncatedPrompt}"\n\nAgent responded: "${truncatedResponse}"`;
+
+    q = query({
+      prompt: titlePrompt,
+      options: {
+        cwd: process.cwd(),
+        permissionMode: 'bypassPermissions',
+        allowDangerouslySkipPermissions: true,
+      },
+    });
+
+    let titleResponse = '';
+
+    for await (const message of q) {
+      if (message.type === 'assistant') {
+        for (const block of message.message.content) {
+          if (block.type === 'text') {
+            titleResponse += block.text;
+          }
+        }
+      }
+    }
+
+    const cleanTitle = titleResponse.trim().replace(/^["']|["']$/g, '').slice(0, 100);
+
+    if (cleanTitle) {
+      const db = getDb();
+      const now = new Date().toISOString();
+      db.prepare('UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?').run(cleanTitle, now, sessionId);
+      broadcast('session:title', { sessionId, title: cleanTitle });
+    }
+  } catch {
+    // Silently skip on error — session keeps null title
+  } finally {
+    if (q) {
+      q.close();
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Provider export
+// ---------------------------------------------------------------------------
+
+/** Claude provider — implements RuntimeProvider interface. */
+export const claudeProvider: RuntimeProvider = {
+  startTurn,
+  interruptTurn,
+  clearThread,
+  clearAllThreads,
+  getModels,
+  shutdown,
+};

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

@@ -0,0 +1,33 @@
+/**
+ * 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,
+} from '@anthropic-ai/claude-agent-sdk';
+
+export type { Query, SDKMessage, Options, EffortLevel, SdkModelInfo, SDKControlInitializeResponse };
+
+/** Per-session Claude query instance + state. */
+export interface ClaudeSessionEntry {
+  query: Query;
+  sessionId: string | null;  // Claude session ID from SDKSystemMessage init
+  turnId: string | null;      // current AgentPane turn ID
+}
+
+/** 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

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