repoburg 1.3.188 → 1.3.196

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

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import Fastify, { type FastifyInstance } from 'fastify';
+import { registerProviderRoutes } from './providers.ts';
+
+describe('Provider routes', () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    app = Fastify();
+    await registerProviderRoutes(app);
+  });
+
+  describe('GET /api/providers', () => {
+    it('returns all provider definitions', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/providers' });
+      expect(res.statusCode).toBe(200);
+      const providers = res.json();
+      expect(providers).toHaveLength(2);
+      expect(providers[0].id).toBe('codex');
+      expect(providers[0].available).toBe(true);
+      expect(providers[1].id).toBe('claude');
+      expect(providers[1].available).toBe(true);
+    });
+
+    it('codex provider has all capabilities enabled', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/providers' });
+      const codex = res.json().find((p: { id: string }) => p.id === 'codex');
+      expect(codex.capabilities.dynamicModels).toBe(true);
+      expect(codex.capabilities.skills).toBe(true);
+      expect(codex.capabilities.plugins).toBe(true);
+      expect(codex.capabilities.mcpServers).toBe(true);
+      expect(codex.capabilities.imageAttachments).toBe(true);
+      expect(codex.capabilities.sandbox).toBe(true);
+      expect(codex.capabilities.webSearch).toBe(true);
+      expect(codex.capabilities.networkAccess).toBe(true);
+      expect(codex.capabilities.fileReferences).toBe(true);
+    });
+
+    it('claude provider has correct capabilities', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/providers' });
+      const claude = res.json().find((p: { id: string }) => p.id === 'claude');
+      expect(claude.available).toBe(true);
+      expect(claude.capabilities.dynamicModels).toBe(true);
+      expect(claude.capabilities.skills).toBe(true);
+      expect(claude.capabilities.plugins).toBe(true);
+      expect(claude.capabilities.mcpServers).toBe(true);
+      expect(claude.capabilities.imageAttachments).toBe(true);
+      expect(claude.capabilities.sandbox).toBe(false);
+      expect(claude.capabilities.webSearch).toBe(false);
+      expect(claude.capabilities.networkAccess).toBe(false);
+      expect(claude.capabilities.fileReferences).toBe(true);
+    });
+  });
+
+  describe('GET /api/providers/:id', () => {
+    it('returns codex provider by id', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/providers/codex' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json().id).toBe('codex');
+      expect(res.json().label).toBe('Codex');
+    });
+
+    it('returns 404 for unknown provider', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/providers/unknown' });
+      expect(res.statusCode).toBe(404);
+      expect(res.json()).toEqual({ error: 'Provider not found' });
+    });
+  });
+});

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

@@ -0,0 +1,57 @@
+import type { FastifyInstance } from 'fastify';
+import type { ProviderDefinition } from '@agentpane/shared';
+
+/** Codex provider definition — all capabilities enabled. */
+const CODEX_PROVIDER: ProviderDefinition = {
+  id: 'codex',
+  label: 'Codex',
+  available: true,
+  capabilities: {
+    dynamicModels: true,
+    skills: true,
+    plugins: true,
+    mcpServers: true,
+    imageAttachments: true,
+    sandbox: true,
+    webSearch: true,
+    networkAccess: true,
+    fileReferences: true,
+  },
+};
+
+/** Claude provider definition — available via @anthropic-ai/claude-agent-sdk. */
+const CLAUDE_PROVIDER: ProviderDefinition = {
+  id: 'claude',
+  label: 'Claude',
+  available: true,
+  capabilities: {
+    dynamicModels: true,
+    skills: true,
+    plugins: true,
+    mcpServers: true,
+    imageAttachments: true,
+    sandbox: false,
+    webSearch: false,
+    networkAccess: false,
+    fileReferences: true,
+  },
+};
+
+const PROVIDERS: ProviderDefinition[] = [CODEX_PROVIDER, CLAUDE_PROVIDER];
+
+/** Register provider routes. */
+export async function registerProviderRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /api/providers — list all provider definitions with capabilities
+  fastify.get('/api/providers', async () => {
+    return PROVIDERS;
+  });
+
+  // GET /api/providers/:id — get a single provider definition
+  fastify.get<{ Params: { id: string } }>('/api/providers/:id', async (request, reply) => {
+    const provider = PROVIDERS.find((p) => p.id === request.params.id);
+    if (!provider) {
+      return reply.code(404).send({ error: 'Provider not found' });
+    }
+    return provider;
+  });
+}

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

@@ -0,0 +1,424 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Fastify, { type FastifyInstance } from 'fastify';
+import { initDb, getDb } from '../db/index.ts';
+import { registerSessionRoutes } from './sessions.ts';
+// Mock registry to avoid spawning real provider processes
+const mocks = vi.hoisted(() => ({
+  clearThread: vi.fn(),
+}));
+
+vi.mock('../providers/registry.ts', () => ({
+  getProvider: vi.fn(() => ({
+    clearThread: mocks.clearThread,
+    startTurn: vi.fn(),
+    interruptTurn: vi.fn(),
+    clearAllThreads: vi.fn(),
+    getModels: vi.fn(),
+    shutdown: vi.fn(),
+  })),
+  hasProvider: vi.fn(() => true),
+}));
+
+const NOW = '2025-01-01T00:00:00Z';
+
+/** Insert a session row with sensible defaults. */
+function insertSession(db: ReturnType<typeof getDb>, id: string, overrides: Record<string, unknown> = {}): void {
+  db.prepare(
+    `INSERT INTO sessions (id, title, runtime_type, model, model_reasoning_effort, cwd, external_thread_id, status, is_running, lifecycle, has_unreviewed, created_at, updated_at, runtime_config)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    (overrides['title'] as string | null) ?? null,
+    (overrides['runtime_type'] as string) ?? 'codex',
+    (overrides['model'] as string | null) ?? null,
+    (overrides['model_reasoning_effort'] as string | null) ?? null,
+    (overrides['cwd'] as string | null) ?? null,
+    (overrides['external_thread_id'] as string | null) ?? null,
+    (overrides['status'] as string) ?? 'active',
+    (overrides['is_running'] as number) ?? 0,
+    (overrides['lifecycle'] as string) ?? 'working',
+    (overrides['has_unreviewed'] as number) ?? 0,
+    (overrides['created_at'] as string) ?? NOW,
+    (overrides['updated_at'] as string) ?? NOW,
+    (overrides['runtime_config'] as string | null) ?? null,
+  );
+}
+
+/** Insert a turn row. */
+function insertTurn(db: ReturnType<typeof getDb>, id: string, sessionId: string, createdAt = NOW): void {
+  db.prepare(
+    `INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
+     VALUES (?, ?, ?, NULL, NULL, NULL, NULL, 'pending', NULL, ?, ?)`,
+  ).run(id, sessionId, 'hello', createdAt, createdAt);
+}
+
+/** Insert an item row. */
+function insertItem(db: ReturnType<typeof getDb>, id: string, turnId: string, type = 'agent_message'): void {
+  db.prepare(
+    `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(id, turnId, `ext-${id}`, type, JSON.stringify({ text: 'test' }), 'completed', NOW, NOW);
+}
+
+describe('Session routes', () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    initDb(':memory:');
+    app = Fastify();
+    await registerSessionRoutes(app);
+  });
+
+  describe('GET /api/sessions', () => {
+    it('returns empty array when no sessions', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/sessions' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual([]);
+    });
+
+    it('returns sessions ordered by created_at DESC', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { created_at: '2025-01-01T00:00:00Z' });
+      insertSession(db, 's2', { created_at: '2025-01-02T00:00:00Z' });
+      const res = await app.inject({ method: 'GET', url: '/api/sessions' });
+      const sessions = res.json();
+      expect(sessions).toHaveLength(2);
+      expect(sessions[0].id).toBe('s2');
+      expect(sessions[1].id).toBe('s1');
+    });
+  });
+
+  describe('GET /api/sessions/:id', () => {
+    it('returns 404 for missing session', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/sessions/nonexistent' });
+      expect(res.statusCode).toBe(404);
+      expect(res.json()).toEqual({ error: 'Session not found' });
+    });
+
+    it('returns session with turns and items', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      insertTurn(db, 't1', 's1');
+      insertItem(db, 'i1', 't1', 'agent_message');
+
+      const res = await app.inject({ method: 'GET', url: '/api/sessions/s1' });
+      expect(res.statusCode).toBe(200);
+      const detail = res.json();
+      expect(detail.id).toBe('s1');
+      expect(detail.turns).toHaveLength(1);
+      expect(detail.turns[0].id).toBe('t1');
+      expect(detail.turns[0].items).toHaveLength(1);
+      expect(detail.turns[0].items[0].id).toBe('i1');
+      expect(detail.turns[0].items[0].data).toEqual({ text: 'test' });
+    });
+  });
+
+  describe('POST /api/sessions', () => {
+    it('creates a session with defaults', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/sessions', payload: {} });
+      expect(res.statusCode).toBe(200);
+      const session = res.json();
+      expect(session.id).toBeDefined();
+      expect(session.runtime_type).toBe('codex');
+      expect(session.status).toBe('active');
+      expect(session.is_running).toBe(0);
+      expect(session.title).toBeNull();
+      expect(session.model).toBeNull();
+    });
+
+    it('creates a session with provided values', async () => {
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions',
+        payload: {
+          title: 'Test',
+          runtime_type: 'claude',
+          model: 'gpt-4',
+          model_reasoning_effort: 'high',
+          cwd: '/home',
+        },
+      });
+      expect(res.statusCode).toBe(200);
+      const session = res.json();
+      expect(session.title).toBe('Test');
+      expect(session.runtime_type).toBe('claude');
+      expect(session.model).toBe('gpt-4');
+      expect(session.model_reasoning_effort).toBe('high');
+      expect(session.cwd).toBe('/home');
+    });
+
+    it('creates a session with runtime_config', async () => {
+      const config = JSON.stringify({ sandboxMode: 'read-only' });
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions',
+        payload: { runtime_config: config },
+      });
+      expect(res.statusCode).toBe(200);
+      expect(res.json().runtime_config).toBe(config);
+    });
+  });
+
+  describe('PATCH /api/sessions/:id — runtime_config', () => {
+    it('updates runtime_config', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      const config = JSON.stringify({ sandboxMode: 'read-only', webSearchMode: 'live' });
+      const res = await app.inject({
+        method: 'PATCH',
+        url: '/api/sessions/s1',
+        payload: { runtime_config: config },
+      });
+      expect(res.statusCode).toBe(200);
+      expect(res.json().runtime_config).toBe(config);
+    });
+
+    it('clears runtime_config with null', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { runtime_config: JSON.stringify({ sandboxMode: 'read-only' }) });
+      const res = await app.inject({
+        method: 'PATCH',
+        url: '/api/sessions/s1',
+        payload: { runtime_config: null },
+      });
+      expect(res.statusCode).toBe(200);
+      expect(res.json().runtime_config).toBeNull();
+    });
+  });
+
+  describe('DELETE /api/sessions/:id', () => {
+    it('returns 404 for missing session', async () => {
+      const res = await app.inject({ method: 'DELETE', url: '/api/sessions/nonexistent' });
+      expect(res.statusCode).toBe(404);
+    });
+
+    it('deletes session and cascades to turns and items', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      insertTurn(db, 't1', 's1');
+      insertItem(db, 'i1', 't1');
+
+      const res = await app.inject({ method: 'DELETE', url: '/api/sessions/s1' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual({ success: true });
+
+      expect(db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1')).toBeUndefined();
+      expect(db.prepare('SELECT * FROM turns WHERE session_id = ?').get('s1')).toBeUndefined();
+      expect(db.prepare('SELECT * FROM items WHERE turn_id = ?').get('t1')).toBeUndefined();
+    });
+  });
+
+  describe('PATCH /api/sessions/:id', () => {
+    it('returns 404 for missing session', async () => {
+      const res = await app.inject({
+        method: 'PATCH',
+        url: '/api/sessions/nonexistent',
+        payload: { title: 'New' },
+      });
+      expect(res.statusCode).toBe(404);
+    });
+
+    it('updates title', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { title: 'Updated' } });
+      expect(res.statusCode).toBe(200);
+      expect(res.json().title).toBe('Updated');
+    });
+
+    it('updates lifecycle', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { lifecycle: 'finished' } });
+      expect(res.statusCode).toBe(200);
+      expect(res.json().lifecycle).toBe('finished');
+    });
+
+    it('updates has_unreviewed', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { has_unreviewed: 1 } });
+      expect(res.statusCode).toBe(200);
+      expect(res.json().has_unreviewed).toBe(1);
+    });
+
+    it('clears thread when model changes and external_thread_id exists', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { model: 'gpt-4', external_thread_id: 'thread-123' });
+      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { model: 'claude-3' } });
+      expect(res.statusCode).toBe(200);
+      expect(mocks.clearThread).toHaveBeenCalledWith('s1');
+      const session = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as {
+        external_thread_id: string | null;
+      };
+      expect(session.external_thread_id).toBeNull();
+    });
+
+    it('does not clear thread when model is unchanged', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { model: 'gpt-4', external_thread_id: 'thread-123' });
+      const res = await app.inject({ method: 'PATCH', url: '/api/sessions/s1', payload: { model: 'gpt-4' } });
+      expect(res.statusCode).toBe(200);
+      expect(mocks.clearThread).not.toHaveBeenCalled();
+    });
+
+    it('switches runtime_type and clears thread', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { runtime_type: 'codex', model: 'gpt-5.6-sol', external_thread_id: 'thread-123' });
+      const res = await app.inject({
+        method: 'PATCH',
+        url: '/api/sessions/s1',
+        payload: { runtime_type: 'claude' },
+      });
+      expect(res.statusCode).toBe(200);
+      const session = res.json();
+      expect(session.runtime_type).toBe('claude');
+      expect(session.model).toBeNull();
+      expect(session.model_reasoning_effort).toBeNull();
+      expect(session.external_thread_id).toBeNull();
+      expect(mocks.clearThread).toHaveBeenCalledWith('s1');
+    });
+
+    it('switches runtime_type with explicit model', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { runtime_type: 'codex', model: 'gpt-5.6-sol' });
+      const res = await app.inject({
+        method: 'PATCH',
+        url: '/api/sessions/s1',
+        payload: { runtime_type: 'claude', model: 'claude-sonnet-5', model_reasoning_effort: 'high' },
+      });
+      expect(res.statusCode).toBe(200);
+      const session = res.json();
+      expect(session.runtime_type).toBe('claude');
+      expect(session.model).toBe('claude-sonnet-5');
+      expect(session.model_reasoning_effort).toBe('high');
+    });
+
+    it('returns 409 when switching provider while running', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { runtime_type: 'codex', is_running: 1 });
+      const res = await app.inject({
+        method: 'PATCH',
+        url: '/api/sessions/s1',
+        payload: { runtime_type: 'claude' },
+      });
+      expect(res.statusCode).toBe(409);
+      expect(res.json().error).toContain('Cannot switch provider');
+    });
+  });
+
+  describe('POST /api/sessions/:id/rewind', () => {
+    it('returns 400 when turn_id is missing', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: {} });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('returns 404 for missing session', async () => {
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/nonexistent/rewind',
+        payload: { turn_id: 't1' },
+      });
+      expect(res.statusCode).toBe(404);
+    });
+
+    it('returns 409 when session is running', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { is_running: 1 });
+      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't1' } });
+      expect(res.statusCode).toBe(409);
+    });
+
+    it('returns 404 when turn is not found', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/s1/rewind',
+        payload: { turn_id: 'nonexistent' },
+      });
+      expect(res.statusCode).toBe(404);
+      expect(res.json().error).toBe('Turn not found');
+    });
+
+    it('deletes turns after target and nulls external_thread_id', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { external_thread_id: 'thread-123' });
+      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
+      insertTurn(db, 't2', 's1', '2025-01-01T01:00:00Z');
+      insertTurn(db, 't3', 's1', '2025-01-01T02:00:00Z');
+
+      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/rewind', payload: { turn_id: 't1' } });
+      expect(res.statusCode).toBe(200);
+
+      const turns = db.prepare('SELECT id FROM turns WHERE session_id = ? ORDER BY created_at').all('s1') as {
+        id: string;
+      }[];
+      expect(turns).toHaveLength(1);
+      expect(turns[0].id).toBe('t1');
+
+      const session = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as {
+        external_thread_id: string | null;
+      };
+      expect(session.external_thread_id).toBeNull();
+      expect(mocks.clearThread).toHaveBeenCalledWith('s1');
+    });
+  });
+
+  describe('POST /api/sessions/:id/branch', () => {
+    it('returns 400 when turn_id is missing', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/branch', payload: {} });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('returns 404 for missing session', async () => {
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/nonexistent/branch',
+        payload: { turn_id: 't1' },
+      });
+      expect(res.statusCode).toBe(404);
+    });
+
+    it('returns 404 when turn is not found', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/s1/branch',
+        payload: { turn_id: 'nonexistent' },
+      });
+      expect(res.statusCode).toBe(404);
+      expect(res.json().error).toBe('Turn not found');
+    });
+
+    it('creates new session with copied turns up to target', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { title: 'Original', model: 'gpt-4' });
+      insertTurn(db, 't1', 's1', '2025-01-01T00:00:00Z');
+      insertTurn(db, 't2', 's1', '2025-01-01T01:00:00Z');
+      insertItem(db, 'i1', 't1');
+
+      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/branch', payload: { turn_id: 't1' } });
+      expect(res.statusCode).toBe(200);
+      const newSession = res.json();
+      expect(newSession.id).not.toBe('s1');
+      expect(newSession.title).toBe('Branch of Original');
+      expect(newSession.model).toBe('gpt-4');
+      expect(newSession.external_thread_id).toBeNull();
+
+      // Only t1 copied (not t2)
+      const newTurns = db
+        .prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at')
+        .all(newSession.id) as { id: string; user_prompt: string }[];
+      expect(newTurns).toHaveLength(1);
+      expect(newTurns[0].user_prompt).toBe('hello');
+
+      // Item copied
+      const newItems = db.prepare('SELECT * FROM items WHERE turn_id = ?').all(newTurns[0].id) as { type: string }[];
+      expect(newItems).toHaveLength(1);
+      expect(newItems[0].type).toBe('agent_message');
+    });
+  });
+});