repoburg 1.3.188 → 1.3.196

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

@@ -0,0 +1,112 @@
+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(),
+}));
+
+import { apiGet, apiPost, apiDelete } from './client.ts';
+import {
+  fetchWorkspaces,
+  createWorkspace,
+  hideWorkspace,
+  deleteWorkspace,
+  pickDirectory,
+} from './workspaces.ts';
+import type { Workspace } from '../types/index.ts';
+
+const NOW = '2025-01-01T00:00:00Z';
+
+function makeWorkspace(overrides: Partial<Workspace> = {}): Workspace {
+  return {
+    id: 'w1',
+    path: '/test/path',
+    label: null,
+    deleted: 0,
+    created_at: NOW,
+    ...overrides,
+  };
+}
+
+describe('fetchWorkspaces', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiGet with /workspaces', async () => {
+    const workspaces = [makeWorkspace()];
+    vi.mocked(apiGet).mockResolvedValue(workspaces);
+    const result = await fetchWorkspaces();
+    expect(apiGet).toHaveBeenCalledWith('/workspaces');
+    expect(result).toEqual(workspaces);
+  });
+});
+
+describe('createWorkspace', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPost with path', async () => {
+    const ws = makeWorkspace({ path: '/new' });
+    vi.mocked(apiPost).mockResolvedValue(ws);
+    await createWorkspace('/new');
+    expect(apiPost).toHaveBeenCalledWith('/workspaces', { path: '/new', label: undefined });
+  });
+
+  it('passes label when provided', async () => {
+    const ws = makeWorkspace({ path: '/new', label: 'My Project' });
+    vi.mocked(apiPost).mockResolvedValue(ws);
+    await createWorkspace('/new', 'My Project');
+    expect(apiPost).toHaveBeenCalledWith('/workspaces', { path: '/new', label: 'My Project' });
+  });
+});
+
+describe('hideWorkspace', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiPost with path on /workspaces/hide', async () => {
+    vi.mocked(apiPost).mockResolvedValue({ success: true });
+    await hideWorkspace('/path');
+    expect(apiPost).toHaveBeenCalledWith('/workspaces/hide', { path: '/path' });
+  });
+});
+
+describe('deleteWorkspace', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('calls apiDelete with /workspaces/:id', async () => {
+    vi.mocked(apiDelete).mockResolvedValue({ success: true });
+    await deleteWorkspace('w1');
+    expect(apiDelete).toHaveBeenCalledWith('/workspaces/w1');
+  });
+});
+
+describe('pickDirectory', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    global.fetch = vi.fn();
+  });
+
+  it('returns cancelled when status is 204', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({ status: 204 });
+    const result = await pickDirectory();
+    expect(result).toEqual({ cancelled: true });
+  });
+
+  it('returns path on ok response', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ path: '/selected/dir' }),
+    });
+    const result = await pickDirectory();
+    expect(result).toEqual({ path: '/selected/dir' });
+  });
+
+  it('throws on error response', async () => {
+    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+    });
+    await expect(pickDirectory()).rejects.toThrow('GET /api/pick-directory failed: 500 Internal Server Error');
+  });
+});

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

@@ -1,24 +1,38 @@
 import { apiGet, apiPost, apiDelete } from './client.ts';
 import type { Workspace } from '../types/index.ts';
 
+interface PickDirectoryResult {
+  path?: string;
+  cancelled?: boolean;
+}
+
+/** Fetch all workspaces (active and soft-deleted), ordered by creation date. */
 export function fetchWorkspaces(): Promise<Workspace[]> {
   return apiGet<Workspace[]>('/workspaces');
 }
 
+/** Create a new workspace at the given path, or restore a soft-deleted one. */
 export function createWorkspace(path: string, label?: string): Promise<Workspace> {
   return apiPost<Workspace>('/workspaces', { path, label });
 }
 
+/** Soft-delete (hide) a workspace by path. Sessions keep their cwd. */
 export function hideWorkspace(path: string): Promise<{ success: boolean }> {
   return apiPost<{ success: boolean }>('/workspaces/hide', { path });
 }
 
+/** Soft-delete a workspace by ID. Does NOT delete sessions. */
 export function deleteWorkspace(id: string): Promise<{ success: boolean }> {
   return apiDelete<{ success: boolean }>(`/workspaces/${id}`);
 }
 
-export async function pickDirectory(): Promise<{ path?: string; cancelled?: boolean }> {
+/** Open the native OS folder picker dialog (macOS only via osascript).
+ *  @returns `{ path }` on success, or `{ cancelled: true }` if the user dismissed the dialog. */
+export async function pickDirectory(): Promise<PickDirectoryResult> {
   const res = await fetch('/api/pick-directory');
   if (res.status === 204) return { cancelled: true };
-  return res.json();
-}
+  if (!res.ok) {
+    throw new Error(`GET /api/pick-directory failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json() as Promise<PickDirectoryResult>;
+}

package/agent-pane/frontend/src/components/CollapsibleToolCalls.test.tsx

@@ -0,0 +1,49 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { render, screen, fireEvent, cleanup } from '@testing-library/react';
+import CollapsibleToolCalls, { isToolItem } from './CollapsibleToolCalls.tsx';
+import { makeItem } from '../test/fixtures.ts';
+
+describe('isToolItem', () => {
+  it('returns true for tool types', () => {
+    expect(isToolItem(makeItem('i1', 't1', 'command_execution'))).toBe(true);
+    expect(isToolItem(makeItem('i2', 't1', 'file_change'))).toBe(true);
+    expect(isToolItem(makeItem('i3', 't1', 'mcp_tool_call'))).toBe(true);
+    expect(isToolItem(makeItem('i4', 't1', 'web_search'))).toBe(true);
+  });
+
+  it('returns false for non-tool types', () => {
+    expect(isToolItem(makeItem('i1', 't1', 'agent_message'))).toBe(false);
+    expect(isToolItem(makeItem('i2', 't1', 'reasoning'))).toBe(false);
+    expect(isToolItem(makeItem('i3', 't1', 'todo_list'))).toBe(false);
+    expect(isToolItem(makeItem('i4', 't1', 'error'))).toBe(false);
+  });
+});
+
+describe('CollapsibleToolCalls', () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  it('returns null when items is empty', () => {
+    const { container } = render(<CollapsibleToolCalls items={[]} />);
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('shows collapsed state by default (no item content visible)', () => {
+    const item = makeItem('i1', 't1', 'command_execution');
+    item.data = { command: 'ls', aggregated_output: '' };
+    render(<CollapsibleToolCalls items={[item]} />);
+    expect(screen.getByText(/1 tool call/)).toBeInTheDocument();
+    // Item card content should NOT be rendered when collapsed
+    expect(screen.queryByText('Command')).not.toBeInTheDocument();
+  });
+
+  it('expands on header click and shows item cards', () => {
+    const item = makeItem('i1', 't1', 'command_execution');
+    item.data = { command: 'echo hello', aggregated_output: 'hello' };
+    render(<CollapsibleToolCalls items={[item]} />);
+    const header = document.querySelector('.tool-calls-header')!;
+    fireEvent.click(header);
+    expect(screen.getByText('Command')).toBeInTheDocument();
+  });
+});

package/agent-pane/frontend/src/components/CollapsibleToolCalls.tsx

@@ -22,10 +22,7 @@ export default function CollapsibleToolCalls({ items }: Props) {
 
   return (
     <div className="tool-calls">
-      <div
-        className="tool-calls-header"
-        onClick={() => setExpanded((e) => !e)}
-      >
+      <div className="tool-calls-header" onClick={() => setExpanded((e) => !e)}>
         <span className="tool-calls-icon">
           <Wrench size={12} />
         </span>
@@ -47,4 +44,4 @@ export default function CollapsibleToolCalls({ items }: Props) {
       )}
     </div>
   );
-}
+}

package/agent-pane/frontend/src/components/CommandInputBar.test.tsx

@@ -0,0 +1,133 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { render, screen, fireEvent, cleanup } from '@testing-library/react';
+
+// Mock useProvider to avoid async fetch in tests
+vi.mock('../hooks/useProvider.ts', () => ({
+  useProvider: () => ({
+    provider: { id: 'codex', label: 'Codex', available: true, capabilities: {
+      dynamicModels: true, skills: true, plugins: true, mcpServers: true,
+      imageAttachments: true, sandbox: true, webSearch: true, networkAccess: true, fileReferences: true,
+    } },
+    capabilities: {
+      dynamicModels: true, skills: true, plugins: true, mcpServers: true,
+      imageAttachments: true, sandbox: true, webSearch: true, networkAccess: true, fileReferences: true,
+    },
+    loading: false,
+  }),
+}));
+
+import CommandInputBar from './CommandInputBar.tsx';
+import { useStore } from '../store/store.ts';
+import { resetStore } from '../test/component-helpers.ts';
+import { makeSession, makeDetail } from '../test/fixtures.ts';
+
+describe('CommandInputBar', () => {
+  beforeEach(() => {
+    vi.stubGlobal('requestAnimationFrame', (cb: () => void) => cb());
+    resetStore();
+  });
+  afterEach(() => {
+    cleanup();
+    vi.unstubAllGlobals();
+  });
+
+  it('shows "Select or create a session…" placeholder when no active session', () => {
+    render(<CommandInputBar />);
+    expect(screen.getByPlaceholderText('Select or create a session…')).toBeInTheDocument();
+  });
+
+  it('shows "Agent is running…" placeholder when is_running=1', () => {
+    const detail = makeDetail('s1', [], { is_running: 1 });
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail }, sessions: [makeSession('s1')] });
+    render(<CommandInputBar />);
+    expect(screen.getByPlaceholderText('Agent is running…')).toBeInTheDocument();
+  });
+
+  it('shows "Type a message…" placeholder when idle', () => {
+    const detail = makeDetail('s1', []);
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail }, sessions: [makeSession('s1')] });
+    render(<CommandInputBar />);
+    const textarea = screen.getByRole('textbox') as HTMLTextAreaElement;
+    expect(textarea.placeholder).toMatch(/Type a message/);
+  });
+
+  it('disables textarea when no active session', () => {
+    render(<CommandInputBar />);
+    expect(screen.getByRole('textbox')).toBeDisabled();
+  });
+
+  it('sends prompt on Cmd+Enter and clears input', async () => {
+    const detail = makeDetail('s1', []);
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail }, sessions: [makeSession('s1')] });
+    const submitPrompt = vi.fn().mockResolvedValue(undefined);
+    useStore.setState({ submitPrompt });
+
+    render(<CommandInputBar />);
+    const textarea = screen.getByRole('textbox') as HTMLTextAreaElement;
+    fireEvent.change(textarea, { target: { value: 'hello world' } });
+    fireEvent.keyDown(textarea, { key: 'Enter', metaKey: true });
+
+    expect(submitPrompt).toHaveBeenCalledWith('hello world');
+  });
+
+  it('send button calls submitPrompt with trimmed value', async () => {
+    const detail = makeDetail('s1', []);
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail }, sessions: [makeSession('s1')] });
+    const submitPrompt = vi.fn().mockResolvedValue(undefined);
+    useStore.setState({ submitPrompt });
+
+    render(<CommandInputBar />);
+    const textarea = screen.getByRole('textbox') as HTMLTextAreaElement;
+    fireEvent.change(textarea, { target: { value: '  test  ' } });
+    const sendBtn = document.querySelector('.cmd-send-btn') as HTMLElement;
+    fireEvent.click(sendBtn);
+
+    expect(submitPrompt).toHaveBeenCalledWith('test');
+  });
+
+  it('send button is disabled when input is empty', () => {
+    const detail = makeDetail('s1', []);
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail }, sessions: [makeSession('s1')] });
+    render(<CommandInputBar />);
+    const sendBtn = document.querySelector('.cmd-send-btn') as HTMLButtonElement;
+    expect(sendBtn.disabled).toBe(true);
+  });
+
+  it('stop button is visible when running and calls cancelTurn', async () => {
+    const detail = makeDetail('s1', [], { is_running: 1 });
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail }, sessions: [makeSession('s1')] });
+    const cancelTurn = vi.fn().mockResolvedValue(undefined);
+    useStore.setState({ cancelTurn });
+
+    render(<CommandInputBar />);
+    const stopBtn = document.querySelector('.cmd-stop-btn') as HTMLElement;
+    expect(stopBtn).toBeInTheDocument();
+    fireEvent.click(stopBtn);
+    expect(cancelTurn).toHaveBeenCalled();
+  });
+
+  it('ESC key calls cancelTurn when running', () => {
+    const detail = makeDetail('s1', [], { is_running: 1 });
+    resetStore({ activeSessionId: 's1', sessionDetails: { s1: detail }, sessions: [makeSession('s1')] });
+    const cancelTurn = vi.fn().mockResolvedValue(undefined);
+    useStore.setState({ cancelTurn });
+
+    render(<CommandInputBar />);
+    fireEvent.keyDown(window, { key: 'Escape' });
+    expect(cancelTurn).toHaveBeenCalled();
+  });
+
+  it('restoredPrompt sets textarea value and clears store', () => {
+    const detail = makeDetail('s1', []);
+    resetStore({
+      activeSessionId: 's1',
+      sessionDetails: { s1: detail },
+      sessions: [makeSession('s1')],
+      restoredPrompt: 'restored text',
+    });
+    render(<CommandInputBar />);
+    const textarea = screen.getByRole('textbox') as HTMLTextAreaElement;
+    expect(textarea.value).toBe('restored text');
+    expect(useStore.getState().restoredPrompt).toBeNull();
+  });
+});