repoburg 1.3.188 → 1.3.196

package/agent-pane/backend/src/integration/turn-failure.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Integration test: turn failure handling.
+ *
+ * Verifies that error events from the SDK set the correct DB state
+ * (turn=failed, session=failed) and broadcast turn:failed.
+ *
+ * Uses HTTP POST to trigger the turn (fire-and-forget startTurn).
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type Database from 'better-sqlite3';
+import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
+import { clearBroadcasts, findBroadcast, capturedBroadcasts } from './helpers/ws-capture.ts';
+import type { TestApp } from './helpers/test-app.ts';
+
+const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/failed-turn.json'), 'utf-8')) as Fixture;
+
+vi.mock('../codex/app-server-client.ts', () => ({
+  AppServerClient: createAppServerMock(fixture),
+}));
+
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      capturedBroadcasts.push({ event, data });
+    }),
+  };
+});
+
+const { getDb } = await import('../db/index.ts');
+const { createTestApp, waitForTurn } = await import('./helpers/test-app.ts');
+
+describe('Integration: turn failure', () => {
+  let testApp: TestApp;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    clearBroadcasts();
+    testApp = await createTestApp();
+  });
+
+  afterEach(async () => {
+    await testApp.cleanup();
+  });
+
+  it('handles error event → turn=failed, session=failed, WS turn:failed', async () => {
+    const db: Database.Database = getDb();
+
+    // Create session
+    const createRes = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions',
+      payload: {},
+    });
+    const session = createRes.json();
+
+    // Submit turn via HTTP — triggers fire-and-forget startTurn
+    const turnRes = await testApp.app.inject({
+      method: 'POST',
+      url: `/api/sessions/${session.id}/turns`,
+      payload: { user_prompt: 'Do something that fails' },
+    });
+    const turn = turnRes.json();
+
+    await waitForTurn(db, turn.id);
+
+    // Assert DB — turn
+    const dbTurn = db.prepare('SELECT status, error FROM turns WHERE id = ?').get(turn.id) as {
+      status: string;
+      error: string | null;
+    };
+    expect(dbTurn.status).toBe('failed');
+    expect(dbTurn.error).toBe('Rate limit exceeded. Please try again later.');
+
+    // Assert DB — session
+    const dbSession = db.prepare('SELECT is_running, status FROM sessions WHERE id = ?').get(session.id) as {
+      is_running: number;
+      status: string;
+    };
+    expect(dbSession.is_running).toBe(0);
+    expect(dbSession.status).toBe('failed');
+
+    // Assert WS broadcast
+    const failedData = findBroadcast('turn:failed') as {
+      sessionId: string;
+      turnId: string;
+      error: string;
+    };
+    expect(failedData.sessionId).toBe(session.id);
+    expect(failedData.turnId).toBe(turn.id);
+    expect(failedData.error).toBe('Rate limit exceeded. Please try again later.');
+  });
+});

package/agent-pane/backend/src/integration/turn-lifecycle.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Integration test: full turn lifecycle.
+ *
+ * Verifies the complete pipeline: HTTP POST → startTurn → runStreamed
+ * (replayed) → handleEvent → DB writes → WS broadcasts.
+ *
+ * Uses the real codex-provider.ts code with a mocked app-server client.
+ * The HTTP route handler calls startTurn() fire-and-forget. Tests wait
+ * for the turn to reach terminal status by polling the DB.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type Database from 'better-sqlite3';
+import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
+import { clearBroadcasts, findBroadcast, expectBroadcastSequence, capturedBroadcasts } from './helpers/ws-capture.ts';
+import type { TestApp } from './helpers/test-app.ts';
+
+const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/simple-turn.json'), 'utf-8')) as Fixture;
+
+vi.mock('../codex/app-server-client.ts', () => ({
+  AppServerClient: createAppServerMock(fixture),
+}));
+
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      capturedBroadcasts.push({ event, data });
+    }),
+  };
+});
+
+const { getDb } = await import('../db/index.ts');
+const { createTestApp, waitForTurn } = await import('./helpers/test-app.ts');
+
+describe('Integration: turn lifecycle', () => {
+  let testApp: TestApp;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    clearBroadcasts();
+    testApp = await createTestApp();
+  });
+
+  afterEach(async () => {
+    await testApp.cleanup();
+  });
+
+  it('completes a full turn: HTTP → startTurn → events → DB → WS', async () => {
+    const db: Database.Database = getDb();
+
+    // 1. Create session via HTTP
+    const createRes = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions',
+      payload: { cwd: '/test' },
+    });
+    expect(createRes.statusCode).toBe(200);
+    const session = createRes.json();
+    const sessionId = session.id;
+
+    // 2. Submit turn via HTTP — route handler calls startTurn() fire-and-forget
+    const turnRes = await testApp.app.inject({
+      method: 'POST',
+      url: `/api/sessions/${sessionId}/turns`,
+      payload: { user_prompt: 'Hello, how are you?' },
+    });
+    expect(turnRes.statusCode).toBe(200);
+    const turn = turnRes.json();
+    const turnId = turn.id;
+    expect(turn.status).toBe('pending');
+
+    // 3. Wait for turn to reach terminal status
+    await waitForTurn(db, turnId);
+
+    // 4. Assert DB state — session
+    const dbSession = db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId) as {
+      external_thread_id: string | null;
+      is_running: number;
+      status: string;
+      has_unreviewed: number;
+      title: string | null;
+    };
+    expect(dbSession.external_thread_id).toBe('thread_fix_001');
+    expect(dbSession.is_running).toBe(0);
+    expect(dbSession.status).toBe('active');
+    expect(dbSession.has_unreviewed).toBe(1);
+
+    // 5. Assert DB state — turn
+    const dbTurn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as {
+      status: string;
+      agent_response: string | null;
+      token_usage: string | null;
+    };
+    expect(dbTurn.status).toBe('completed');
+    expect(dbTurn.agent_response).toBe('Hello! How can I help you today?');
+    // Real app-server does not send usage in turn/completed — token_usage is null
+    // until thread/tokenUsage/updated notification is implemented
+    expect(dbTurn.token_usage).toBeNull();
+
+    // 6. Assert DB state — items
+    const items = db.prepare('SELECT * FROM items WHERE turn_id = ? ORDER BY created_at ASC').all(turnId) as {
+      id: string;
+      type: string;
+      data: string;
+      status: string;
+    }[];
+    expect(items).toHaveLength(1);
+    expect(items[0].type).toBe('agent_message');
+    expect(items[0].status).toBe('completed');
+    expect(JSON.parse(items[0].data)).toEqual({ text: 'Hello! How can I help you today?' });
+
+    // 7. Assert WS broadcasts — order matters
+    expectBroadcastSequence(['turn:started', 'item:started', 'item:updated', 'item:completed', 'turn:completed']);
+
+    // 8. Assert turn:completed broadcast payload (no usage — real app-server)
+    const completedData = findBroadcast('turn:completed') as {
+      sessionId: string;
+      turnId: string;
+      hasUnreviewed: boolean;
+    };
+    expect(completedData.sessionId).toBe(sessionId);
+    expect(completedData.turnId).toBe(turnId);
+    expect(completedData.hasUnreviewed).toBe(true);
+
+    // 9. Title generation is fire-and-forget — wait for it
+    await new Promise((r) => setTimeout(r, 500));
+    const dbSessionTitled = db.prepare('SELECT title FROM sessions WHERE id = ?').get(sessionId) as {
+      title: string | null;
+    };
+    expect(dbSessionTitled.title).toBe('Simple Hello Chat');
+
+    // 10. Verify session:title broadcast
+    const titleData = findBroadcast('session:title') as { sessionId: string; title: string };
+    expect(titleData.sessionId).toBe(sessionId);
+    expect(titleData.title).toBe('Simple Hello Chat');
+  });
+});

package/agent-pane/backend/src/providers/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Provider registration — imports providers and registers them.
+ *
+ * Imported for side effects in `index.ts`:
+ *   import './providers/index.ts';
+ */
+
+import { codexProvider } from '../codex/codex-provider.ts';
+import { claudeProvider } from '../claude/claude-provider.ts';
+import { registerProvider } from './registry.ts';
+
+// Register built-in providers
+registerProvider('codex', codexProvider);
+registerProvider('claude', claudeProvider);

package/agent-pane/backend/src/providers/registry.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { RuntimeProvider } from './runtime-provider.ts';
+
+// Use dynamic import to get a fresh module instance per test.
+// vi.resetModules() ensures the registry Map starts empty each time.
+
+function makeMockProvider(): RuntimeProvider {
+  return {
+    startTurn: vi.fn().mockResolvedValue(undefined),
+    interruptTurn: vi.fn().mockResolvedValue(true),
+    clearThread: vi.fn(),
+    clearAllThreads: vi.fn(),
+    getModels: vi.fn().mockResolvedValue([]),
+    shutdown: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe('Provider registry', () => {
+  let registry: typeof import('./registry.ts');
+
+  beforeEach(async () => {
+    vi.resetModules();
+    registry = await import('./registry.ts');
+  });
+
+  describe('registerProvider + getProvider', () => {
+    it('registers and retrieves a provider', () => {
+      const mock = makeMockProvider();
+      registry.registerProvider('test', mock);
+      expect(registry.getProvider('test')).toBe(mock);
+    });
+
+    it('throws for unregistered provider', () => {
+      expect(() => registry.getProvider('unknown')).toThrow('Unknown provider: unknown');
+    });
+
+    it('overwrites previous registration with same ID', () => {
+      const mock1 = makeMockProvider();
+      const mock2 = makeMockProvider();
+      registry.registerProvider('test', mock1);
+      registry.registerProvider('test', mock2);
+      expect(registry.getProvider('test')).toBe(mock2);
+    });
+  });
+
+  describe('hasProvider', () => {
+    it('returns true for registered provider', () => {
+      registry.registerProvider('test', makeMockProvider());
+      expect(registry.hasProvider('test')).toBe(true);
+    });
+
+    it('returns false for unregistered provider', () => {
+      expect(registry.hasProvider('unknown')).toBe(false);
+    });
+  });
+
+  describe('clearAllProviders', () => {
+    it('calls clearAllThreads on all registered providers', () => {
+      const mock1 = makeMockProvider();
+      const mock2 = makeMockProvider();
+      registry.registerProvider('p1', mock1);
+      registry.registerProvider('p2', mock2);
+
+      registry.clearAllProviders();
+
+      expect(mock1.clearAllThreads).toHaveBeenCalledTimes(1);
+      expect(mock2.clearAllThreads).toHaveBeenCalledTimes(1);
+    });
+
+    it('does nothing when no providers registered', () => {
+      expect(() => registry.clearAllProviders()).not.toThrow();
+    });
+  });
+
+  describe('shutdownAllProviders', () => {
+    it('calls shutdown on all registered providers', async () => {
+      const mock1 = makeMockProvider();
+      const mock2 = makeMockProvider();
+      registry.registerProvider('p1', mock1);
+      registry.registerProvider('p2', mock2);
+
+      await registry.shutdownAllProviders();
+
+      expect(mock1.shutdown).toHaveBeenCalledTimes(1);
+      expect(mock2.shutdown).toHaveBeenCalledTimes(1);
+    });
+
+    it('does nothing when no providers registered', async () => {
+      await expect(registry.shutdownAllProviders()).resolves.toBeUndefined();
+    });
+  });
+});

package/agent-pane/backend/src/providers/registry.ts

@@ -0,0 +1,43 @@
+/**
+ * Provider registry — Map-based dispatch.
+ *
+ * Routes call `getProvider(session.runtime_type).startTurn(...)`.
+ * No if/else branching in route handlers.
+ */
+
+import type { RuntimeProvider } from './runtime-provider.ts';
+
+const providers = new Map<string, RuntimeProvider>();
+
+/** Register a provider by its runtime type ID. */
+export function registerProvider(id: string, provider: RuntimeProvider): void {
+  providers.set(id, provider);
+}
+
+/** Get a provider by runtime type. Throws if not registered. */
+export function getProvider(runtimeType: string): RuntimeProvider {
+  const provider = providers.get(runtimeType);
+  if (!provider) {
+    throw new Error(`Unknown provider: ${runtimeType}`);
+  }
+  return provider;
+}
+
+/** Check if a provider is registered. */
+export function hasProvider(runtimeType: string): boolean {
+  return providers.has(runtimeType);
+}
+
+/** Clear all in-memory state for all providers. Used in test cleanup. */
+export function clearAllProviders(): void {
+  for (const provider of providers.values()) {
+    provider.clearAllThreads();
+  }
+}
+
+/** Graceful shutdown for all registered providers. */
+export async function shutdownAllProviders(): Promise<void> {
+  for (const provider of providers.values()) {
+    await provider.shutdown();
+  }
+}

package/agent-pane/backend/src/providers/runtime-provider.ts

@@ -0,0 +1,25 @@
+/**
+ * Runtime provider interface — one interface for all providers.
+ *
+ * Each provider (Codex, Claude, etc.) implements this interface.
+ * Routes dispatch via the registry Map — no if/else branching.
+ */
+
+import type { Session, Turn } from '../db/schema.ts';
+import type { ModelInfo } from '@agentpane/shared';
+
+/** Runtime provider — turn lifecycle, cleanup, metadata, and shutdown. */
+export interface RuntimeProvider {
+  /** Start a turn. Fire-and-forget — events stream via WebSocket. */
+  startTurn(session: Session, turn: Turn): Promise<void>;
+  /** Cancel a running turn. Returns true if a turn was cancelled. */
+  interruptTurn(sessionId: string): Promise<boolean>;
+  /** Remove session from in-memory state. Used after rewind/branch/model-change. */
+  clearThread(sessionId: string): void;
+  /** Clear all in-memory state. Used in test cleanup. */
+  clearAllThreads(): void;
+  /** Fetch available models for this provider. */
+  getModels(): Promise<ModelInfo[]>;
+  /** Graceful shutdown — close processes, release resources. */
+  shutdown(): Promise<void>;
+}

package/agent-pane/backend/src/routes/files.ts

@@ -0,0 +1,31 @@
+import type { FastifyInstance } from 'fastify';
+import { getSharedAppServer } from '../codex/shared-app-server.ts';
+import type { FileSearchResult } from '../codex/app-server-types.ts';
+
+/** Register file search routes. */
+export async function registerFileRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /api/files/search?q=...&cwd=... — fuzzy file search via app-server
+  fastify.get<{ Querystring: { q?: string; cwd?: string } }>('/api/files/search', async (request) => {
+    const { q = '', cwd = process.cwd() } = request.query;
+
+    if (!q.trim()) {
+      return { entries: [], truncated: false };
+    }
+
+    try {
+      const result = await getSharedAppServer().request<FileSearchResult>('fuzzyFileSearch', {
+        query: q,
+        roots: [cwd],
+      });
+
+      const entries = (result.results ?? []).map((r) => ({
+        path: r.path,
+        kind: r.match_type,
+      }));
+
+      return { entries, truncated: false };
+    } catch {
+      return { entries: [], truncated: false };
+    }
+  });
+}

package/agent-pane/backend/src/routes/mcp.ts

@@ -0,0 +1,33 @@
+import type { FastifyInstance } from 'fastify';
+import type { Extension } from '@agentpane/shared';
+import { getSharedAppServer } from '../codex/shared-app-server.ts';
+import type { McpListResult, AppServerMcpServer } from '../codex/app-server-types.ts';
+
+/** Map an app-server MCP server to the shared Extension type. */
+function mapMcpServer(server: AppServerMcpServer): Extension {
+  return {
+    id: server.name,
+    name: server.serverInfo?.title ?? server.name,
+    description: server.serverInfo?.description ?? '',
+    type: 'mcp-server',
+    enabled: true,
+    metadata: {
+      version: server.serverInfo?.version,
+      authStatus: server.authStatus,
+      hasTools: Boolean(server.tools && Object.keys(server.tools).length > 0),
+    },
+  };
+}
+
+/** Register MCP routes. */
+export async function registerMcpRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /api/mcp — list all MCP servers from the app-server
+  fastify.get('/api/mcp', async () => {
+    const result = await getSharedAppServer().request<McpListResult>('mcpServerStatus/list', {
+      detail: 'toolsAndAuthOnly',
+    });
+
+    const servers: Extension[] = (result.data ?? []).map(mapMcpServer);
+    return servers;
+  });
+}

package/agent-pane/backend/src/routes/models.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Fastify, { type FastifyInstance } from 'fastify';
+import type { ModelInfo } from '@agentpane/shared';
+
+// Mock registry to return a mock provider with getModels()
+const mocks = vi.hoisted(() => ({
+  getModels: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock('../providers/registry.ts', () => ({
+  getProvider: vi.fn(() => ({
+    getModels: mocks.getModels,
+    startTurn: vi.fn(),
+    interruptTurn: vi.fn(),
+    clearThread: vi.fn(),
+    clearAllThreads: vi.fn(),
+    shutdown: vi.fn(),
+  })),
+  hasProvider: vi.fn(() => true),
+}));
+
+import { registerModelRoutes } from './models.ts';
+import { hasProvider } from '../providers/registry.ts';
+
+const MOCK_MODELS: ModelInfo[] = [
+  {
+    slug: 'gpt-5.6-sol',
+    displayName: 'GPT-5.6-Sol',
+    description: 'Flagship model',
+    defaultReasoning: 'low',
+    reasoningLevels: [
+      { effort: 'low', label: 'Low' },
+      { effort: 'high', label: 'High' },
+    ],
+  },
+  {
+    slug: 'gpt-5.4',
+    displayName: 'GPT-5.4',
+    description: 'Everyday model',
+    defaultReasoning: 'medium',
+    reasoningLevels: [
+      { effort: 'low', label: 'Low' },
+      { effort: 'medium', label: 'Medium' },
+    ],
+  },
+];
+
+describe('Model routes', () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    vi.mocked(hasProvider).mockReturnValue(true);
+    mocks.getModels.mockResolvedValue(MOCK_MODELS);
+    app = Fastify();
+    await registerModelRoutes(app);
+  });
+
+  describe('GET /api/providers/:id/models', () => {
+    it('returns model list for codex', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/providers/codex/models' });
+      expect(res.statusCode).toBe(200);
+      const models = res.json();
+      expect(models).toHaveLength(2);
+
+      expect(models[0].slug).toBe('gpt-5.6-sol');
+      expect(models[0].displayName).toBe('GPT-5.6-Sol');
+      expect(models[0].description).toBe('Flagship model');
+      expect(models[0].defaultReasoning).toBe('low');
+      expect(models[0].reasoningLevels).toEqual([
+        { effort: 'low', label: 'Low' },
+        { effort: 'high', label: 'High' },
+      ]);
+    });
+
+    it('returns 404 for unregistered provider', async () => {
+      // Override hasProvider to return false for this test
+      const { hasProvider } = await import('../providers/registry.ts');
+      vi.mocked(hasProvider).mockReturnValue(false);
+      const res = await app.inject({ method: 'GET', url: '/api/providers/unknown/models' });
+      expect(res.statusCode).toBe(404);
+      expect(res.json()).toEqual({ error: 'No models available for provider: unknown' });
+    });
+
+    it('returns empty array when provider getModels fails', async () => {
+      mocks.getModels.mockResolvedValue([]);
+      const res = await app.inject({ method: 'GET', url: '/api/providers/codex/models' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual([]);
+    });
+  });
+});

package/agent-pane/backend/src/routes/models.ts

@@ -0,0 +1,16 @@
+import type { FastifyInstance } from 'fastify';
+import { getProvider, hasProvider } from '../providers/registry.ts';
+
+/** Register model routes. */
+export async function registerModelRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /api/providers/:id/models — list models for a provider
+  fastify.get<{ Params: { id: string } }>('/api/providers/:id/models', async (request, reply) => {
+    const { id } = request.params;
+
+    if (!hasProvider(id)) {
+      return reply.code(404).send({ error: `No models available for provider: ${id}` });
+    }
+
+    return getProvider(id).getModels();
+  });
+}

package/agent-pane/backend/src/routes/plugins.ts

@@ -0,0 +1,40 @@
+import type { FastifyInstance } from 'fastify';
+import type { Extension } from '@agentpane/shared';
+import { getSharedAppServer } from '../codex/shared-app-server.ts';
+import type { PluginListResult, AppServerPlugin } from '../codex/app-server-types.ts';
+
+/** Map an app-server plugin to the shared Extension type. */
+function mapPlugin(plugin: AppServerPlugin, marketplace: string): Extension {
+  return {
+    id: plugin.id,
+    name: plugin.interface?.displayName ?? plugin.name,
+    description: plugin.interface?.shortDescription ?? '',
+    type: 'plugin',
+    enabled: plugin.enabled,
+    metadata: {
+      marketplace,
+      installed: plugin.installed,
+      availability: plugin.availability,
+      category: plugin.interface?.category,
+      developer: plugin.interface?.developerName,
+      brandColor: plugin.interface?.brandColor,
+    },
+  };
+}
+
+/** Register plugin routes. */
+export async function registerPluginRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /api/plugins — list all plugins from the app-server
+  fastify.get('/api/plugins', async () => {
+    const result = await getSharedAppServer().request<PluginListResult>('plugin/list', {});
+
+    // Flatten all plugins from all marketplaces
+    const allPlugins: Extension[] = [];
+    for (const marketplace of result.marketplaces) {
+      for (const plugin of marketplace.plugins) {
+        allPlugins.push(mapPlugin(plugin, marketplace.name));
+      }
+    }
+    return allPlugins;
+  });
+}