repoburg 1.3.185 → 1.3.188

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

@@ -0,0 +1,134 @@
+import type { FastifyInstance } from 'fastify';
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.ts';
+import type { Session, SessionDetail, Turn, Item } from '../db/schema.ts';
+
+/** Raw DB row for turns — token_usage is a JSON string, not parsed. */
+interface TurnRow extends Omit<Turn, 'token_usage'> {
+  token_usage: string | null;
+}
+
+/** Raw DB row for items — data is a JSON string, not parsed. */
+interface ItemRow extends Omit<Item, 'data'> {
+  data: string | null;
+}
+
+export async function registerSessionRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /api/sessions — list all sessions
+  fastify.get('/api/sessions', async () => {
+    const rows = getDb().prepare('SELECT * FROM sessions ORDER BY created_at DESC').all() as Session[];
+    return rows;
+  });
+
+  // GET /api/sessions/:id — session with turns + items
+  fastify.get<{ Params: { id: string } }>('/api/sessions/:id', async (request, reply) => {
+    const { id } = request.params;
+    const db = getDb();
+
+    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
+    if (!session) {
+      return reply.code(404).send({ error: 'Session not found' });
+    }
+
+    const turnRows = db.prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at ASC').all(id) as TurnRow[];
+    const itemRows = db.prepare(
+      'SELECT * FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?) ORDER BY created_at ASC',
+    ).all(id) as ItemRow[];
+
+    // Parse item data from JSON string and group by turn_id
+    const itemsByTurn = new Map<string, Item[]>();
+    for (const row of itemRows) {
+      const item: Item = {
+        ...row,
+        data: row.data ? JSON.parse(row.data) : null,
+      };
+      const list = itemsByTurn.get(item.turn_id) ?? [];
+      list.push(item);
+      itemsByTurn.set(item.turn_id, list);
+    }
+
+    const detail: SessionDetail = {
+      ...session,
+      turns: turnRows.map((row) => ({
+        ...row,
+        token_usage: row.token_usage ? JSON.parse(row.token_usage) : null,
+        items: itemsByTurn.get(row.id) ?? [],
+      })),
+    };
+
+    return detail;
+  });
+
+  // POST /api/sessions — create session
+  fastify.post<{ Body: { title?: string; runtime_type?: string; model?: string; cwd?: string } }>(
+    '/api/sessions',
+    async (request) => {
+      const { title = null, runtime_type = 'codex', model = null, cwd = null } = request.body || {};
+      const id = uuidv4();
+      const now = new Date().toISOString();
+
+      getDb().prepare(
+        `INSERT INTO sessions (id, title, runtime_type, model, cwd, external_thread_id, status, is_running, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, NULL, 'active', 0, ?, ?)`,
+      ).run(id, title, runtime_type, model, cwd, now, now);
+
+      const session = getDb().prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
+      return session;
+    },
+  );
+
+  // DELETE /api/sessions/:id — delete session (cascade)
+  fastify.delete<{ Params: { id: string } }>('/api/sessions/:id', async (request, reply) => {
+    const { id } = request.params;
+    const db = getDb();
+
+    const existing = db.prepare('SELECT id FROM sessions WHERE id = ?').get(id);
+    if (!existing) {
+      return reply.code(404).send({ error: 'Session not found' });
+    }
+
+    // Delete items first (turns cascade via FK, but better-sqlite3 needs explicit cascade if pragma is set)
+    db.prepare('DELETE FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?)').run(id);
+    db.prepare('DELETE FROM turns WHERE session_id = ?').run(id);
+    db.prepare('DELETE FROM sessions WHERE id = ?').run(id);
+
+    return { success: true };
+  });
+
+  // PATCH /api/sessions/:id — update session (title, lifecycle, has_unreviewed)
+  fastify.patch<{ Params: { id: string }; Body: { title?: string; lifecycle?: string; has_unreviewed?: number } }>(
+    '/api/sessions/:id',
+    async (request, reply) => {
+      const { id } = request.params;
+      const { title, lifecycle, has_unreviewed } = request.body || {};
+      const db = getDb();
+
+      const existing = db.prepare('SELECT id FROM sessions WHERE id = ?').get(id);
+      if (!existing) {
+        return reply.code(404).send({ error: 'Session not found' });
+      }
+
+      const now = new Date().toISOString();
+      const updates: string[] = ['updated_at = ?'];
+      const params: (string | number | null)[] = [now];
+
+      if (title !== undefined) {
+        updates.push('title = ?');
+        params.push(title);
+      }
+      if (lifecycle !== undefined) {
+        updates.push('lifecycle = ?');
+        params.push(lifecycle);
+      }
+      if (has_unreviewed !== undefined) {
+        updates.push('has_unreviewed = ?');
+        params.push(has_unreviewed);
+      }
+
+      db.prepare(`UPDATE sessions SET ${updates.join(', ')} WHERE id = ?`).run(...params, id);
+
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session;
+      return session;
+    },
+  );
+}

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

@@ -0,0 +1,60 @@
+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 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
+  fastify.post<{ Params: { id: string }; Body: { user_prompt: string } }>(
+    '/api/sessions/:id/turns',
+    async (request, reply) => {
+      const { id } = request.params;
+      const { user_prompt } = request.body || {};
+
+      if (!user_prompt || !user_prompt.trim()) {
+        return reply.code(400).send({ error: 'user_prompt is required' });
+      }
+
+      const db = getDb();
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id) as Session | undefined;
+      if (!session) {
+        return reply.code(404).send({ error: 'Session not found' });
+      }
+
+      if (session.is_running) {
+        return reply.code(409).send({ error: 'A turn is already running for this session' });
+      }
+
+      // Create turn in DB
+      const turnId = uuidv4();
+      const now = new Date().toISOString();
+      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(turnId, id, user_prompt, now, now);
+
+      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);
+      });
+
+      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 };
+    },
+  );
+}

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

@@ -0,0 +1,110 @@
+import type { FastifyInstance } from 'fastify';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db/index.ts';
+import type { Workspace } from '../db/schema.ts';
+
+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[];
+    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' });
+      }
+
+      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;
+
+      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);
+
+      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) => {
+    try {
+      const { stdout } = await execFileAsync('osascript', [
+        '-e',
+        'POSIX path of (choose folder with prompt "Select a workspace directory")',
+      ]);
+      const path = stdout.trim().replace(/\/$/, '');
+      return { path };
+    } catch {
+      // User cancelled the dialog or osascript not available
+      return reply.code(204).send({ cancelled: true });
+    }
+  });
+
+  // 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();
+
+      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 };
+    },
+  );
+
+  // DELETE /api/workspaces/:id — soft-delete workspace by ID (does NOT delete sessions)
+  fastify.delete<{ Params: { id: string } }>('/api/workspaces/:id', async (request, reply) => {
+    const { id } = request.params;
+    const db = getDb();
+
+    const existing = db.prepare('SELECT id FROM workspaces WHERE id = ? AND deleted = 0').get(id);
+    if (!existing) {
+      return reply.code(404).send({ error: 'Workspace not found' });
+    }
+
+    db.prepare('UPDATE workspaces SET deleted = 1 WHERE id = ?').run(id);
+    return { success: true };
+  });
+}

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

@@ -0,0 +1,43 @@
+import type { WebSocket } from 'ws';
+import { WebSocketServer } from 'ws';
+
+let wss: WebSocketServer | null = null;
+
+/** Attach WebSocket server to an existing HTTP server (noServer mode). */
+export function initWs(): WebSocketServer {
+  wss = new WebSocketServer({ noServer: true });
+  return wss;
+}
+
+/** Handle HTTP upgrade for the /ws path. Call from server.on('upgrade'). */
+export function handleUpgrade(
+  wss: WebSocketServer,
+  request: any,
+  socket: any,
+  head: any,
+): void {
+  const url = request.url || '';
+  if (url.startsWith('/ws')) {
+    wss.handleUpgrade(request, socket, head, (ws: WebSocket) => {
+      wss.emit('connection', ws, request);
+    });
+  } else {
+    socket.destroy();
+  }
+}
+
+/** Broadcast a JSON event to all connected WebSocket clients. */
+export function broadcast(event: string, data: unknown): void {
+  if (!wss) return;
+  const message = JSON.stringify({ event, data });
+  for (const client of wss.clients) {
+    if (client.readyState === client.OPEN) {
+      client.send(message);
+    }
+  }
+}
+
+/** Get the WebSocket server instance (or null if not initialized). */
+export function getWss(): WebSocketServer | null {
+  return wss;
+}

package/agent-pane/backend/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "resolveJsonModule": true,
+    "declaration": false,
+    "sourceMap": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowImportingTsExtensions": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/agent-pane/frontend/index.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>AgentPane</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@400;450;510;590;600&family=JetBrains+Mono:wght@400;500&display=swap"
+      rel="stylesheet"
+    />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>