repoburg 1.3.188 → 1.3.196

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

@@ -0,0 +1,152 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Fastify, { type FastifyInstance } from 'fastify';
+import { initDb, getDb } from '../db/index.ts';
+import { registerTurnRoutes } from './turns.ts';
+
+// Mock registry to avoid spawning real provider processes
+const mocks = vi.hoisted(() => ({
+  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),
+}));
+
+vi.mock('../providers/registry.ts', () => ({
+  getProvider: vi.fn(() => ({
+    startTurn: mocks.startTurn,
+    interruptTurn: mocks.interruptTurn,
+    clearThread: mocks.clearThread,
+    clearAllThreads: mocks.clearAllThreads,
+    getModels: mocks.getModels,
+    shutdown: mocks.shutdown,
+  })),
+  hasProvider: vi.fn(() => true),
+}));
+
+const NOW = '2025-01-01T00:00:00Z';
+
+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)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    null,
+    'codex',
+    null,
+    null,
+    null,
+    (overrides['external_thread_id'] as string | null) ?? null,
+    (overrides['status'] as string) ?? 'active',
+    (overrides['is_running'] as number) ?? 0,
+    'working',
+    0,
+    NOW,
+    NOW,
+  );
+}
+
+describe('Turn routes', () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    initDb(':memory:');
+    app = Fastify();
+    await registerTurnRoutes(app);
+  });
+
+  describe('POST /api/sessions/:id/turns', () => {
+    it('returns 400 when user_prompt is missing', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/turns', payload: {} });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('returns 400 when user_prompt has wrong type', async () => {
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/s1/turns',
+        payload: { user_prompt: { nested: true } },
+      });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('returns 400 when user_prompt is empty', async () => {
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/s1/turns',
+        payload: { user_prompt: '   ' },
+      });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('returns 404 for missing session', async () => {
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/nonexistent/turns',
+        payload: { user_prompt: 'hello' },
+      });
+      expect(res.statusCode).toBe(404);
+    });
+
+    it('returns 409 when session is already running', async () => {
+      const db = getDb();
+      insertSession(db, 's1', { is_running: 1 });
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/s1/turns',
+        payload: { user_prompt: 'hello' },
+      });
+      expect(res.statusCode).toBe(409);
+    });
+
+    it('creates a turn and calls startTurn', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      mocks.startTurn.mockResolvedValue(undefined);
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/sessions/s1/turns',
+        payload: { user_prompt: 'hello' },
+      });
+      expect(res.statusCode).toBe(200);
+      const turn = res.json();
+      expect(turn.id).toBeDefined();
+      expect(turn.user_prompt).toBe('hello');
+      expect(turn.status).toBe('pending');
+
+      expect(mocks.startTurn).toHaveBeenCalledTimes(1);
+      const [sessionArg, turnArg] = mocks.startTurn.mock.calls[0];
+      expect(sessionArg.id).toBe('s1');
+      expect(turnArg.user_prompt).toBe('hello');
+    });
+  });
+
+  describe('POST /api/sessions/:id/cancel', () => {
+    it('returns 404 for missing session', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/sessions/nonexistent/cancel' });
+      expect(res.statusCode).toBe(404);
+    });
+
+    it('returns 409 when no running turn', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      mocks.interruptTurn.mockResolvedValue(false);
+      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/cancel' });
+      expect(res.statusCode).toBe(409);
+      expect(res.json().error).toBe('No running turn to cancel');
+    });
+
+    it('returns success when turn is cancelled', async () => {
+      const db = getDb();
+      insertSession(db, 's1');
+      mocks.interruptTurn.mockResolvedValue(true);
+      const res = await app.inject({ method: 'POST', url: '/api/sessions/s1/cancel' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual({ success: true });
+      expect(mocks.interruptTurn).toHaveBeenCalledWith('s1');
+    });
+  });
+});

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

@@ -1,13 +1,24 @@
 import type { FastifyInstance } from 'fastify';
 import { v4 as uuidv4 } from 'uuid';
 import { getDb } from '../db/index.ts';
-import { startTurn, interruptTurn } from '../codex/codex-provider.ts';
+import { getProvider } from '../providers/registry.ts';
 import type { Session, Turn } from '../db/schema.ts';
 
 export async function registerTurnRoutes(fastify: FastifyInstance): Promise<void> {
-  // POST /api/sessions/:id/turns — submit prompt, starts Codex turn
+  // POST /api/sessions/:id/turns — submit prompt, starts a turn
   fastify.post<{ Params: { id: string }; Body: { user_prompt: string } }>(
     '/api/sessions/:id/turns',
+    {
+      schema: {
+        body: {
+          type: 'object',
+          required: ['user_prompt'],
+          properties: {
+            user_prompt: { type: 'string', minLength: 1 },
+          },
+        },
+      },
+    },
     async (request, reply) => {
       const { id } = request.params;
       const { user_prompt } = request.body || {};
@@ -37,24 +48,33 @@ export async function registerTurnRoutes(fastify: FastifyInstance): Promise<void
       const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get(turnId) as Turn;
 
       // Fire and forget — events stream via WebSocket
-      startTurn(session, turn).catch((err) => {
-        console.error(`[codex-provider] Unhandled error for session ${id}:`, err);
-      });
+      getProvider(session.runtime_type)
+        .startTurn(session, turn)
+        .catch((err) => {
+          console.error(`[provider] Unhandled error for session ${id}:`, err);
+        });
 
       return turn;
     },
   );
 
   // POST /api/sessions/:id/cancel — cancel running turn
-  fastify.post<{ Params: { id: string } }>(
-    '/api/sessions/:id/cancel',
-    async (request, reply) => {
-      const { id } = request.params;
-      const cancelled = interruptTurn(id);
-      if (!cancelled) {
-        return reply.code(409).send({ error: 'No running turn to cancel' });
-      }
-      return { success: true };
-    },
-  );
+  fastify.post<{ Params: { id: string } }>('/api/sessions/:id/cancel', async (request, reply) => {
+    const { id } = request.params;
+    const db = getDb();
+
+    // Look up session to get runtime_type for provider dispatch
+    const session = db.prepare('SELECT runtime_type FROM sessions WHERE id = ?').get(id) as
+      | { runtime_type: string }
+      | undefined;
+    if (!session) {
+      return reply.code(404).send({ error: 'Session not found' });
+    }
+
+    const cancelled = await getProvider(session.runtime_type).interruptTurn(id);
+    if (!cancelled) {
+      return reply.code(409).send({ error: 'No running turn to cancel' });
+    }
+    return { success: true };
+  });
 }

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

@@ -0,0 +1,197 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Fastify, { type FastifyInstance } from 'fastify';
+import { initDb, getDb } from '../db/index.ts';
+import { registerWorkspaceRoutes } from './workspaces.ts';
+import { execFile } from 'node:child_process';
+
+// Mock child_process to avoid spawning osascript in tests
+vi.mock('node:child_process', () => ({
+  execFile: vi.fn(),
+}));
+
+const NOW = '2025-01-01T00:00:00Z';
+
+function insertWorkspace(
+  db: ReturnType<typeof getDb>,
+  id: string,
+  path: string,
+  overrides: Record<string, unknown> = {},
+): void {
+  db.prepare('INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, ?, ?, ?)').run(
+    id,
+    path,
+    (overrides['label'] as string | null) ?? null,
+    (overrides['deleted'] as number) ?? 0,
+    (overrides['created_at'] as string) ?? NOW,
+  );
+}
+
+/** Configure execFile mock to call callback with success.
+ *  Passes an object as the first result arg so promisify resolves with { stdout, stderr }.
+ */
+function mockExecFileSuccess(stdout: string): void {
+  const mock = execFile as unknown as ReturnType<typeof vi.fn>;
+  mock.mockImplementation((...args: unknown[]) => {
+    const cb = args[args.length - 1] as ((err: Error | null, ...results: unknown[]) => void) | undefined;
+    if (typeof cb === 'function') cb(null, { stdout, stderr: '' });
+  });
+}
+
+/** Configure execFile mock to call callback with error (simulates user cancel). */
+function mockExecFileError(error: Error): void {
+  const mock = execFile as unknown as ReturnType<typeof vi.fn>;
+  mock.mockImplementation((...args: unknown[]) => {
+    const cb = args[args.length - 1] as ((err: Error | null, ...results: unknown[]) => void) | undefined;
+    if (typeof cb === 'function') cb(error);
+  });
+}
+
+describe('Workspace routes', () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    initDb(':memory:');
+    app = Fastify();
+    await registerWorkspaceRoutes(app);
+  });
+
+  describe('GET /api/workspaces', () => {
+    it('returns empty array when no workspaces', async () => {
+      const res = await app.inject({ method: 'GET', url: '/api/workspaces' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual([]);
+    });
+
+    it('returns all workspaces ordered by created_at ASC', async () => {
+      const db = getDb();
+      insertWorkspace(db, 'w1', '/path/a', { created_at: '2025-01-02T00:00:00Z' });
+      insertWorkspace(db, 'w2', '/path/b', { created_at: '2025-01-01T00:00:00Z' });
+      const res = await app.inject({ method: 'GET', url: '/api/workspaces' });
+      const workspaces = res.json();
+      expect(workspaces).toHaveLength(2);
+      expect(workspaces[0].id).toBe('w2');
+      expect(workspaces[1].id).toBe('w1');
+    });
+  });
+
+  describe('POST /api/workspaces', () => {
+    it('returns 400 when path is missing', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/workspaces', payload: {} });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('returns 400 when path is empty', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/workspaces', payload: { path: '   ' } });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('returns 400 when path has wrong type', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/workspaces', payload: { path: { nested: true } } });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('returns 409 for duplicate active workspace', async () => {
+      const db = getDb();
+      insertWorkspace(db, 'w1', '/existing/path');
+      const res = await app.inject({ method: 'POST', url: '/api/workspaces', payload: { path: '/existing/path' } });
+      expect(res.statusCode).toBe(409);
+    });
+
+    it('creates a new workspace', async () => {
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/workspaces',
+        payload: { path: '/new/path', label: 'Test' },
+      });
+      expect(res.statusCode).toBe(200);
+      const ws = res.json();
+      expect(ws.id).toBeDefined();
+      expect(ws.path).toBe('/new/path');
+      expect(ws.label).toBe('Test');
+      expect(ws.deleted).toBe(0);
+    });
+
+    it('restores a soft-deleted workspace', async () => {
+      const db = getDb();
+      insertWorkspace(db, 'w1', '/deleted/path', { deleted: 1, label: 'Old' });
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/workspaces',
+        payload: { path: '/deleted/path', label: 'Restored' },
+      });
+      expect(res.statusCode).toBe(200);
+      const ws = res.json();
+      expect(ws.id).toBe('w1');
+      expect(ws.deleted).toBe(0);
+      expect(ws.label).toBe('Restored');
+    });
+  });
+
+  describe('POST /api/workspaces/hide', () => {
+    it('returns 400 when path is missing', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/workspaces/hide', payload: {} });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('soft-deletes existing workspace', async () => {
+      const db = getDb();
+      insertWorkspace(db, 'w1', '/path/to/hide');
+      const res = await app.inject({ method: 'POST', url: '/api/workspaces/hide', payload: { path: '/path/to/hide' } });
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual({ success: true });
+      const ws = db.prepare('SELECT deleted FROM workspaces WHERE id = ?').get('w1') as { deleted: number };
+      expect(ws.deleted).toBe(1);
+    });
+
+    it('creates and soft-deletes new workspace when path does not exist', async () => {
+      const res = await app.inject({ method: 'POST', url: '/api/workspaces/hide', payload: { path: '/new/path' } });
+      expect(res.statusCode).toBe(200);
+      const db = getDb();
+      const ws = db.prepare('SELECT * FROM workspaces WHERE path = ?').get('/new/path') as {
+        deleted: number;
+        id: string;
+      };
+      expect(ws.deleted).toBe(1);
+    });
+  });
+
+  describe('DELETE /api/workspaces/:id', () => {
+    it('returns 404 for missing workspace', async () => {
+      const res = await app.inject({ method: 'DELETE', url: '/api/workspaces/nonexistent' });
+      expect(res.statusCode).toBe(404);
+    });
+
+    it('returns 404 for already-deleted workspace', async () => {
+      const db = getDb();
+      insertWorkspace(db, 'w1', '/path', { deleted: 1 });
+      const res = await app.inject({ method: 'DELETE', url: '/api/workspaces/w1' });
+      expect(res.statusCode).toBe(404);
+    });
+
+    it('soft-deletes an active workspace', async () => {
+      const db = getDb();
+      insertWorkspace(db, 'w1', '/path');
+      const res = await app.inject({ method: 'DELETE', url: '/api/workspaces/w1' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual({ success: true });
+      const ws = db.prepare('SELECT deleted FROM workspaces WHERE id = ?').get('w1') as { deleted: number };
+      expect(ws.deleted).toBe(1);
+    });
+  });
+
+  describe('GET /api/pick-directory', () => {
+    it('returns path on success', async () => {
+      mockExecFileSuccess('/selected/path/\n');
+      const res = await app.inject({ method: 'GET', url: '/api/pick-directory' });
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual({ path: '/selected/path' });
+    });
+
+    it('returns 204 when user cancels', async () => {
+      mockExecFileError(new Error('User cancelled'));
+      const res = await app.inject({ method: 'GET', url: '/api/pick-directory' });
+      expect(res.statusCode).toBe(204);
+    });
+  });
+});

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

@@ -10,48 +10,57 @@ const execFileAsync = promisify(execFile);
 export async function registerWorkspaceRoutes(fastify: FastifyInstance): Promise<void> {
   // GET /api/workspaces — list ALL workspaces (active + soft-deleted)
   fastify.get('/api/workspaces', async () => {
-    const rows = getDb()
-      .prepare('SELECT * FROM workspaces ORDER BY created_at ASC')
-      .all() as Workspace[];
+    const rows = getDb().prepare('SELECT * FROM workspaces ORDER BY created_at ASC').all() as Workspace[];
     return rows;
   });
 
   // POST /api/workspaces — create workspace (or restore if soft-deleted)
-  fastify.post<{ Body: { path: string; label?: string } }>(
-    '/api/workspaces',
-    async (request, reply) => {
-      const { path, label = null } = request.body || {};
-      if (!path || !path.trim()) {
-        return reply.code(400).send({ error: 'Path is required' });
-      }
+  fastify.post<{ Body: { path: string; label?: string } }>('/api/workspaces', {
+    schema: {
+      body: {
+        type: 'object',
+        required: ['path'],
+        properties: {
+          path: { type: 'string' },
+          label: { type: 'string' },
+        },
+      },
+    },
+  }, async (request, reply) => {
+    const { path, label = null } = request.body || {};
+    if (!path || !path.trim()) {
+      return reply.code(400).send({ error: 'Path is required' });
+    }
 
-      const trimmedPath = path.trim();
-      const db = getDb();
+    const trimmedPath = path.trim();
+    const db = getDb();
 
-      // Check if workspace with this path already exists
-      const existing = db.prepare('SELECT * FROM workspaces WHERE path = ?').get(trimmedPath) as Workspace | undefined;
+    // Check if workspace with this path already exists
+    const existing = db.prepare('SELECT * FROM workspaces WHERE path = ?').get(trimmedPath) as Workspace | undefined;
 
-      if (existing) {
-        if (existing.deleted === 0) {
-          return reply.code(409).send({ error: 'Workspace with this path already exists' });
-        }
-        // Restore soft-deleted workspace
-        db.prepare('UPDATE workspaces SET deleted = 0, label = ? WHERE id = ?').run(label, existing.id);
-        const restored = db.prepare('SELECT * FROM workspaces WHERE id = ?').get(existing.id) as Workspace;
-        return restored;
+    if (existing) {
+      if (existing.deleted === 0) {
+        return reply.code(409).send({ error: 'Workspace with this path already exists' });
       }
+      // Restore soft-deleted workspace
+      db.prepare('UPDATE workspaces SET deleted = 0, label = ? WHERE id = ?').run(label, existing.id);
+      const restored = db.prepare('SELECT * FROM workspaces WHERE id = ?').get(existing.id) as Workspace;
+      return restored;
+    }
 
-      // Create new workspace
-      const id = uuidv4();
-      const now = new Date().toISOString();
-      db.prepare(
-        'INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, ?, 0, ?)',
-      ).run(id, trimmedPath, label, now);
+    // Create new workspace
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    db.prepare('INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, ?, 0, ?)').run(
+      id,
+      trimmedPath,
+      label,
+      now,
+    );
 
-      const workspace = db.prepare('SELECT * FROM workspaces WHERE id = ?').get(id) as Workspace;
-      return workspace;
-    },
-  );
+    const workspace = db.prepare('SELECT * FROM workspaces WHERE id = ?').get(id) as Workspace;
+    return workspace;
+  });
 
   // GET /api/pick-directory — open native OS folder picker (macOS only)
   fastify.get('/api/pick-directory', async (_request, reply) => {
@@ -69,30 +78,39 @@ export async function registerWorkspaceRoutes(fastify: FastifyInstance): Promise
   });
 
   // POST /api/workspaces/hide — soft-delete workspace by path (creates record if not exists)
-  fastify.post<{ Body: { path: string } }>(
-    '/api/workspaces/hide',
-    async (request, reply) => {
-      const { path } = request.body || {};
-      if (!path || !path.trim()) {
-        return reply.code(400).send({ error: 'Path is required' });
-      }
-      const trimmedPath = path.trim();
-      const db = getDb();
+  fastify.post<{ Body: { path: string } }>('/api/workspaces/hide', {
+    schema: {
+      body: {
+        type: 'object',
+        required: ['path'],
+        properties: {
+          path: { type: 'string' },
+        },
+      },
+    },
+  }, async (request, reply) => {
+    const { path } = request.body || {};
+    if (!path || !path.trim()) {
+      return reply.code(400).send({ error: 'Path is required' });
+    }
+    const trimmedPath = path.trim();
+    const db = getDb();
 
-      const existing = db.prepare('SELECT * FROM workspaces WHERE path = ?').get(trimmedPath) as Workspace | undefined;
-      if (existing) {
-        db.prepare('UPDATE workspaces SET deleted = 1 WHERE id = ?').run(existing.id);
-      } else {
-        const id = uuidv4();
-        const now = new Date().toISOString();
-        db.prepare(
-          'INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, NULL, 1, ?)',
-        ).run(id, trimmedPath, now);
-      }
+    const existing = db.prepare('SELECT * FROM workspaces WHERE path = ?').get(trimmedPath) as Workspace | undefined;
+    if (existing) {
+      db.prepare('UPDATE workspaces SET deleted = 1 WHERE id = ?').run(existing.id);
+    } else {
+      const id = uuidv4();
+      const now = new Date().toISOString();
+      db.prepare('INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, NULL, 1, ?)').run(
+        id,
+        trimmedPath,
+        now,
+      );
+    }
 
-      return { success: true };
-    },
-  );
+    return { success: true };
+  });
 
   // DELETE /api/workspaces/:id — soft-delete workspace by ID (does NOT delete sessions)
   fastify.delete<{ Params: { id: string } }>('/api/workspaces/:id', async (request, reply) => {
@@ -107,4 +125,4 @@ export async function registerWorkspaceRoutes(fastify: FastifyInstance): Promise
     db.prepare('UPDATE workspaces SET deleted = 1 WHERE id = ?').run(id);
     return { success: true };
   });
-}
+}