repoburg 1.3.188 → 1.3.196

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

@@ -0,0 +1,221 @@
+import { describe, it, expect } from 'vitest';
+import { mapItemData, getItemStatus } from './item-mapper.ts';
+import { mapTokenUsage } from './app-server-types.ts';
+import type { AppServerItem, AppServerTokenUsageData } from './app-server-types.ts';
+
+/** Helper to create an AppServerItem with required id field. */
+function makeItem(partial: Partial<AppServerItem> & { type: string }): AppServerItem {
+  return { id: 'test-item', ...partial } as AppServerItem;
+}
+
+describe('mapItemData', () => {
+  it('maps agent_message to { text }', () => {
+    const item = makeItem({ type: 'agent_message', text: 'Hello world' });
+    expect(mapItemData(item)).toEqual({ text: 'Hello world' });
+  });
+
+  it('maps reasoning to { text }', () => {
+    const item = makeItem({ type: 'reasoning', text: 'Thinking...' });
+    expect(mapItemData(item)).toEqual({ text: 'Thinking...' });
+  });
+
+  it('maps reasoning with summary array to joined text', () => {
+    const item = makeItem({ type: 'reasoning', summary: ['First thought', 'Second thought'] });
+    expect(mapItemData(item)).toEqual({ text: 'First thought\nSecond thought' });
+  });
+
+  it('maps reasoning with empty summary and content to empty text', () => {
+    const item = makeItem({ type: 'reasoning', summary: [], content: [] });
+    expect(mapItemData(item)).toEqual({ text: '' });
+  });
+
+  it('maps command_execution with all fields', () => {
+    const item = makeItem({
+      type: 'command_execution',
+      command: 'ls -la',
+      aggregated_output: 'total 0',
+      exit_code: 0,
+      status: 'completed',
+    });
+    expect(mapItemData(item)).toEqual({
+      command: 'ls -la',
+      aggregated_output: 'total 0',
+      exit_code: 0,
+      status: 'completed',
+    });
+  });
+
+  it('maps command_execution with null exit_code', () => {
+    const item = makeItem({
+      type: 'command_execution',
+      command: 'npm install',
+      aggregated_output: 'done',
+      status: 'completed',
+    });
+    expect(mapItemData(item)).toEqual({
+      command: 'npm install',
+      aggregated_output: 'done',
+      exit_code: null,
+      status: 'completed',
+    });
+  });
+
+  it('maps file_change with changes and status', () => {
+    const changes = [{ path: 'src/index.ts', change_type: 'modify' }];
+    const item = makeItem({ type: 'file_change', changes, status: 'completed' });
+    expect(mapItemData(item)).toEqual({ changes, status: 'completed' });
+  });
+
+  it('maps mcp_tool_call with all fields', () => {
+    const args = { query: 'test' };
+    const result = { data: 'response' };
+    const item = makeItem({
+      type: 'mcp_tool_call',
+      server: 'myserver',
+      tool: 'search',
+      arguments: args,
+      result,
+      error: null,
+      status: 'completed',
+    });
+    expect(mapItemData(item)).toEqual({
+      server: 'myserver',
+      tool: 'search',
+      arguments: args,
+      result,
+      error: null,
+      status: 'completed',
+    });
+  });
+
+  it('maps mcp_tool_call with null result and error', () => {
+    const item = makeItem({
+      type: 'mcp_tool_call',
+      server: 'srv',
+      tool: 't',
+      arguments: {},
+      status: 'failed',
+    });
+    expect(mapItemData(item)).toEqual({
+      server: 'srv',
+      tool: 't',
+      arguments: {},
+      result: null,
+      error: null,
+      status: 'failed',
+    });
+  });
+
+  it('maps web_search to { query }', () => {
+    const item = makeItem({ type: 'web_search', query: 'typescript vitest' });
+    expect(mapItemData(item)).toEqual({ query: 'typescript vitest' });
+  });
+
+  it('maps todo_list to { items }', () => {
+    const items = [{ content: 'task 1', status: 'completed' }];
+    const item = makeItem({ type: 'todo_list', items });
+    expect(mapItemData(item)).toEqual({ items });
+  });
+
+  it('maps error to { message }', () => {
+    const item = makeItem({ type: 'error', message: 'Something went wrong' });
+    expect(mapItemData(item)).toEqual({ message: 'Something went wrong' });
+  });
+
+  it('returns empty object for unknown type', () => {
+    const item = makeItem({ type: 'unknown_type' });
+    expect(mapItemData(item)).toEqual({});
+  });
+});
+
+describe('getItemStatus', () => {
+  it('returns item.status for command_execution', () => {
+    const item = makeItem({
+      type: 'command_execution',
+      command: 'ls',
+      aggregated_output: '',
+      exit_code: 1,
+      status: 'failed',
+    });
+    expect(getItemStatus(item)).toBe('failed');
+  });
+
+  it('returns item.status for file_change', () => {
+    const item = makeItem({ type: 'file_change', changes: [], status: 'in_progress' });
+    expect(getItemStatus(item)).toBe('in_progress');
+  });
+
+  it('returns item.status for mcp_tool_call', () => {
+    const item = makeItem({
+      type: 'mcp_tool_call',
+      server: 's',
+      tool: 't',
+      arguments: {},
+      status: 'completed',
+    });
+    expect(getItemStatus(item)).toBe('completed');
+  });
+
+  it('returns failed for error type', () => {
+    const item = makeItem({ type: 'error', message: 'boom' });
+    expect(getItemStatus(item)).toBe('failed');
+  });
+
+  it('returns completed for agent_message', () => {
+    const item = makeItem({ type: 'agent_message', text: 'hi' });
+    expect(getItemStatus(item)).toBe('completed');
+  });
+
+  it('returns completed for reasoning', () => {
+    const item = makeItem({ type: 'reasoning', text: 'thinking' });
+    expect(getItemStatus(item)).toBe('completed');
+  });
+
+  it('returns completed for web_search', () => {
+    const item = makeItem({ type: 'web_search', query: 'test' });
+    expect(getItemStatus(item)).toBe('completed');
+  });
+
+  it('returns completed for todo_list', () => {
+    const item = makeItem({ type: 'todo_list', items: [] });
+    expect(getItemStatus(item)).toBe('completed');
+  });
+});
+
+describe('mapTokenUsage', () => {
+  it('maps camelCase app-server fields to snake_case TokenUsage', () => {
+    const data: AppServerTokenUsageData = {
+      totalTokens: 15910,
+      inputTokens: 15901,
+      cachedInputTokens: 11008,
+      cacheWriteInputTokens: 0,
+      outputTokens: 9,
+      reasoningOutputTokens: 0,
+    };
+    expect(mapTokenUsage(data)).toEqual({
+      input_tokens: 15901,
+      cached_input_tokens: 11008,
+      cache_write_input_tokens: 0,
+      output_tokens: 9,
+      reasoning_output_tokens: 0,
+    });
+  });
+
+  it('maps zero values correctly', () => {
+    const data: AppServerTokenUsageData = {
+      totalTokens: 0,
+      inputTokens: 0,
+      cachedInputTokens: 0,
+      cacheWriteInputTokens: 0,
+      outputTokens: 0,
+      reasoningOutputTokens: 0,
+    };
+    expect(mapTokenUsage(data)).toEqual({
+      input_tokens: 0,
+      cached_input_tokens: 0,
+      cache_write_input_tokens: 0,
+      output_tokens: 0,
+      reasoning_output_tokens: 0,
+    });
+  });
+});

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

@@ -1,14 +1,28 @@
-import type { ThreadItem } from '@openai/codex-sdk';
+import type { AppServerItem } from './app-server-types.ts';
 
-/** Map a Codex ThreadItem to the JSON `data` field for the items table. */
-export function mapItemData(item: ThreadItem): Record<string, unknown> {
+/**
+ * Map an app-server item to a plain object for JSON storage in the items table.
+ *
+ * App-server uses camelCase type names: `agentMessage`, `userMessage`,
+ * `commandExecution`, `fileChange`, `mcpToolCall`, `webSearch`, `todoList`, `error`.
+ *
+ * @param item — The app-server item to map.
+ * @returns A plain object suitable for `JSON.stringify` into the `data` column.
+ */
+export function mapItemData(item: AppServerItem): Record<string, unknown> {
   switch (item.type) {
+    case 'agentMessage':
     case 'agent_message':
       return { text: item.text };
 
     case 'reasoning':
-      return { text: item.text };
+    case 'agentReasoning': {
+      // App-server sends summary: string[] and content: string[] (both may be empty)
+      const summary = Array.isArray(item.summary) ? (item.summary as string[]).join('\n') : '';
+      return { text: summary || item.text || '' };
+    }
 
+    case 'commandExecution':
     case 'command_execution':
       return {
         command: item.command,
@@ -17,12 +31,14 @@ export function mapItemData(item: ThreadItem): Record<string, unknown> {
         status: item.status,
       };
 
+    case 'fileChange':
     case 'file_change':
       return {
         changes: item.changes,
         status: item.status,
       };
 
+    case 'mcpToolCall':
     case 'mcp_tool_call':
       return {
         server: item.server,
@@ -33,9 +49,11 @@ export function mapItemData(item: ThreadItem): Record<string, unknown> {
         status: item.status,
       };
 
+    case 'webSearch':
     case 'web_search':
       return { query: item.query };
 
+    case 'todoList':
     case 'todo_list':
       return { items: item.items };
 
@@ -47,10 +65,19 @@ export function mapItemData(item: ThreadItem): Record<string, unknown> {
   }
 }
 
-/** 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;
+/**
+ * Determine the DB item status from a completed app-server item.
+ *
+ * @param item — The app-server item that has completed.
+ * @returns `'in_progress' | 'completed' | 'failed'`.
+ */
+export function getItemStatus(item: AppServerItem): 'in_progress' | 'completed' | 'failed' {
+  if (
+    item.type === 'commandExecution' || item.type === 'command_execution' ||
+    item.type === 'fileChange' || item.type === 'file_change' ||
+    item.type === 'mcpToolCall' || item.type === 'mcp_tool_call'
+  ) {
+    return item.status ?? 'completed';
   }
   if (item.type === 'error') {
     return 'failed';

package/agent-pane/backend/src/codex/shared-app-server.ts

@@ -0,0 +1,25 @@
+/** Singleton manager for the shared metadata app-server process. */
+
+import { AppServerClient } from './app-server-client.ts';
+
+let shared: AppServerClient | null = null;
+
+/** Get or create the shared app-server client for metadata queries. */
+export function getSharedAppServer(): AppServerClient {
+  if (!shared || shared.isClosed()) {
+    shared = new AppServerClient({ cwd: process.cwd() });
+    // Fire-and-forget initialize — the first request will wait for it
+    shared.initialize().catch((err) => {
+      console.error('[shared-app-server] Initialize failed:', err);
+    });
+  }
+  return shared;
+}
+
+/** Close the shared app-server client. Called during graceful shutdown. */
+export async function closeSharedAppServer(): Promise<void> {
+  if (shared) {
+    await shared.close();
+    shared = null;
+  }
+}

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

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { initDb, getDb } from './index.ts';
+import type Database from 'better-sqlite3';
+
+describe('getDb', () => {
+  it('throws if initDb has not been called', async () => {
+    vi.resetModules();
+    const { getDb: freshGetDb } = await import('./index.ts');
+    expect(() => freshGetDb()).toThrow('Database not initialized');
+  });
+
+  it('returns the database instance after initDb', () => {
+    const db = initDb(':memory:');
+    expect(getDb()).toBe(db);
+  });
+});
+
+describe('initDb', () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = initDb(':memory:');
+  });
+
+  it('creates sessions table', () => {
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sessions'").all() as {
+      name: string;
+    }[];
+    expect(tables).toHaveLength(1);
+  });
+
+  it('creates turns table', () => {
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='turns'").all() as {
+      name: string;
+    }[];
+    expect(tables).toHaveLength(1);
+  });
+
+  it('creates items table', () => {
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='items'").all() as {
+      name: string;
+    }[];
+    expect(tables).toHaveLength(1);
+  });
+
+  it('creates workspaces table', () => {
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workspaces'").all() as {
+      name: string;
+    }[];
+    expect(tables).toHaveLength(1);
+  });
+
+  it('creates idx_turns_session_id index', () => {
+    const indexes = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_turns_session_id'")
+      .all() as { name: string }[];
+    expect(indexes).toHaveLength(1);
+  });
+
+  it('creates idx_items_turn_id index', () => {
+    const indexes = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_items_turn_id'")
+      .all() as { name: string }[];
+    expect(indexes).toHaveLength(1);
+  });
+
+  it('creates idx_workspaces_path index', () => {
+    const indexes = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_workspaces_path'")
+      .all() as { name: string }[];
+    expect(indexes).toHaveLength(1);
+  });
+
+  it('adds lifecycle column to sessions', () => {
+    const cols = db.prepare('PRAGMA table_info(sessions)').all() as { name: string }[];
+    expect(cols.some((c) => c.name === 'lifecycle')).toBe(true);
+  });
+
+  it('adds has_unreviewed column to sessions', () => {
+    const cols = db.prepare('PRAGMA table_info(sessions)').all() as { name: string }[];
+    expect(cols.some((c) => c.name === 'has_unreviewed')).toBe(true);
+  });
+
+  it('adds model_reasoning_effort column to sessions', () => {
+    const cols = db.prepare('PRAGMA table_info(sessions)').all() as { name: string }[];
+    expect(cols.some((c) => c.name === 'model_reasoning_effort')).toBe(true);
+  });
+
+  it('adds deleted column to workspaces', () => {
+    const cols = db.prepare('PRAGMA table_info(workspaces)').all() as { name: string }[];
+    expect(cols.some((c) => c.name === 'deleted')).toBe(true);
+  });
+
+  it('enables foreign keys', () => {
+    const result = db.pragma('foreign_keys', { simple: true }) as number;
+    expect(result).toBe(1);
+  });
+
+  it('enforces foreign key cascade on turn deletion', () => {
+    db.prepare(
+      'INSERT INTO sessions (id, title, runtime_type, status, is_running, lifecycle, has_unreviewed, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
+    ).run('s1', null, 'codex', 'active', 0, 'working', 0, '2025-01-01T00:00:00Z', '2025-01-01T00:00:00Z');
+
+    db.prepare(
+      'INSERT INTO turns (id, session_id, user_prompt, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)',
+    ).run('t1', 's1', 'hello', 'pending', '2025-01-01T00:00:00Z', '2025-01-01T00:00:00Z');
+
+    db.prepare('INSERT INTO items (id, turn_id, type, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)').run(
+      'i1',
+      't1',
+      'agent_message',
+      'completed',
+      '2025-01-01T00:00:00Z',
+      '2025-01-01T00:00:00Z',
+    );
+
+    // Delete session → cascades to turns → cascades to items
+    db.prepare('DELETE FROM sessions WHERE id = ?').run('s1');
+
+    const turns = db.prepare('SELECT COUNT(*) as count FROM turns').get() as { count: number };
+    const items = db.prepare('SELECT COUNT(*) as count FROM items').get() as { count: number };
+    expect(turns.count).toBe(0);
+    expect(items.count).toBe(0);
+  });
+});

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

@@ -1,9 +1,17 @@
 import Database from 'better-sqlite3';
-import type { Database as DB } from 'better-sqlite3';
 
-let db: DB;
+let db: Database.Database;
 
-export function initDb(path: string = 'data.db'): DB {
+/**
+ * Initialise the SQLite database at the given path.
+ *
+ * Enables WAL journal mode and foreign keys, then creates tables and runs
+ * any pending column migrations.
+ *
+ * @param path — Filesystem path to the SQLite database file. Use `':memory:'` for tests.
+ * @returns The initialised `Database` instance.
+ */
+export function initDb(path: string = 'data.db'): Database.Database {
   db = new Database(path);
   db.pragma('journal_mode = WAL');
   db.pragma('foreign_keys = ON');
@@ -12,14 +20,29 @@ export function initDb(path: string = 'data.db'): DB {
   return db;
 }
 
-export function getDb(): DB {
+/**
+ * Get the initialised database instance.
+ *
+ * @throws Error if `initDb()` has not been called yet.
+ * @returns The singleton `Database` instance.
+ */
+export function getDb(): Database.Database {
   if (!db) {
     throw new Error('Database not initialized. Call initDb() first.');
   }
   return db;
 }
 
-function createTables(database: DB): void {
+/**
+ * Create all tables and run inline migrations for new columns.
+ *
+ * Tables: `sessions`, `turns`, `items`, `workspaces`.
+ * Migrations: `deleted` (workspaces), `lifecycle` + `has_unreviewed` +
+ * `model_reasoning_effort` (sessions) — each guarded by PRAGMA table_info check.
+ *
+ * @param database — The DB instance to create tables in.
+ */
+function createTables(database: Database.Database): void {
   database.exec(`
     CREATE TABLE IF NOT EXISTS sessions (
       id                  TEXT PRIMARY KEY,
@@ -75,17 +98,25 @@ function createTables(database: DB): void {
   `);
 
   // Migration: add 'deleted' column to existing workspaces table if missing
-  const wsColumns = database.prepare("PRAGMA table_info(workspaces)").all() as { name: string }[];
+  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 }[];
+  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');
   }
-}
+  if (!sessColumns.some((c) => c.name === 'model_reasoning_effort')) {
+    database.exec('ALTER TABLE sessions ADD COLUMN model_reasoning_effort TEXT');
+  }
+
+  // Migration: add 'runtime_config' column to existing sessions table
+  if (!sessColumns.some((c) => c.name === 'runtime_config')) {
+    database.exec('ALTER TABLE sessions ADD COLUMN runtime_config TEXT');
+  }
+}

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

@@ -1,76 +1,30 @@
-// Database schema — TypeScript interfaces (no ORM, raw SQL).
+// Database schema — TypeScript interfaces.
+// Core types are imported from @agentpane/shared and re-exported.
+// This file adds DB-specific aliases (TurnBase = Turn without items).
 
-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';
+import type {
+  SessionStatus,
+  TurnStatus,
+  ItemType,
+  ItemStatus,
+  Session,
+  Turn,
+  TokenUsage,
+  Item,
+  Workspace,
+  SessionDetail,
+} from '@agentpane/shared';
 
-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[] })[];
-}
+// Re-export shared types for backward compatibility with existing imports.
+export type {
+  SessionStatus,
+  TurnStatus,
+  ItemType,
+  ItemStatus,
+  Session,
+  Turn,
+  TokenUsage,
+  Item,
+  Workspace,
+  SessionDetail,
+};