repoburg 1.3.185 → 1.3.188

package/agent-pane/backend/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "agent-pane-backend",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js --format=esm",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@fastify/cors": "^10.0.0",
+    "@openai/codex-sdk": "^0.147.0",
+    "better-sqlite3": "^11.8.0",
+    "fastify": "^5.2.0",
+    "uuid": "^11.1.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^22.10.0",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.5.13",
+    "esbuild": "^0.24.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}

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

@@ -0,0 +1,363 @@
+import { Codex, type Thread, type ThreadEvent, type ThreadItem, type ThreadOptions } from '@openai/codex-sdk';
+import { v4 as uuidv4 } from 'uuid';
+import Database from 'better-sqlite3';
+import { readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { getDb } from '../db/index.ts';
+import { broadcast } from '../ws/index.ts';
+import { mapItemData, getItemStatus } from './item-mapper.ts';
+import type { Session, Turn, Item, ItemStatus } from '../db/schema.ts';
+
+interface ThreadEntry {
+  codex: Codex;
+  thread: Thread;
+  abortController: AbortController | null;
+}
+
+const threadMap = new Map<string, ThreadEntry>();
+
+function getThreadOptions(session: Session): ThreadOptions {
+  return {
+    model: session.model ?? undefined,
+    workingDirectory: session.cwd ?? undefined,
+    sandboxMode: 'workspace-write',
+    approvalPolicy: 'never',
+    skipGitRepoCheck: true,
+  };
+}
+
+function getOrCreateThread(session: Session): { codex: Codex; thread: Thread } {
+  const existing = threadMap.get(session.id);
+  if (existing) {
+    return { codex: existing.codex, thread: existing.thread };
+  }
+
+  const codex = new Codex();
+  let thread: Thread;
+
+  if (session.external_thread_id) {
+    thread = codex.resumeThread(session.external_thread_id, getThreadOptions(session));
+  } else {
+    thread = codex.startThread(getThreadOptions(session));
+  }
+
+  return { codex, thread };
+}
+
+/** Start a Codex turn. Fire-and-forget — streams events via WS. */
+export async function startTurn(session: Session, turn: Turn): Promise<void> {
+  const db = getDb();
+
+  // Phase 1: create or resume thread
+  let codex: Codex;
+  let thread: Thread;
+
+  try {
+    const result = getOrCreateThread(session);
+    codex = result.codex;
+    thread = result.thread;
+  } catch (err) {
+    const errMsg = `Failed to create Codex thread: ${(err as Error).message}`;
+    const now = new Date().toISOString();
+    db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
+      .run('failed', errMsg, now, turn.id);
+    db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
+      .run('failed', now, session.id);
+    broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
+    return;
+  }
+
+  // Phase 2: set up abort controller and update status
+  const abortController = new AbortController();
+  threadMap.set(session.id, { codex, thread, abortController });
+
+  const now = new Date().toISOString();
+  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?')
+    .run('running', now, turn.id);
+  db.prepare('UPDATE sessions SET is_running = 1, status = ?, updated_at = ? WHERE id = ?')
+    .run('running', now, session.id);
+
+  broadcast('turn:started', { sessionId: session.id, turnId: turn.id });
+
+  // Phase 3: run the turn and handle events
+  try {
+    const { events } = await thread.runStreamed(turn.user_prompt, { signal: abortController.signal });
+
+    for await (const event of events) {
+      handleEvent(event, session.id, turn.id);
+    }
+  } catch (err) {
+    const isAbort = abortController.signal.aborted || (err as Error).name === 'AbortError';
+    const errMsg = (err as Error).message;
+    const now2 = new Date().toISOString();
+
+    if (isAbort) {
+      db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?')
+        .run('aborted', now2, turn.id);
+      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
+        .run('active', now2, session.id);
+      broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: 'Turn cancelled by user' });
+    } else {
+      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
+        .run('failed', errMsg, now2, turn.id);
+      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
+        .run('failed', now2, session.id);
+      broadcast('turn:failed', { sessionId: session.id, turnId: turn.id, error: errMsg });
+    }
+  } finally {
+    const entry = threadMap.get(session.id);
+    if (entry) {
+      threadMap.set(session.id, { ...entry, abortController: null });
+    }
+  }
+}
+
+/** Cancel a running turn by session ID. Returns true if a turn was cancelled. */
+export function interruptTurn(sessionId: string): boolean {
+  const entry = threadMap.get(sessionId);
+  if (entry?.abortController) {
+    entry.abortController.abort();
+    return true;
+  }
+  return false;
+}
+
+function handleEvent(event: ThreadEvent, sessionId: string, turnId: string): void {
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  switch (event.type) {
+    case 'thread.started': {
+      db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?')
+        .run(event.thread_id, now, sessionId);
+      break;
+    }
+
+    case 'turn.started': {
+      // Already broadcasted turn:started before the stream started.
+      break;
+    }
+
+    case 'item.started': {
+      const item = event.item;
+      const itemId = uuidv4();
+      const data = mapItemData(item);
+      db.prepare(
+        'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+      ).run(itemId, turnId, item.id, item.type, JSON.stringify(data), 'in_progress', now, now);
+
+      broadcast('item:started', { sessionId, turnId, item: makeItem(itemId, turnId, item, 'in_progress', now, now) });
+      break;
+    }
+
+    case 'item.updated': {
+      const item = event.item;
+      const data = mapItemData(item);
+      const result = db.prepare('UPDATE items SET data = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
+        .run(JSON.stringify(data), now, item.id, turnId);
+
+      // SDK may skip item.started — insert if missing
+      if (result.changes === 0) {
+        const itemId = uuidv4();
+        db.prepare(
+          'INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+        ).run(itemId, turnId, item.id, item.type, JSON.stringify(data), 'in_progress', now, now);
+        broadcast('item:updated', { sessionId, turnId, item: makeItem(itemId, turnId, item, 'in_progress', now, now) });
+      } else {
+        const row = db.prepare('SELECT id, status, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
+          .get(item.id, turnId) as { id: string; status: ItemStatus; created_at: string } | undefined;
+        if (row) {
+          broadcast('item:updated', { sessionId, turnId, item: makeItem(row.id, turnId, item, row.status, row.created_at, now) });
+        }
+      }
+      break;
+    }
+
+    case 'item.completed': {
+      const item = event.item;
+      const status = getItemStatus(item);
+      const data = mapItemData(item);
+      const result = db.prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE external_item_id = ? AND turn_id = ?')
+        .run(JSON.stringify(data), status, now, item.id, turnId);
+
+      // SDK may skip item.started — insert if missing
+      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, item.id, item.type, JSON.stringify(data), status, now, now);
+      } else {
+        const row = db.prepare('SELECT id, created_at FROM items WHERE external_item_id = ? AND turn_id = ?')
+          .get(item.id, turnId) as { id: string; created_at: string };
+        itemId = row.id;
+        createdAt = row.created_at;
+      }
+
+      // Update turn-level fields
+      if (item.type === 'agent_message') {
+        db.prepare('UPDATE turns SET agent_response = ?, updated_at = ? WHERE id = ?')
+          .run(item.text, now, turnId);
+      }
+      if (item.type === 'reasoning') {
+        const existing = db.prepare('SELECT thoughts FROM turns WHERE id = ?').get(turnId) as { thoughts: string | null };
+        const thoughts = existing.thoughts ? existing.thoughts + '\n' + item.text : item.text;
+        db.prepare('UPDATE turns SET thoughts = ?, updated_at = ? WHERE id = ?')
+          .run(thoughts, now, turnId);
+      }
+
+      broadcast('item:completed', { sessionId, turnId, item: makeItem(itemId, turnId, item, status, createdAt, now) });
+      break;
+    }
+
+    case 'turn.completed': {
+      const usage = event.usage;
+      db.prepare('UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?')
+        .run('completed', JSON.stringify(usage), now, turnId);
+      db.prepare('UPDATE sessions SET is_running = 0, status = ?, has_unreviewed = 1, updated_at = ? WHERE id = ?')
+        .run('active', now, sessionId);
+      broadcast('turn:completed', { sessionId, turnId, usage, hasUnreviewed: true });
+
+      // Auto-generate session title from first turn (if title is still null)
+      syncThreadTitle(sessionId);
+      break;
+    }
+
+    case 'turn.failed': {
+      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
+        .run('failed', event.error.message, now, turnId);
+      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
+        .run('failed', now, sessionId);
+      broadcast('turn:failed', { sessionId, turnId, error: event.error.message });
+      break;
+    }
+
+    case 'error': {
+      db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?')
+        .run('failed', event.message, now, turnId);
+      db.prepare('UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE id = ?')
+        .run('failed', now, sessionId);
+      broadcast('turn:failed', { sessionId, turnId, error: event.message });
+      break;
+    }
+  }
+}
+
+function makeItem(
+  id: string,
+  turnId: string,
+  sdkItem: ThreadItem,
+  status: ItemStatus,
+  createdAt: string,
+  updatedAt: string,
+): Item {
+  return {
+    id,
+    turn_id: turnId,
+    external_item_id: sdkItem.id,
+    type: sdkItem.type,
+    data: mapItemData(sdkItem),
+    status,
+    created_at: createdAt,
+    updated_at: updatedAt,
+  };
+}
+
+/** Tracks sessions currently generating titles — prevents duplicate throwaway threads. */
+const titleGenerating = new Set<string>();
+
+/** Generate a title for the session using a throwaway Codex thread.
+ *  Only runs once per session — guarded by title === null AND titleGenerating set. */
+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; // Already has a title
+  if (titleGenerating.has(sessionId)) return; // Already generating
+
+  // Get the first turn's user_prompt and agent_response
+  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;
+
+  // Mark as generating — prevents concurrent title generation for same session
+  titleGenerating.add(sessionId);
+
+  // Fire-and-forget — don't block the turn:completed handler
+  generateTitleAsync(sessionId, turn.user_prompt, turn.agent_response).finally(() => {
+    titleGenerating.delete(sessionId);
+  });
+}
+
+/** Create a throwaway Codex thread, ask for a title, update the session, then clean up. */
+async function generateTitleAsync(sessionId: string, userPrompt: string, agentResponse: string | null): Promise<void> {
+  let throwawayThreadId: string | null = null;
+  try {
+    const codex = new Codex();
+    const thread = codex.startThread({ skipGitRepoCheck: true });
+    throwawayThreadId = thread.id;
+
+    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}"`;
+
+    const result = await thread.run(titlePrompt);
+    const title = result.finalResponse.trim().replace(/^["']|["']$/g, '').slice(0, 100);
+
+    if (title) {
+      const db = getDb();
+      const now = new Date().toISOString();
+      db.prepare('UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?').run(title, now, sessionId);
+      broadcast('session:title', { sessionId, title });
+    }
+  } catch {
+    // Silently skip on error — session keeps null title
+  } finally {
+    // Clean up the throwaway thread
+    if (throwawayThreadId) {
+      cleanupThrowawayThread(throwawayThreadId);
+    }
+  }
+}
+
+/** Delete throwaway thread from Codex state DB, rollout file, and session_index.jsonl. */
+function cleanupThrowawayThread(threadId: string): void {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+
+  // 1. Delete from state DB and get rollout path
+  try {
+    const codexDb = new Database(`${home}/.codex/state_5.sqlite`);
+    const row = codexDb.prepare('SELECT rollout_path FROM threads WHERE id = ?')
+      .get(threadId) as { rollout_path: string } | undefined;
+
+    codexDb.prepare('DELETE FROM thread_spawn_edges WHERE child_thread_id = ? OR parent_thread_id = ?').run(threadId, threadId);
+    codexDb.prepare('DELETE FROM threads WHERE id = ?').run(threadId);
+    codexDb.close();
+
+    // 2. Delete rollout file
+    if (row?.rollout_path) {
+      try { unlinkSync(row.rollout_path); } catch { /* file may not exist */ }
+    }
+  } catch {
+    // DB not found — skip
+  }
+
+  // 3. Remove from session_index.jsonl
+  try {
+    const indexPath = `${home}/.codex/session_index.jsonl`;
+    const content = readFileSync(indexPath, 'utf-8');
+    const lines = content.trim().split('\n').filter((line) => {
+      try {
+        const entry = JSON.parse(line) as { id: string };
+        return entry.id !== threadId;
+      } catch {
+        return true; // keep unparseable lines
+      }
+    });
+    writeFileSync(indexPath, lines.join('\n') + '\n');
+  } catch {
+    // File not found — skip
+  }
+}

package/agent-pane/backend/src/codex/item-mapper.ts

@@ -0,0 +1,59 @@
+import type { ThreadItem } from '@openai/codex-sdk';
+
+/** Map a Codex ThreadItem to the JSON `data` field for the items table. */
+export function mapItemData(item: ThreadItem): Record<string, unknown> {
+  switch (item.type) {
+    case 'agent_message':
+      return { text: item.text };
+
+    case 'reasoning':
+      return { text: item.text };
+
+    case 'command_execution':
+      return {
+        command: item.command,
+        aggregated_output: item.aggregated_output,
+        exit_code: item.exit_code ?? null,
+        status: item.status,
+      };
+
+    case 'file_change':
+      return {
+        changes: item.changes,
+        status: item.status,
+      };
+
+    case 'mcp_tool_call':
+      return {
+        server: item.server,
+        tool: item.tool,
+        arguments: item.arguments,
+        result: item.result ?? null,
+        error: item.error ?? null,
+        status: item.status,
+      };
+
+    case 'web_search':
+      return { query: item.query };
+
+    case 'todo_list':
+      return { items: item.items };
+
+    case 'error':
+      return { message: item.message };
+
+    default:
+      return {};
+  }
+}
+
+/** Determine the DB status from a completed ThreadItem. */
+export function getItemStatus(item: ThreadItem): 'in_progress' | 'completed' | 'failed' {
+  if (item.type === 'command_execution' || item.type === 'file_change' || item.type === 'mcp_tool_call') {
+    return item.status;
+  }
+  if (item.type === 'error') {
+    return 'failed';
+  }
+  return 'completed';
+}

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

@@ -0,0 +1,91 @@
+import Database from 'better-sqlite3';
+import type { Database as DB } from 'better-sqlite3';
+
+let db: DB;
+
+export function initDb(path: string = 'data.db'): DB {
+  db = new Database(path);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+
+  createTables(db);
+  return db;
+}
+
+export function getDb(): DB {
+  if (!db) {
+    throw new Error('Database not initialized. Call initDb() first.');
+  }
+  return db;
+}
+
+function createTables(database: DB): void {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id                  TEXT PRIMARY KEY,
+      title               TEXT,
+      runtime_type        TEXT NOT NULL DEFAULT 'codex',
+      model               TEXT,
+      cwd                 TEXT,
+      external_thread_id  TEXT,
+      status              TEXT NOT NULL DEFAULT 'active',
+      is_running          INTEGER NOT NULL DEFAULT 0,
+      created_at          TEXT NOT NULL,
+      updated_at          TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS turns (
+      id                  TEXT PRIMARY KEY,
+      session_id          TEXT NOT NULL,
+      user_prompt         TEXT NOT NULL,
+      agent_response      TEXT,
+      thoughts            TEXT,
+      token_usage         TEXT,
+      external_turn_id    TEXT,
+      status              TEXT NOT NULL DEFAULT 'pending',
+      error               TEXT,
+      created_at          TEXT NOT NULL,
+      updated_at          TEXT NOT NULL,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS items (
+      id                  TEXT PRIMARY KEY,
+      turn_id             TEXT NOT NULL,
+      external_item_id    TEXT,
+      type                TEXT NOT NULL,
+      data                TEXT,
+      status              TEXT NOT NULL DEFAULT 'in_progress',
+      created_at          TEXT NOT NULL,
+      updated_at          TEXT NOT NULL,
+      FOREIGN KEY (turn_id) REFERENCES turns(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id          TEXT PRIMARY KEY,
+      path        TEXT NOT NULL UNIQUE,
+      label       TEXT,
+      deleted     INTEGER NOT NULL DEFAULT 0,
+      created_at  TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_turns_session_id ON turns(session_id);
+    CREATE INDEX IF NOT EXISTS idx_items_turn_id ON items(turn_id);
+    CREATE INDEX IF NOT EXISTS idx_workspaces_path ON workspaces(path);
+  `);
+
+  // Migration: add 'deleted' column to existing workspaces table if missing
+  const wsColumns = database.prepare("PRAGMA table_info(workspaces)").all() as { name: string }[];
+  if (!wsColumns.some((c) => c.name === 'deleted')) {
+    database.exec('ALTER TABLE workspaces ADD COLUMN deleted INTEGER NOT NULL DEFAULT 0');
+  }
+
+  // Migration: add 'lifecycle' + 'has_unreviewed' columns to existing sessions table
+  const sessColumns = database.prepare("PRAGMA table_info(sessions)").all() as { name: string }[];
+  if (!sessColumns.some((c) => c.name === 'lifecycle')) {
+    database.exec("ALTER TABLE sessions ADD COLUMN lifecycle TEXT NOT NULL DEFAULT 'working'");
+  }
+  if (!sessColumns.some((c) => c.name === 'has_unreviewed')) {
+    database.exec('ALTER TABLE sessions ADD COLUMN has_unreviewed INTEGER NOT NULL DEFAULT 0');
+  }
+}

package/agent-pane/backend/src/db/schema.ts

@@ -0,0 +1,76 @@
+// Database schema — TypeScript interfaces (no ORM, raw SQL).
+
+export type SessionStatus = 'active' | 'running' | 'completed' | 'failed' | 'aborted';
+export type TurnStatus = 'pending' | 'running' | 'completed' | 'failed' | 'aborted';
+export type ItemType =
+  | 'agent_message'
+  | 'reasoning'
+  | 'command_execution'
+  | 'file_change'
+  | 'mcp_tool_call'
+  | 'web_search'
+  | 'todo_list'
+  | 'error';
+export type ItemStatus = 'in_progress' | 'completed' | 'failed';
+
+export interface Session {
+  id: string;
+  title: string | null;
+  runtime_type: string; // 'codex' (future: 'claude', 'cursor')
+  model: string | null;
+  cwd: string | null;
+  external_thread_id: string | null; // Codex thread ID for resume
+  status: SessionStatus;
+  is_running: number; // 0 | 1
+  lifecycle: string; // 'working' | 'finished'
+  has_unreviewed: number; // 0 | 1
+  created_at: string; // ISO
+  updated_at: string; // ISO
+}
+
+export interface TokenUsage {
+  input_tokens: number;
+  cached_input_tokens: number;
+  cache_write_input_tokens: number;
+  output_tokens: number;
+  reasoning_output_tokens: number;
+}
+
+export interface Turn {
+  id: string;
+  session_id: string;
+  user_prompt: string;
+  agent_response: string | null;
+  thoughts: string | null;
+  token_usage: TokenUsage | null;
+  external_turn_id: string | null;
+  status: TurnStatus;
+  error: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Item {
+  id: string;
+  turn_id: string;
+  external_item_id: string | null;
+  type: ItemType;
+  data: Record<string, unknown> | null;
+  status: ItemStatus;
+  created_at: string;
+  updated_at: string;
+}
+
+// Workspaces — directory paths for grouping sessions in sidebar
+export interface Workspace {
+  id: string;
+  path: string; // directory path, e.g. "/Users/me/projects/my-app"
+  label: string | null; // optional custom label, null = use basename
+  deleted: number; // 0 = active, 1 = soft-deleted (hidden from sidebar)
+  created_at: string; // ISO
+}
+
+// Nested session detail for GET /api/sessions/:id
+export interface SessionDetail extends Session {
+  turns: (Turn & { items: Item[] })[];
+}

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

@@ -0,0 +1,57 @@
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import { initDb } from './db/index.ts';
+import { initWs, handleUpgrade, getWss } from './ws/index.ts';
+import { registerSessionRoutes } from './routes/sessions.ts';
+import { registerTurnRoutes } from './routes/turns.ts';
+import { registerWorkspaceRoutes } from './routes/workspaces.ts';
+
+const PORT = 3001;
+
+async function main(): Promise<void> {
+  // Initialize database
+  initDb('data.db');
+
+  // Create Fastify server
+  const fastify = Fastify({ logger: true });
+
+  // Register CORS (allow Vite dev server)
+  await fastify.register(cors, { origin: true });
+
+  // Register routes
+  await registerSessionRoutes(fastify);
+  await registerTurnRoutes(fastify);
+  await registerWorkspaceRoutes(fastify);
+
+  // Initialize WebSocket server (noServer mode)
+  const wss = initWs();
+
+  // Handle HTTP upgrade for /ws path
+  fastify.server.on('upgrade', (request, socket, head) => {
+    const wsServer = getWss();
+    if (wsServer) {
+      handleUpgrade(wsServer, request, socket, head);
+    } else {
+      socket.destroy();
+    }
+  });
+
+  wss.on('connection', (ws) => {
+    fastify.log.info('WebSocket client connected');
+    ws.on('close', () => {
+      fastify.log.info('WebSocket client disconnected');
+    });
+  });
+
+  // Start server
+  try {
+    await fastify.listen({ port: PORT, host: '0.0.0.0' });
+    fastify.log.info(`AgentPane backend running on http://localhost:${PORT}`);
+    fastify.log.info(`WebSocket endpoint: ws://localhost:${PORT}/ws`);
+  } catch (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+}
+
+main();