repoburg 1.3.201 → 1.3.204

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

@@ -1,34 +0,0 @@
-const API_BASE = '/api';
-
-/** 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,
-    headers: body ? { 'Content-Type': 'application/json' } : undefined,
-    body: body ? JSON.stringify(body) : undefined,
-  });
-  if (!res.ok) {
-    throw new Error(`${method} ${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);
-}
-
-/** 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

@@ -1,7 +0,0 @@
-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

@@ -1,17 +0,0 @@
-import { apiGet } from './client.ts';
-import type { ProviderDefinition, ProviderSlashCommand } 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}`);
-}
-
-/** Fetch provider-native slash commands (e.g. Claude CLI /compact, /clear). */
-export function fetchProviderCommands(id: string): Promise<ProviderSlashCommand[]> {
-  return apiGet<ProviderSlashCommand[]>(`/providers/${id}/commands`);
-}

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

@@ -1,245 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-// Mock the client module to capture call signatures without network access
-vi.mock('./client.ts', () => ({
-  apiGet: vi.fn(),
-  apiPost: vi.fn(),
-  apiDelete: vi.fn(),
-  apiPatch: vi.fn(),
-}));
-
-import { apiGet, apiPost, apiDelete, apiPatch } from './client.ts';
-import {
-  fetchSessions,
-  fetchSessionDetail,
-  createSession,
-  deleteSession,
-  submitPrompt,
-  cancelTurn,
-  renameSession,
-  markFinished,
-  reopenSession,
-  clearUnreviewed,
-  updateModelConfig,
-  rewindSession,
-  branchSession,
-} from './sessions.ts';
-import type { Session, SessionDetail, Turn } from '../types/index.ts';
-
-const NOW = '2025-01-01T00:00:00Z';
-
-function makeSession(overrides: Partial<Session> = {}): Session {
-  return {
-    id: 's1',
-    title: 'Test',
-    runtime_type: 'codex',
-    model: null,
-    model_reasoning_effort: null,
-    cwd: null,
-    external_thread_id: null,
-    status: 'active',
-    is_running: 0,
-    lifecycle: 'working',
-    has_unreviewed: 0,
-    runtime_config: null,
-    rewound_at_turn_id: null,
-    pre_rewind_thread_id: null,
-    created_at: NOW,
-    updated_at: NOW,
-    ...overrides,
-  };
-}
-
-function makeTurn(overrides: Partial<Turn> = {}): Turn {
-  return {
-    id: 't1',
-    session_id: 's1',
-    user_prompt: 'test',
-    agent_response: null,
-    thoughts: null,
-    token_usage: null,
-    external_turn_id: null,
-    status: 'completed',
-    error: null,
-    thread_id: null,
-    attachments: null,
-    created_at: NOW,
-    updated_at: NOW,
-    items: [],
-    ...overrides,
-  };
-}
-
-describe('fetchSessions', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiGet with /sessions', async () => {
-    const sessions = [makeSession()];
-    vi.mocked(apiGet).mockResolvedValue(sessions);
-    const result = await fetchSessions();
-    expect(apiGet).toHaveBeenCalledWith('/sessions');
-    expect(result).toEqual(sessions);
-  });
-});
-
-describe('fetchSessionDetail', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiGet with /sessions/:id', async () => {
-    const detail: SessionDetail = { ...makeSession(), turns: [] };
-    vi.mocked(apiGet).mockResolvedValue(detail);
-    const result = await fetchSessionDetail('s1');
-    expect(apiGet).toHaveBeenCalledWith('/sessions/s1');
-    expect(result).toEqual(detail);
-  });
-});
-
-describe('createSession', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPost with body', async () => {
-    const session = makeSession({ title: 'New' });
-    vi.mocked(apiPost).mockResolvedValue(session);
-    const result = await createSession({ title: 'New', model: 'gpt-5.6-sol' });
-    expect(apiPost).toHaveBeenCalledWith('/sessions', { title: 'New', model: 'gpt-5.6-sol' });
-    expect(result).toEqual(session);
-  });
-});
-
-describe('deleteSession', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiDelete with /sessions/:id', async () => {
-    vi.mocked(apiDelete).mockResolvedValue({ success: true });
-    const result = await deleteSession('s1');
-    expect(apiDelete).toHaveBeenCalledWith('/sessions/s1');
-    expect(result).toEqual({ success: true });
-  });
-});
-
-describe('submitPrompt', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPost with user_prompt body', async () => {
-    const turn = makeTurn({ user_prompt: 'hello' });
-    vi.mocked(apiPost).mockResolvedValue(turn);
-    const result = await submitPrompt('s1', 'hello');
-    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/turns', { user_prompt: 'hello' });
-    expect(result).toEqual(turn);
-  });
-});
-
-describe('cancelTurn', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPost with /sessions/:id/cancel', async () => {
-    vi.mocked(apiPost).mockResolvedValue({ success: true });
-    await cancelTurn('s1');
-    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/cancel');
-  });
-});
-
-describe('renameSession', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPatch with title body', async () => {
-    const session = makeSession({ title: 'Renamed' });
-    vi.mocked(apiPatch).mockResolvedValue(session);
-    await renameSession('s1', 'Renamed');
-    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { title: 'Renamed' });
-  });
-});
-
-describe('markFinished', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPatch with lifecycle finished', async () => {
-    const session = makeSession({ lifecycle: 'finished' });
-    vi.mocked(apiPatch).mockResolvedValue(session);
-    await markFinished('s1');
-    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { lifecycle: 'finished' });
-  });
-});
-
-describe('reopenSession', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPatch with lifecycle working', async () => {
-    const session = makeSession({ lifecycle: 'working' });
-    vi.mocked(apiPatch).mockResolvedValue(session);
-    await reopenSession('s1');
-    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { lifecycle: 'working' });
-  });
-});
-
-describe('clearUnreviewed', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPatch with has_unreviewed 0', async () => {
-    const session = makeSession({ has_unreviewed: 0 });
-    vi.mocked(apiPatch).mockResolvedValue(session);
-    await clearUnreviewed('s1');
-    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { has_unreviewed: 0 });
-  });
-});
-
-describe('updateModelConfig', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPatch with model and reasoning effort', async () => {
-    const session = makeSession({ model: 'gpt-5.6-sol', model_reasoning_effort: 'high' });
-    vi.mocked(apiPatch).mockResolvedValue(session);
-    await updateModelConfig('s1', 'gpt-5.6-sol', 'high');
-    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', {
-      model: 'gpt-5.6-sol',
-      model_reasoning_effort: 'high',
-    });
-  });
-
-  it('passes null model and effort', async () => {
-    const session = makeSession({ model: null, model_reasoning_effort: null });
-    vi.mocked(apiPatch).mockResolvedValue(session);
-    await updateModelConfig('s1', null, null);
-    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', { model: null, model_reasoning_effort: null });
-  });
-
-  it('includes runtime_type when provided', async () => {
-    const session = makeSession({ runtime_type: 'claude', model: null });
-    vi.mocked(apiPatch).mockResolvedValue(session);
-    await updateModelConfig('s1', null, null, 'claude');
-    expect(apiPatch).toHaveBeenCalledWith('/sessions/s1', {
-      model: null,
-      model_reasoning_effort: null,
-      runtime_type: 'claude',
-    });
-  });
-});
-
-describe('rewindSession', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPost with turn_id', async () => {
-    const session = makeSession({ external_thread_id: null });
-    vi.mocked(apiPost).mockResolvedValue(session);
-    await rewindSession('s1', 't1');
-    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/rewind', { turn_id: 't1' });
-  });
-});
-
-describe('branchSession', () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it('calls apiPost with turn_id and title', async () => {
-    const session = makeSession({ id: 's2', title: 'Branch' });
-    vi.mocked(apiPost).mockResolvedValue(session);
-    await branchSession('s1', 't1', 'Branch');
-    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/branch', { turn_id: 't1', title: 'Branch' });
-  });
-
-  it('passes undefined title when not provided', async () => {
-    const session = makeSession({ id: 's2' });
-    vi.mocked(apiPost).mockResolvedValue(session);
-    await branchSession('s1', 't1');
-    expect(apiPost).toHaveBeenCalledWith('/sessions/s1/branch', { turn_id: 't1', title: undefined });
-  });
-});

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

@@ -1,97 +0,0 @@
-import { apiGet, apiPost, apiDelete, apiPatch } from './client.ts';
-import type { Session, SessionDetail, Turn, Attachment } from '../types/index.ts';
-
-/** Fetch all sessions, ordered by creation date (newest first). */
-export function fetchSessions(): Promise<Session[]> {
-  return apiGet<Session[]>('/sessions');
-}
-
-/** Fetch a single session with all its turns and items. */
-export function fetchSessionDetail(id: string): Promise<SessionDetail> {
-  return apiGet<SessionDetail>(`/sessions/${id}`);
-}
-
-/** Create a new session with optional title, model, and working directory. */
-export function createSession(body: {
-  title?: string;
-  runtime_type?: string;
-  model?: string;
-  model_reasoning_effort?: string;
-  cwd?: string;
-  runtime_config?: string;
-}): Promise<Session> {
-  return apiPost<Session>('/sessions', body);
-}
-
-/** Delete a session and all its turns and items (cascade). */
-export function deleteSession(id: string): Promise<{ success: boolean }> {
-  return apiDelete<{ success: boolean }>(`/sessions/${id}`);
-}
-
-/** Submit a user prompt to a session — starts a turn (fire-and-forget). */
-export function submitPrompt(sessionId: string, userPrompt: string, attachments?: Attachment[]): Promise<Turn> {
-  return apiPost<Turn>(`/sessions/${sessionId}/turns`, {
-    user_prompt: userPrompt,
-    ...(attachments?.length ? { attachments } : {}),
-  });
-}
-
-/** Cancel the currently running turn in a session. */
-export function cancelTurn(sessionId: string): Promise<{ success: boolean }> {
-  return apiPost<{ success: boolean }>(`/sessions/${sessionId}/cancel`);
-}
-
-/** Rename a session by updating its title. */
-export function renameSession(sessionId: string, title: string): Promise<Session> {
-  return apiPatch<Session>(`/sessions/${sessionId}`, { title });
-}
-
-/** Mark a session as finished (lifecycle = 'finished'). */
-export function markFinished(sessionId: string): Promise<Session> {
-  return apiPatch<Session>(`/sessions/${sessionId}`, { lifecycle: 'finished' });
-}
-
-/** Reopen a finished session (lifecycle = 'working'). */
-export function reopenSession(sessionId: string): Promise<Session> {
-  return apiPatch<Session>(`/sessions/${sessionId}`, { lifecycle: 'working' });
-}
-
-/** Clear the "has unreviewed" flag on a session (reviewed by user). */
-export function clearUnreviewed(sessionId: string): Promise<Session> {
-  return apiPatch<Session>(`/sessions/${sessionId}`, { has_unreviewed: 0 });
-}
-
-/** Update the model, reasoning effort, and/or provider for a session. Clears the cached thread when changed. */
-export function updateModelConfig(
-  sessionId: string,
-  model: string | null,
-  modelReasoningEffort: string | null,
-  runtimeType?: string,
-): Promise<Session> {
-  const body: Record<string, unknown> = { model, model_reasoning_effort: modelReasoningEffort };
-  if (runtimeType !== undefined) body.runtime_type = runtimeType;
-  return apiPatch<Session>(`/sessions/${sessionId}`, body);
-}
-
-/** Update the runtime config (sandbox mode, web search, network access) for a session. */
-export function updateRuntimeConfig(
-  sessionId: string,
-  runtimeConfig: string | null,
-): Promise<Session> {
-  return apiPatch<Session>(`/sessions/${sessionId}`, { runtime_config: runtimeConfig });
-}
-
-/** Rewind a session to a specific turn — hides turns after the target (non-destructive), forks the provider session. */
-export function rewindSession(sessionId: string, turnId: string): Promise<Session> {
-  return apiPost<Session>(`/sessions/${sessionId}/rewind`, { turn_id: turnId });
-}
-
-/** Restore a rewound session — unhides all turns, restores the original provider thread. */
-export function restoreSession(sessionId: string): Promise<Session> {
-  return apiPost<Session>(`/sessions/${sessionId}/restore`, {});
-}
-
-/** Branch a session from a specific turn — creates a new session with turns up to and including the target. */
-export function branchSession(sessionId: string, turnId: string, title?: string): Promise<Session> {
-  return apiPost<Session>(`/sessions/${sessionId}/branch`, { turn_id: turnId, title });
-}

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

@@ -1,12 +0,0 @@
-import { apiGet } from './client.ts';
-import type { Extension } from '../types/index.ts';
-
-/** Fetch all available skills (user + system). */
-export function fetchSkills(): Promise<Extension[]> {
-  return apiGet<Extension[]>('/skills');
-}
-
-/** Fetch full SKILL.md content for a specific skill. */
-export function fetchSkillContent(name: string): Promise<{ name: string; content: string; path: string }> {
-  return apiGet(`/skills/${name}`);
-}