repoburg 1.3.188 → 1.3.196

package/agent-pane/frontend/package.json

@@ -7,7 +7,9 @@
     "dev": "vite",
     "build": "tsc --noEmit && vite build",
     "preview": "vite preview",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "dompurify": "^3.2.0",
@@ -18,11 +20,16 @@
     "zustand": "^5.0.0"
   },
   "devDependencies": {
+    "@testing-library/jest-dom": "^6.4.0",
+    "@testing-library/react": "^16.1.0",
     "@types/dompurify": "^3.0.5",
     "@types/react": "^18.3.0",
     "@types/react-dom": "^18.3.0",
     "@vitejs/plugin-react": "^4.3.0",
+    "@vitest/coverage-v8": "^3.2.7",
+    "jsdom": "^25.0.0",
     "typescript": "^5.7.0",
-    "vite": "^6.0.0"
+    "vite": "^6.0.0",
+    "vitest": "^3.2.4"
   }
-}
+}

package/agent-pane/frontend/src/App.test.tsx

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { render, screen, fireEvent, cleanup } from '@testing-library/react';
+import App from './App.tsx';
+import { resetStore } from './test/component-helpers.ts';
+
+// Mock child components that have side effects (WebSocket, init)
+vi.mock('./api/websocket.ts', () => ({
+  connectWebSocket: vi.fn(),
+  disconnectWebSocket: vi.fn(),
+}));
+
+// Mock API modules to prevent real network calls
+vi.mock('./api/sessions.ts', () => ({
+  fetchSessions: vi.fn(),
+  fetchSessionDetail: vi.fn(),
+  createSession: vi.fn(),
+  deleteSession: vi.fn(),
+  submitPrompt: vi.fn(),
+  cancelTurn: vi.fn(),
+  renameSession: vi.fn(),
+  markFinished: vi.fn(),
+  reopenSession: vi.fn(),
+  clearUnreviewed: vi.fn(),
+  rewindSession: vi.fn(),
+  branchSession: vi.fn(),
+  updateModelConfig: vi.fn(),
+}));
+
+vi.mock('./api/workspaces.ts', () => ({
+  fetchWorkspaces: vi.fn(),
+  createWorkspace: vi.fn(),
+  hideWorkspace: vi.fn(),
+  deleteWorkspace: vi.fn(),
+  pickDirectory: vi.fn(),
+}));
+
+describe('App', () => {
+  beforeEach(() => {
+    // Mock init as no-op to prevent real store init from running
+    resetStore({ init: vi.fn().mockResolvedValue(undefined) });
+  });
+  afterEach(() => {
+    cleanup();
+  });
+
+  it('shows "Loading sessions…" when loading and no sessions', () => {
+    resetStore({ loading: true, sessions: [] });
+    render(<App />);
+    expect(screen.getByText('Loading sessions…')).toBeInTheDocument();
+  });
+
+  it('shows error message when error and no sessions', () => {
+    const init = vi.fn().mockResolvedValue(undefined); // no-op init
+    resetStore({ loading: false, error: 'Connection refused', sessions: [], init });
+    render(<App />);
+    expect(screen.getByText('Error: Connection refused')).toBeInTheDocument();
+  });
+
+  it('renders IdeWorkspace when sessions loaded', () => {
+    const session = { id: 's1', title: 'Test', runtime_type: 'codex', model: null, model_reasoning_effort: null, cwd: null, external_thread_id: null, status: 'active' as const, is_running: 0, lifecycle: 'working', has_unreviewed: 0, created_at: '2025-01-01T00:00:00Z', updated_at: '2025-01-01T00:00:00Z' };
+    resetStore({ loading: false, sessions: [session], openTabs: ['s1'], activeSessionId: 's1' });
+    render(<App />);
+    // IdeWorkspace renders the workspace sidebar
+    expect(document.querySelector('.ide-root')).toBeInTheDocument();
+  });
+
+  it('Cmd+K opens command palette', () => {
+    const setShowCommandPalette = vi.fn();
+    resetStore({ loading: false, sessions: [], setShowCommandPalette });
+    render(<App />);
+    fireEvent.keyDown(window, { key: 'k', metaKey: true });
+    expect(setShowCommandPalette).toHaveBeenCalledWith(true);
+  });
+});

package/agent-pane/frontend/src/App.tsx

@@ -41,4 +41,4 @@ export default function App() {
       )}
     </>
   );
-}
+}

package/agent-pane/frontend/src/AppInitializer.test.tsx

@@ -0,0 +1,142 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { render, cleanup } from '@testing-library/react';
+import AppInitializer from './AppInitializer.tsx';
+import { useStore } from './store/store.ts';
+import { resetStore } from './test/component-helpers.ts';
+
+// Mock WebSocket module
+vi.mock('./api/websocket.ts', () => ({
+  connectWebSocket: vi.fn(),
+  disconnectWebSocket: vi.fn(),
+}));
+
+// Mock API modules
+vi.mock('./api/sessions.ts', () => ({
+  fetchSessions: vi.fn(),
+  fetchSessionDetail: vi.fn(),
+  createSession: vi.fn(),
+  deleteSession: vi.fn(),
+  submitPrompt: vi.fn(),
+  cancelTurn: vi.fn(),
+  renameSession: vi.fn(),
+  markFinished: vi.fn(),
+  reopenSession: vi.fn(),
+  clearUnreviewed: vi.fn(),
+  rewindSession: vi.fn(),
+  branchSession: vi.fn(),
+  updateModelConfig: vi.fn(),
+}));
+
+vi.mock('./api/workspaces.ts', () => ({
+  fetchWorkspaces: vi.fn(),
+  createWorkspace: vi.fn(),
+  hideWorkspace: vi.fn(),
+  deleteWorkspace: vi.fn(),
+  pickDirectory: vi.fn(),
+}));
+
+/** Helper: set document.visibilityState then dispatch visibilitychange */
+function dispatchVisibility(state: string) {
+  Object.defineProperty(document, 'visibilityState', {
+    value: state,
+    configurable: true,
+  });
+  document.dispatchEvent(new Event('visibilitychange'));
+}
+
+describe('AppInitializer', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetStore();
+    // Restore default visibility
+    Object.defineProperty(document, 'visibilityState', {
+      value: 'visible',
+      configurable: true,
+    });
+  });
+  afterEach(() => {
+    cleanup();
+  });
+
+  it('calls init on mount', () => {
+    const init = vi.fn().mockResolvedValue(undefined);
+    useStore.setState({ init });
+    render(<AppInitializer />);
+    expect(init).toHaveBeenCalled();
+  });
+
+  it('calls connectWebSocket on mount', async () => {
+    const { connectWebSocket } = await import('./api/websocket.ts');
+    render(<AppInitializer />);
+    expect(connectWebSocket).toHaveBeenCalled();
+  });
+
+  it('cleanup calls disconnectWebSocket', async () => {
+    const { disconnectWebSocket } = await import('./api/websocket.ts');
+    const init = vi.fn().mockResolvedValue(undefined);
+    useStore.setState({ init });
+    const { unmount } = render(<AppInitializer />);
+    unmount();
+    expect(disconnectWebSocket).toHaveBeenCalled();
+  });
+
+  it('visibilitychange hidden: does not reconnect or refresh', async () => {
+    const { connectWebSocket } = await import('./api/websocket.ts');
+    const refreshActiveSession = vi.fn();
+    const addLogEntry = vi.fn();
+    useStore.setState({ refreshActiveSession, addLogEntry });
+    render(<AppInitializer />);
+    vi.clearAllMocks();
+    dispatchVisibility('hidden');
+    expect(connectWebSocket).not.toHaveBeenCalled();
+    expect(refreshActiveSession).not.toHaveBeenCalled();
+  });
+
+  it('visibilitychange visible with no active session: no reconnect, no refresh', async () => {
+    const { connectWebSocket } = await import('./api/websocket.ts');
+    const refreshActiveSession = vi.fn();
+    useStore.setState({ activeSessionId: null, refreshActiveSession });
+    render(<AppInitializer />);
+    vi.clearAllMocks();
+    dispatchVisibility('visible');
+    expect(connectWebSocket).not.toHaveBeenCalled();
+    expect(refreshActiveSession).not.toHaveBeenCalled();
+  });
+
+  it('visibilitychange visible with WS down: reconnects, no refresh', async () => {
+    const { connectWebSocket } = await import('./api/websocket.ts');
+    const refreshActiveSession = vi.fn();
+    useStore.setState({
+      activeSessionId: 's1',
+      wsConnected: false,
+      sessionDetails: {},
+      refreshActiveSession,
+    });
+    render(<AppInitializer />);
+    vi.clearAllMocks();
+    dispatchVisibility('visible');
+    expect(connectWebSocket).toHaveBeenCalledTimes(1);
+    expect(refreshActiveSession).not.toHaveBeenCalled();
+  });
+
+  it('visibilitychange visible with running session: refreshes and logs', async () => {
+    const { connectWebSocket } = await import('./api/websocket.ts');
+    const refreshActiveSession = vi.fn();
+    const addLogEntry = vi.fn();
+    useStore.setState({
+      activeSessionId: 's1',
+      wsConnected: true,
+      sessionDetails: {
+        s1: { id: 's1', is_running: 1 } as never,
+      },
+      refreshActiveSession,
+      addLogEntry,
+    });
+    render(<AppInitializer />);
+    vi.clearAllMocks();
+    dispatchVisibility('visible');
+    expect(refreshActiveSession).toHaveBeenCalledTimes(1);
+    expect(addLogEntry).toHaveBeenCalledWith('INFO', 'Tab returned — reconciling session state');
+    expect(connectWebSocket).not.toHaveBeenCalled();
+  });
+});

package/agent-pane/frontend/src/AppInitializer.tsx

@@ -43,4 +43,4 @@ export default function AppInitializer() {
   }, [init]);
 
   return null;
-}
+}

package/agent-pane/frontend/src/api/client.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { apiGet, apiPost, apiDelete, apiPatch } from './client.ts';
+
+describe('apiGet', () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  it('sends GET request and returns parsed JSON', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ id: '123' }),
+    });
+
+    const result = await apiGet('/sessions');
+    expect(result).toEqual({ id: '123' });
+    expect(global.fetch).toHaveBeenCalledWith('/api/sessions', {
+      method: 'GET',
+      headers: undefined,
+      body: undefined,
+    });
+  });
+});
+
+describe('apiPost', () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  it('sends POST with JSON body and Content-Type header', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ success: true }),
+    });
+
+    const result = await apiPost('/sessions', { title: 'Test' });
+    expect(result).toEqual({ success: true });
+    expect(global.fetch).toHaveBeenCalledWith('/api/sessions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'Test' }),
+    });
+  });
+
+  it('sends POST without body when body is undefined', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ ok: true }),
+    });
+
+    await apiPost('/sessions/1/cancel');
+    expect(global.fetch).toHaveBeenCalledWith('/api/sessions/1/cancel', {
+      method: 'POST',
+      headers: undefined,
+      body: undefined,
+    });
+  });
+});
+
+describe('apiPatch', () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  it('sends PATCH with JSON body', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ id: '1', title: 'Updated' }),
+    });
+
+    const result = await apiPatch('/sessions/1', { title: 'Updated' });
+    expect(result).toEqual({ id: '1', title: 'Updated' });
+    expect(global.fetch).toHaveBeenCalledWith('/api/sessions/1', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'Updated' }),
+    });
+  });
+});
+
+describe('apiDelete', () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  it('sends DELETE request', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ success: true }),
+    });
+
+    const result = await apiDelete('/sessions/1');
+    expect(result).toEqual({ success: true });
+    expect(global.fetch).toHaveBeenCalledWith('/api/sessions/1', {
+      method: 'DELETE',
+      headers: undefined,
+      body: undefined,
+    });
+  });
+});
+
+describe('error handling', () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  it('throws with method, path, and status on non-ok response', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: false,
+      status: 404,
+      statusText: 'Not Found',
+    });
+
+    await expect(apiGet('/sessions/missing')).rejects.toThrow('GET /sessions/missing failed: 404 Not Found');
+  });
+
+  it('throws for POST error', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+    });
+
+    await expect(apiPost('/sessions', {})).rejects.toThrow('POST /sessions failed: 500 Internal Server Error');
+  });
+});

package/agent-pane/frontend/src/api/client.ts

@@ -1,41 +1,34 @@
 const API_BASE = '/api';
 
-export async function apiGet<T>(path: string): Promise<T> {
-  const res = await fetch(`${API_BASE}${path}`);
-  if (!res.ok) {
-    throw new Error(`GET ${path} failed: ${res.status} ${res.statusText}`);
-  }
-  return res.json() as Promise<T>;
-}
-
-export async function apiPost<T>(path: string, body?: unknown): Promise<T> {
+/** Core fetch wrapper with error handling and JSON parsing. */
+async function apiFetch<T>(method: string, path: string, body?: unknown): Promise<T> {
   const res = await fetch(`${API_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : undefined,
     body: body ? JSON.stringify(body) : undefined,
   });
   if (!res.ok) {
-    throw new Error(`POST ${path} failed: ${res.status} ${res.statusText}`);
+    throw new Error(`${method} ${path} failed: ${res.status} ${res.statusText}`);
   }
   return res.json() as Promise<T>;
 }
 
-export async function apiDelete<T>(path: string): Promise<T> {
-  const res = await fetch(`${API_BASE}${path}`, { method: 'DELETE' });
-  if (!res.ok) {
-    throw new Error(`DELETE ${path} failed: ${res.status} ${res.statusText}`);
-  }
-  return res.json() as Promise<T>;
+/** GET request — returns parsed JSON. */
+export function apiGet<T>(path: string): Promise<T> {
+  return apiFetch<T>('GET', path);
 }
 
-export async function apiPatch<T>(path: string, body?: unknown): Promise<T> {
-  const res = await fetch(`${API_BASE}${path}`, {
-    method: 'PATCH',
-    headers: { 'Content-Type': 'application/json' },
-    body: body ? JSON.stringify(body) : undefined,
-  });
-  if (!res.ok) {
-    throw new Error(`PATCH ${path} failed: ${res.status} ${res.statusText}`);
-  }
-  return res.json() as Promise<T>;
-}
+/** POST request with optional JSON body — returns parsed JSON. */
+export function apiPost<T>(path: string, body?: unknown): Promise<T> {
+  return apiFetch<T>('POST', path, body);
+}
+
+/** DELETE request — returns parsed JSON. */
+export function apiDelete<T>(path: string): Promise<T> {
+  return apiFetch<T>('DELETE', path);
+}
+
+/** PATCH request with optional JSON body — returns parsed JSON. */
+export function apiPatch<T>(path: string, body?: unknown): Promise<T> {
+  return apiFetch<T>('PATCH', path, body);
+}

package/agent-pane/frontend/src/api/models.ts

@@ -0,0 +1,7 @@
+import { apiGet } from './client.ts';
+import type { ModelInfo } from '../types/index.ts';
+
+/** Fetch the model list for a provider. */
+export function fetchModels(providerId: string): Promise<ModelInfo[]> {
+  return apiGet<ModelInfo[]>(`/providers/${providerId}/models`);
+}

package/agent-pane/frontend/src/api/providers.ts

@@ -0,0 +1,12 @@
+import { apiGet } from './client.ts';
+import type { ProviderDefinition } from '../types/index.ts';
+
+/** Fetch all provider definitions with capability flags. */
+export function fetchProviders(): Promise<ProviderDefinition[]> {
+  return apiGet<ProviderDefinition[]>('/providers');
+}
+
+/** Fetch a single provider definition by ID. */
+export function fetchProvider(id: string): Promise<ProviderDefinition> {
+  return apiGet<ProviderDefinition>(`/providers/${id}`);
+}