repoburg 1.3.188 → 1.3.196

package/agent-pane/backend/src/integration/missing-item-started.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Integration test: missing item.started auto-insert fallback.
+ *
+ * Verifies that when item.updated or item.completed arrives without
+ * a prior item.started, the handleEvent auto-inserts the item into DB.
+ *
+ * Uses HTTP POST to trigger the turn (fire-and-forget startTurn).
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type Database from 'better-sqlite3';
+import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
+import { clearBroadcasts, capturedBroadcasts } from './helpers/ws-capture.ts';
+import type { TestApp } from './helpers/test-app.ts';
+
+const fixture = JSON.parse(
+  readFileSync(resolve(__dirname, '__fixtures__/missing-item-started.json'), 'utf-8'),
+) as Fixture;
+
+vi.mock('../codex/app-server-client.ts', () => ({
+  AppServerClient: createAppServerMock(fixture),
+}));
+
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      capturedBroadcasts.push({ event, data });
+    }),
+  };
+});
+
+const { getDb } = await import('../db/index.ts');
+const { createTestApp, waitForTurn } = await import('./helpers/test-app.ts');
+
+describe('Integration: missing item.started auto-insert', () => {
+  let testApp: TestApp;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    clearBroadcasts();
+    testApp = await createTestApp();
+  });
+
+  afterEach(async () => {
+    await testApp.cleanup();
+  });
+
+  it('auto-inserts item when item.updated arrives without item.started', async () => {
+    const db: Database.Database = getDb();
+
+    // Create session
+    const createRes = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions',
+      payload: {},
+    });
+    const session = createRes.json();
+
+    // Submit turn via HTTP
+    const turnRes = await testApp.app.inject({
+      method: 'POST',
+      url: `/api/sessions/${session.id}/turns`,
+      payload: { user_prompt: 'Hello' },
+    });
+    const turn = turnRes.json();
+
+    await waitForTurn(db, turn.id);
+
+    // Only 1 item in DB (no duplicate from missing item.started)
+    const items = db.prepare('SELECT * FROM items WHERE turn_id = ? ORDER BY created_at ASC').all(turn.id) as {
+      type: string;
+      data: string;
+      status: string;
+    }[];
+    expect(items).toHaveLength(1);
+    expect(items[0].type).toBe('agent_message');
+    expect(items[0].status).toBe('completed');
+    expect(JSON.parse(items[0].data)).toEqual({ text: 'Hello! How can I help?' });
+
+    // Verify WS: item:updated broadcast fired (auto-insert path)
+    const updatedBroadcasts = capturedBroadcasts.filter((b) => b.event === 'item:updated');
+    expect(updatedBroadcasts).toHaveLength(1);
+
+    const completedBroadcasts = capturedBroadcasts.filter((b) => b.event === 'item:completed');
+    expect(completedBroadcasts).toHaveLength(1);
+  });
+});

package/agent-pane/backend/src/integration/multi-turn.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Integration test: multi-turn session — thread reuse and title only once.
+ *
+ * Verifies that a second turn in the same session reuses the existing
+ * thread (external_thread_id set after first turn) and that the title
+ * is only generated once (for the first turn).
+ *
+ * Uses HTTP POST to trigger each turn (fire-and-forget startTurn).
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type Database from 'better-sqlite3';
+import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
+import { clearBroadcasts, capturedBroadcasts } from './helpers/ws-capture.ts';
+import type { TestApp } from './helpers/test-app.ts';
+
+const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/multi-turn.json'), 'utf-8')) as Fixture;
+
+vi.mock('../codex/app-server-client.ts', () => ({
+  AppServerClient: createAppServerMock(fixture),
+}));
+
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      capturedBroadcasts.push({ event, data });
+    }),
+  };
+});
+
+const { getDb } = await import('../db/index.ts');
+const { createTestApp, waitForTurn } = await import('./helpers/test-app.ts');
+
+describe('Integration: multi-turn', () => {
+  let testApp: TestApp;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    clearBroadcasts();
+    testApp = await createTestApp();
+  });
+
+  afterEach(async () => {
+    await testApp.cleanup();
+  });
+
+  it('handles two turns with thread reuse and title only once', async () => {
+    const db: Database.Database = getDb();
+
+    // Create session
+    const createRes = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions',
+      payload: {},
+    });
+    const session = createRes.json();
+
+    // Turn 1 via HTTP
+    const turn1Res = await testApp.app.inject({
+      method: 'POST',
+      url: `/api/sessions/${session.id}/turns`,
+      payload: { user_prompt: 'What is 2+2?' },
+    });
+    const turn1 = turn1Res.json();
+    await waitForTurn(db, turn1.id);
+
+    // After turn 1: external_thread_id should be set
+    const sessionAfterT1 = db
+      .prepare('SELECT external_thread_id, title FROM sessions WHERE id = ?')
+      .get(session.id) as { external_thread_id: string | null; title: string | null };
+    expect(sessionAfterT1.external_thread_id).toBe('thread_fix_005');
+
+    // Wait for title generation (fire-and-forget)
+    await new Promise((r) => setTimeout(r, 500));
+    const sessionTitled = db.prepare('SELECT title FROM sessions WHERE id = ?').get(session.id) as {
+      title: string | null;
+    };
+    expect(sessionTitled.title).toBe('Simple Math Questions');
+
+    // Turn 2 via HTTP
+    const turn2Res = await testApp.app.inject({
+      method: 'POST',
+      url: `/api/sessions/${session.id}/turns`,
+      payload: { user_prompt: 'What about 3+3?' },
+    });
+    const turn2 = turn2Res.json();
+    await waitForTurn(db, turn2.id);
+
+    // Both turns in DB
+    const turns = db.prepare('SELECT * FROM turns WHERE session_id = ? ORDER BY created_at ASC').all(session.id) as {
+      user_prompt: string;
+      agent_response: string | null;
+      status: string;
+    }[];
+    expect(turns).toHaveLength(2);
+    expect(turns[0].user_prompt).toBe('What is 2+2?');
+    expect(turns[0].agent_response).toBe('2+2 equals 4.');
+    expect(turns[0].status).toBe('completed');
+    expect(turns[1].user_prompt).toBe('What about 3+3?');
+    expect(turns[1].agent_response).toBe('3+3 equals 6.');
+    expect(turns[1].status).toBe('completed');
+
+    // Title should still be from first turn (not regenerated)
+    const finalTitle = db.prepare('SELECT title FROM sessions WHERE id = ?').get(session.id) as {
+      title: string | null;
+    };
+    expect(finalTitle.title).toBe('Simple Math Questions');
+
+    // Only one session:title broadcast (from first turn's title generation)
+    const titleBroadcasts = capturedBroadcasts.filter((b) => b.event === 'session:title');
+    expect(titleBroadcasts).toHaveLength(1);
+
+    // Two turn:completed broadcasts
+    const completedBroadcasts = capturedBroadcasts.filter((b) => b.event === 'turn:completed');
+    expect(completedBroadcasts).toHaveLength(2);
+  });
+});

package/agent-pane/backend/src/integration/session-operations.test.ts

@@ -0,0 +1,168 @@
+/**
+ * Integration test: session operations — rewind, branch, model change.
+ *
+ * These operations interact with codex-provider's clearThread() function.
+ * Uses the real codex-provider.ts (not mocked) with a simple-turn fixture
+ * to populate DB state, then tests the operations via HTTP.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type Database from 'better-sqlite3';
+import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
+import { clearBroadcasts, capturedBroadcasts } from './helpers/ws-capture.ts';
+import type { TestApp } from './helpers/test-app.ts';
+
+const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/simple-turn.json'), 'utf-8')) as Fixture;
+
+vi.mock('../codex/app-server-client.ts', () => ({
+  AppServerClient: createAppServerMock(fixture),
+}));
+
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      capturedBroadcasts.push({ event, data });
+    }),
+  };
+});
+
+const { getDb } = await import('../db/index.ts');
+const { createTestApp, insertTestSession } = await import('./helpers/test-app.ts');
+
+describe('Integration: session operations', () => {
+  let testApp: TestApp;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    clearBroadcasts();
+    testApp = await createTestApp();
+  });
+
+  afterEach(async () => {
+    await testApp.cleanup();
+  });
+
+  it('rewind deletes turns after target and nulls external_thread_id', async () => {
+    const db: Database.Database = getDb();
+
+    insertTestSession(db, 's1', { external_thread_id: 'thread_old' });
+
+    // Insert two turns manually
+    const now1 = '2025-01-01T00:00:00Z';
+    const now2 = '2025-01-01T01:00:00Z';
+    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, 'completed', NULL, ?, ?)`,
+    ).run('t1', 's1', 'first', now1, now1);
+    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, 'completed', NULL, ?, ?)`,
+    ).run('t2', 's1', 'second', now2, now2);
+
+    // Rewind to t1 — deletes t2 and after
+    const res = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions/s1/rewind',
+      payload: { turn_id: 't1' },
+    });
+    expect(res.statusCode).toBe(200);
+
+    // Only t1 remains
+    const turns = db.prepare('SELECT id FROM turns WHERE session_id = ?').all('s1') as {
+      id: string;
+    }[];
+    expect(turns).toHaveLength(1);
+    expect(turns[0].id).toBe('t1');
+
+    // external_thread_id nulled
+    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('branch creates new session with copied turns and items', async () => {
+    const db: Database.Database = getDb();
+
+    insertTestSession(db, 's1', { title: 'Original', model: 'gpt-4' });
+
+    const now = '2025-01-01T00:00:00Z';
+    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 (?, ?, ?, 'answer', NULL, NULL, NULL, 'completed', NULL, ?, ?)`,
+    ).run('t1', 's1', 'hello', now, now);
+    db.prepare(
+      `INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+       VALUES (?, ?, ?, 'agent_message', ?, 'completed', ?, ?)`,
+    ).run('i1', 't1', 'ext1', JSON.stringify({ text: 'answer' }), now, now);
+
+    const res = await testApp.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();
+
+    // New session has copied turn + item
+    const newTurns = db.prepare('SELECT * FROM turns WHERE session_id = ?').all(newSession.id) as {
+      user_prompt: string;
+      agent_response: string;
+    }[];
+    expect(newTurns).toHaveLength(1);
+    expect(newTurns[0].user_prompt).toBe('hello');
+    expect(newTurns[0].agent_response).toBe('answer');
+
+    const newItems = db
+      .prepare('SELECT * FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?)')
+      .all(newSession.id) as { type: string }[];
+    expect(newItems).toHaveLength(1);
+    expect(newItems[0].type).toBe('agent_message');
+  });
+
+  it('model change clears thread when external_thread_id exists', async () => {
+    const db: Database.Database = getDb();
+
+    insertTestSession(db, 's1', { model: 'gpt-4', external_thread_id: 'thread_123' });
+
+    const res = await testApp.app.inject({
+      method: 'PATCH',
+      url: '/api/sessions/s1',
+      payload: { model: 'o3' },
+    });
+    expect(res.statusCode).toBe(200);
+
+    const session = db.prepare('SELECT external_thread_id, model FROM sessions WHERE id = ?').get('s1') as {
+      external_thread_id: string | null;
+      model: string | null;
+    };
+    expect(session.external_thread_id).toBeNull();
+    expect(session.model).toBe('o3');
+  });
+
+  it('model change does NOT clear thread when external_thread_id is null', async () => {
+    const db: Database.Database = getDb();
+
+    insertTestSession(db, 's1', { model: 'gpt-4' });
+
+    const res = await testApp.app.inject({
+      method: 'PATCH',
+      url: '/api/sessions/s1',
+      payload: { model: 'o3' },
+    });
+    expect(res.statusCode).toBe(200);
+
+    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();
+  });
+});

package/agent-pane/backend/src/integration/title-generation.test.ts

@@ -0,0 +1,109 @@
+/**
+ * Integration test: title auto-generation.
+ *
+ * Verifies that after a turn completes, a throwaway Codex thread is
+ * used to generate a title, which is saved to the DB and broadcast
+ * via session:title.
+ *
+ * Uses HTTP POST to trigger the turn (fire-and-forget startTurn).
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type Database from 'better-sqlite3';
+import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
+import { clearBroadcasts, findBroadcast, capturedBroadcasts } from './helpers/ws-capture.ts';
+import type { TestApp } from './helpers/test-app.ts';
+
+const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/simple-turn.json'), 'utf-8')) as Fixture;
+
+vi.mock('../codex/app-server-client.ts', () => ({
+  AppServerClient: createAppServerMock(fixture),
+}));
+
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      capturedBroadcasts.push({ event, data });
+    }),
+  };
+});
+
+const { getDb } = await import('../db/index.ts');
+const { createTestApp, waitForTurn, insertTestSession } = await import('./helpers/test-app.ts');
+
+describe('Integration: title generation', () => {
+  let testApp: TestApp;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    clearBroadcasts();
+    testApp = await createTestApp();
+  });
+
+  afterEach(async () => {
+    await testApp.cleanup();
+  });
+
+  it('generates title after first turn via throwaway thread', async () => {
+    const db: Database.Database = getDb();
+
+    insertTestSession(db, 's1');
+
+    // Submit turn via HTTP
+    const turnRes = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions/s1/turns',
+      payload: { user_prompt: 'Hello, how are you?' },
+    });
+    const turn = turnRes.json();
+
+    await waitForTurn(db, turn.id);
+
+    // Wait for fire-and-forget title generation
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Title in DB
+    const dbSession = db.prepare('SELECT title FROM sessions WHERE id = ?').get('s1') as {
+      title: string | null;
+    };
+    expect(dbSession.title).toBe('Simple Hello Chat');
+
+    // session:title broadcast
+    const titleData = findBroadcast('session:title') as { sessionId: string; title: string };
+    expect(titleData.sessionId).toBe('s1');
+    expect(titleData.title).toBe('Simple Hello Chat');
+  });
+
+  it('does not regenerate title when session already has one', async () => {
+    const db: Database.Database = getDb();
+
+    insertTestSession(db, 's1', { title: 'Existing Title' });
+
+    // Submit turn via HTTP
+    const turnRes = await testApp.app.inject({
+      method: 'POST',
+      url: '/api/sessions/s1/turns',
+      payload: { user_prompt: 'Hello, how are you?' },
+    });
+    const turn = turnRes.json();
+
+    await waitForTurn(db, turn.id);
+
+    // Wait for any potential title generation
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Title should NOT have changed
+    const dbSession = db.prepare('SELECT title FROM sessions WHERE id = ?').get('s1') as {
+      title: string | null;
+    };
+    expect(dbSession.title).toBe('Existing Title');
+
+    // No session:title broadcast
+    const titleBroadcasts = capturedBroadcasts.filter((b) => b.event === 'session:title');
+    expect(titleBroadcasts).toHaveLength(0);
+  });
+});

package/agent-pane/backend/src/integration/turn-cancel.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Integration test: turn cancellation.
+ *
+ * Verifies that aborting a running turn sets the correct DB state
+ * and broadcasts turn:cancelled.
+ *
+ * Uses manual turn insertion + direct startTurn call to control cancel timing.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type Database from 'better-sqlite3';
+import { createAppServerMock, type Fixture } from './helpers/app-server-mock.ts';
+import { clearBroadcasts, findBroadcast, capturedBroadcasts } from './helpers/ws-capture.ts';
+import type { TestApp } from './helpers/test-app.ts';
+
+const fixture = JSON.parse(readFileSync(resolve(__dirname, '__fixtures__/cancel-turn.json'), 'utf-8')) as Fixture;
+
+vi.mock('../codex/app-server-client.ts', () => ({
+  AppServerClient: createAppServerMock(fixture),
+}));
+
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      capturedBroadcasts.push({ event, data });
+    }),
+  };
+});
+
+const { startTurn, interruptTurn } = await import('../codex/codex-provider.ts');
+const { getDb } = await import('../db/index.ts');
+const { createTestApp, waitForTurn, insertTestSession } = await import('./helpers/test-app.ts');
+
+describe('Integration: turn cancellation', () => {
+  let testApp: TestApp;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    clearBroadcasts();
+    testApp = await createTestApp();
+  });
+
+  afterEach(async () => {
+    await testApp.cleanup();
+  });
+
+  it('aborts a running turn and sets correct DB + WS state', async () => {
+    const db: Database.Database = getDb();
+
+    // Create session via HTTP
+    insertTestSession(db, 's1');
+
+    // Insert turn manually (not via HTTP — avoids fire-and-forget startTurn)
+    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('t1', 's1', 'Write a long essay about history', now, now);
+
+    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as Record<string, unknown>;
+    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('t1') as Record<string, unknown>;
+
+    // Start turn directly — do NOT await (need to cancel while running)
+    const turnPromise = startTurn(session as never, turn as never);
+
+    // Give it a moment to start streaming and set up abortController
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Check that abortController is registered
+    const isRunning = db.prepare('SELECT is_running FROM sessions WHERE id = ?').get('s1') as { is_running: number };
+    expect(isRunning.is_running).toBe(1);
+
+    // Cancel the turn
+    const cancelled = await interruptTurn('s1');
+    expect(cancelled).toBe(true);
+
+    // Wait for the turn promise to resolve
+    await turnPromise;
+    await waitForTurn(db, 't1');
+
+    // Assert DB state
+    const dbTurn = db.prepare('SELECT status FROM turns WHERE id = ?').get('t1') as {
+      status: string;
+    };
+    expect(dbTurn.status).toBe('aborted');
+
+    const dbSession = db.prepare('SELECT is_running, status FROM sessions WHERE id = ?').get('s1') as {
+      is_running: number;
+      status: string;
+    };
+    expect(dbSession.is_running).toBe(0);
+    expect(dbSession.status).toBe('active');
+
+    // Assert WS broadcast
+    const cancelledData = findBroadcast('turn:cancelled') as {
+      sessionId: string;
+      turnId: string;
+    };
+    expect(cancelledData.sessionId).toBe('s1');
+    expect(cancelledData.turnId).toBe('t1');
+  });
+
+  it('returns false when interrupting a non-running session', async () => {
+    const result = await interruptTurn('nonexistent-session');
+    expect(result).toBe(false);
+  });
+});