repoburg 1.3.201 → 1.3.204

package/agent-pane/backend/src/routes/workspaces.test.ts

@@ -1,197 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import Fastify, { type FastifyInstance } from 'fastify';
-import { initDb, getDb } from '../db/index.ts';
-import { registerWorkspaceRoutes } from './workspaces.ts';
-import { execFile } from 'node:child_process';
-
-// Mock child_process to avoid spawning osascript in tests
-vi.mock('node:child_process', () => ({
-  execFile: vi.fn(),
-}));
-
-const NOW = '2025-01-01T00:00:00Z';
-
-function insertWorkspace(
-  db: ReturnType<typeof getDb>,
-  id: string,
-  path: string,
-  overrides: Record<string, unknown> = {},
-): void {
-  db.prepare('INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, ?, ?, ?)').run(
-    id,
-    path,
-    (overrides['label'] as string | null) ?? null,
-    (overrides['deleted'] as number) ?? 0,
-    (overrides['created_at'] as string) ?? NOW,
-  );
-}
-
-/** Configure execFile mock to call callback with success.
- *  Passes an object as the first result arg so promisify resolves with { stdout, stderr }.
- */
-function mockExecFileSuccess(stdout: string): void {
-  const mock = execFile as unknown as ReturnType<typeof vi.fn>;
-  mock.mockImplementation((...args: unknown[]) => {
-    const cb = args[args.length - 1] as ((err: Error | null, ...results: unknown[]) => void) | undefined;
-    if (typeof cb === 'function') cb(null, { stdout, stderr: '' });
-  });
-}
-
-/** Configure execFile mock to call callback with error (simulates user cancel). */
-function mockExecFileError(error: Error): void {
-  const mock = execFile as unknown as ReturnType<typeof vi.fn>;
-  mock.mockImplementation((...args: unknown[]) => {
-    const cb = args[args.length - 1] as ((err: Error | null, ...results: unknown[]) => void) | undefined;
-    if (typeof cb === 'function') cb(error);
-  });
-}
-
-describe('Workspace routes', () => {
-  let app: FastifyInstance;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    initDb(':memory:');
-    app = Fastify();
-    await registerWorkspaceRoutes(app);
-  });
-
-  describe('GET /api/workspaces', () => {
-    it('returns empty array when no workspaces', async () => {
-      const res = await app.inject({ method: 'GET', url: '/api/workspaces' });
-      expect(res.statusCode).toBe(200);
-      expect(res.json()).toEqual([]);
-    });
-
-    it('returns all workspaces ordered by created_at ASC', async () => {
-      const db = getDb();
-      insertWorkspace(db, 'w1', '/path/a', { created_at: '2025-01-02T00:00:00Z' });
-      insertWorkspace(db, 'w2', '/path/b', { created_at: '2025-01-01T00:00:00Z' });
-      const res = await app.inject({ method: 'GET', url: '/api/workspaces' });
-      const workspaces = res.json();
-      expect(workspaces).toHaveLength(2);
-      expect(workspaces[0].id).toBe('w2');
-      expect(workspaces[1].id).toBe('w1');
-    });
-  });
-
-  describe('POST /api/workspaces', () => {
-    it('returns 400 when path is missing', async () => {
-      const res = await app.inject({ method: 'POST', url: '/api/workspaces', payload: {} });
-      expect(res.statusCode).toBe(400);
-    });
-
-    it('returns 400 when path is empty', async () => {
-      const res = await app.inject({ method: 'POST', url: '/api/workspaces', payload: { path: '   ' } });
-      expect(res.statusCode).toBe(400);
-    });
-
-    it('returns 400 when path has wrong type', async () => {
-      const res = await app.inject({ method: 'POST', url: '/api/workspaces', payload: { path: { nested: true } } });
-      expect(res.statusCode).toBe(400);
-    });
-
-    it('returns 409 for duplicate active workspace', async () => {
-      const db = getDb();
-      insertWorkspace(db, 'w1', '/existing/path');
-      const res = await app.inject({ method: 'POST', url: '/api/workspaces', payload: { path: '/existing/path' } });
-      expect(res.statusCode).toBe(409);
-    });
-
-    it('creates a new workspace', async () => {
-      const res = await app.inject({
-        method: 'POST',
-        url: '/api/workspaces',
-        payload: { path: '/new/path', label: 'Test' },
-      });
-      expect(res.statusCode).toBe(200);
-      const ws = res.json();
-      expect(ws.id).toBeDefined();
-      expect(ws.path).toBe('/new/path');
-      expect(ws.label).toBe('Test');
-      expect(ws.deleted).toBe(0);
-    });
-
-    it('restores a soft-deleted workspace', async () => {
-      const db = getDb();
-      insertWorkspace(db, 'w1', '/deleted/path', { deleted: 1, label: 'Old' });
-      const res = await app.inject({
-        method: 'POST',
-        url: '/api/workspaces',
-        payload: { path: '/deleted/path', label: 'Restored' },
-      });
-      expect(res.statusCode).toBe(200);
-      const ws = res.json();
-      expect(ws.id).toBe('w1');
-      expect(ws.deleted).toBe(0);
-      expect(ws.label).toBe('Restored');
-    });
-  });
-
-  describe('POST /api/workspaces/hide', () => {
-    it('returns 400 when path is missing', async () => {
-      const res = await app.inject({ method: 'POST', url: '/api/workspaces/hide', payload: {} });
-      expect(res.statusCode).toBe(400);
-    });
-
-    it('soft-deletes existing workspace', async () => {
-      const db = getDb();
-      insertWorkspace(db, 'w1', '/path/to/hide');
-      const res = await app.inject({ method: 'POST', url: '/api/workspaces/hide', payload: { path: '/path/to/hide' } });
-      expect(res.statusCode).toBe(200);
-      expect(res.json()).toEqual({ success: true });
-      const ws = db.prepare('SELECT deleted FROM workspaces WHERE id = ?').get('w1') as { deleted: number };
-      expect(ws.deleted).toBe(1);
-    });
-
-    it('creates and soft-deletes new workspace when path does not exist', async () => {
-      const res = await app.inject({ method: 'POST', url: '/api/workspaces/hide', payload: { path: '/new/path' } });
-      expect(res.statusCode).toBe(200);
-      const db = getDb();
-      const ws = db.prepare('SELECT * FROM workspaces WHERE path = ?').get('/new/path') as {
-        deleted: number;
-        id: string;
-      };
-      expect(ws.deleted).toBe(1);
-    });
-  });
-
-  describe('DELETE /api/workspaces/:id', () => {
-    it('returns 404 for missing workspace', async () => {
-      const res = await app.inject({ method: 'DELETE', url: '/api/workspaces/nonexistent' });
-      expect(res.statusCode).toBe(404);
-    });
-
-    it('returns 404 for already-deleted workspace', async () => {
-      const db = getDb();
-      insertWorkspace(db, 'w1', '/path', { deleted: 1 });
-      const res = await app.inject({ method: 'DELETE', url: '/api/workspaces/w1' });
-      expect(res.statusCode).toBe(404);
-    });
-
-    it('soft-deletes an active workspace', async () => {
-      const db = getDb();
-      insertWorkspace(db, 'w1', '/path');
-      const res = await app.inject({ method: 'DELETE', url: '/api/workspaces/w1' });
-      expect(res.statusCode).toBe(200);
-      expect(res.json()).toEqual({ success: true });
-      const ws = db.prepare('SELECT deleted FROM workspaces WHERE id = ?').get('w1') as { deleted: number };
-      expect(ws.deleted).toBe(1);
-    });
-  });
-
-  describe('GET /api/pick-directory', () => {
-    it('returns path on success', async () => {
-      mockExecFileSuccess('/selected/path/\n');
-      const res = await app.inject({ method: 'GET', url: '/api/pick-directory' });
-      expect(res.statusCode).toBe(200);
-      expect(res.json()).toEqual({ path: '/selected/path' });
-    });
-
-    it('returns 204 when user cancels', async () => {
-      mockExecFileError(new Error('User cancelled'));
-      const res = await app.inject({ method: 'GET', url: '/api/pick-directory' });
-      expect(res.statusCode).toBe(204);
-    });
-  });
-});

package/agent-pane/backend/src/routes/workspaces.ts

@@ -1,128 +0,0 @@
-import type { FastifyInstance } from 'fastify';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { v4 as uuidv4 } from 'uuid';
-import { getDb } from '../db/index.ts';
-import type { Workspace } from '../db/schema.ts';
-
-const execFileAsync = promisify(execFile);
-
-export async function registerWorkspaceRoutes(fastify: FastifyInstance): Promise<void> {
-  // GET /api/workspaces — list ALL workspaces (active + soft-deleted)
-  fastify.get('/api/workspaces', async () => {
-    const rows = getDb().prepare('SELECT * FROM workspaces ORDER BY created_at ASC').all() as Workspace[];
-    return rows;
-  });
-
-  // POST /api/workspaces — create workspace (or restore if soft-deleted)
-  fastify.post<{ Body: { path: string; label?: string } }>('/api/workspaces', {
-    schema: {
-      body: {
-        type: 'object',
-        required: ['path'],
-        properties: {
-          path: { type: 'string' },
-          label: { type: 'string' },
-        },
-      },
-    },
-  }, async (request, reply) => {
-    const { path, label = null } = request.body || {};
-    if (!path || !path.trim()) {
-      return reply.code(400).send({ error: 'Path is required' });
-    }
-
-    const trimmedPath = path.trim();
-    const db = getDb();
-
-    // Check if workspace with this path already exists
-    const existing = db.prepare('SELECT * FROM workspaces WHERE path = ?').get(trimmedPath) as Workspace | undefined;
-
-    if (existing) {
-      if (existing.deleted === 0) {
-        return reply.code(409).send({ error: 'Workspace with this path already exists' });
-      }
-      // Restore soft-deleted workspace
-      db.prepare('UPDATE workspaces SET deleted = 0, label = ? WHERE id = ?').run(label, existing.id);
-      const restored = db.prepare('SELECT * FROM workspaces WHERE id = ?').get(existing.id) as Workspace;
-      return restored;
-    }
-
-    // Create new workspace
-    const id = uuidv4();
-    const now = new Date().toISOString();
-    db.prepare('INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, ?, 0, ?)').run(
-      id,
-      trimmedPath,
-      label,
-      now,
-    );
-
-    const workspace = db.prepare('SELECT * FROM workspaces WHERE id = ?').get(id) as Workspace;
-    return workspace;
-  });
-
-  // GET /api/pick-directory — open native OS folder picker (macOS only)
-  fastify.get('/api/pick-directory', async (_request, reply) => {
-    try {
-      const { stdout } = await execFileAsync('osascript', [
-        '-e',
-        'POSIX path of (choose folder with prompt "Select a workspace directory")',
-      ]);
-      const path = stdout.trim().replace(/\/$/, '');
-      return { path };
-    } catch {
-      // User cancelled the dialog or osascript not available
-      return reply.code(204).send({ cancelled: true });
-    }
-  });
-
-  // POST /api/workspaces/hide — soft-delete workspace by path (creates record if not exists)
-  fastify.post<{ Body: { path: string } }>('/api/workspaces/hide', {
-    schema: {
-      body: {
-        type: 'object',
-        required: ['path'],
-        properties: {
-          path: { type: 'string' },
-        },
-      },
-    },
-  }, async (request, reply) => {
-    const { path } = request.body || {};
-    if (!path || !path.trim()) {
-      return reply.code(400).send({ error: 'Path is required' });
-    }
-    const trimmedPath = path.trim();
-    const db = getDb();
-
-    const existing = db.prepare('SELECT * FROM workspaces WHERE path = ?').get(trimmedPath) as Workspace | undefined;
-    if (existing) {
-      db.prepare('UPDATE workspaces SET deleted = 1 WHERE id = ?').run(existing.id);
-    } else {
-      const id = uuidv4();
-      const now = new Date().toISOString();
-      db.prepare('INSERT INTO workspaces (id, path, label, deleted, created_at) VALUES (?, ?, NULL, 1, ?)').run(
-        id,
-        trimmedPath,
-        now,
-      );
-    }
-
-    return { success: true };
-  });
-
-  // DELETE /api/workspaces/:id — soft-delete workspace by ID (does NOT delete sessions)
-  fastify.delete<{ Params: { id: string } }>('/api/workspaces/:id', async (request, reply) => {
-    const { id } = request.params;
-    const db = getDb();
-
-    const existing = db.prepare('SELECT id FROM workspaces WHERE id = ? AND deleted = 0').get(id);
-    if (!existing) {
-      return reply.code(404).send({ error: 'Workspace not found' });
-    }
-
-    db.prepare('UPDATE workspaces SET deleted = 1 WHERE id = ?').run(id);
-    return { success: true };
-  });
-}

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

@@ -1,107 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { broadcast, handleUpgrade, getWss, initWs } from './index.ts';
-import type { WebSocket, WebSocketServer } from 'ws';
-import type { IncomingMessage } from 'node:http';
-import type { Duplex } from 'node:stream';
-
-describe('getWss', () => {
-  it('returns null before initWs is called', async () => {
-    vi.resetModules();
-    const { getWss: freshGetWss } = await import('./index.ts');
-    expect(freshGetWss()).toBeNull();
-  });
-
-  it('returns instance after initWs', () => {
-    const wss = initWs();
-    expect(getWss()).toBe(wss);
-  });
-});
-
-describe('broadcast', () => {
-  let wss: WebSocketServer;
-
-  beforeEach(() => {
-    wss = initWs();
-  });
-
-  it('sends JSON message to OPEN clients', () => {
-    const client = { readyState: 1, OPEN: 1, send: vi.fn() } as unknown as WebSocket;
-    wss.clients.add(client);
-    broadcast('turn:started', { sessionId: 's1' });
-    expect(client.send).toHaveBeenCalledWith(JSON.stringify({ event: 'turn:started', data: { sessionId: 's1' } }));
-  });
-
-  it('skips non-OPEN clients', () => {
-    const client = { readyState: 3, OPEN: 1, send: vi.fn() } as unknown as WebSocket;
-    wss.clients.add(client);
-    broadcast('turn:started', {});
-    expect(client.send).not.toHaveBeenCalled();
-  });
-
-  it('sends to multiple OPEN clients', () => {
-    const c1 = { readyState: 1, OPEN: 1, send: vi.fn() } as unknown as WebSocket;
-    const c2 = { readyState: 1, OPEN: 1, send: vi.fn() } as unknown as WebSocket;
-    wss.clients.add(c1);
-    wss.clients.add(c2);
-    broadcast('item:completed', { id: 'i1' });
-    expect(c1.send).toHaveBeenCalledTimes(1);
-    expect(c2.send).toHaveBeenCalledTimes(1);
-  });
-
-  it('is no-op when no clients connected', () => {
-    broadcast('turn:started', {});
-    // No error thrown
-  });
-
-  it('is no-op when wss is not initialised', async () => {
-    vi.resetModules();
-    const { broadcast: freshBroadcast } = await import('./index.ts');
-    freshBroadcast('turn:started', {});
-    // No error thrown
-  });
-});
-
-describe('handleUpgrade', () => {
-  function makeMockWss(): WebSocketServer {
-    return { handleUpgrade: vi.fn(), emit: vi.fn() } as unknown as WebSocketServer;
-  }
-
-  it('calls wss.handleUpgrade for /ws path', () => {
-    const mockWss = makeMockWss();
-    const request = { url: '/ws' } as unknown as IncomingMessage;
-    const socket = { destroy: vi.fn() } as unknown as Duplex;
-    const head = Buffer.alloc(0);
-
-    handleUpgrade(mockWss, request, socket, head);
-
-    expect(mockWss.handleUpgrade).toHaveBeenCalledWith(request, socket, head, expect.any(Function));
-    expect(socket.destroy).not.toHaveBeenCalled();
-  });
-
-  it('emits connection event when upgrade completes', () => {
-    const mockWss = makeMockWss();
-    const request = { url: '/ws' } as unknown as IncomingMessage;
-    const socket = { destroy: vi.fn() } as unknown as Duplex;
-    const head = Buffer.alloc(0);
-
-    handleUpgrade(mockWss, request, socket, head);
-
-    const callback = (mockWss.handleUpgrade as ReturnType<typeof vi.fn>).mock.calls[0][3] as (ws: WebSocket) => void;
-    const mockWs = { readyState: 1 } as unknown as WebSocket;
-    callback(mockWs);
-
-    expect(mockWss.emit).toHaveBeenCalledWith('connection', mockWs, request);
-  });
-
-  it('destroys socket for non-/ws path', () => {
-    const mockWss = makeMockWss();
-    const request = { url: '/api/something' } as unknown as IncomingMessage;
-    const socket = { destroy: vi.fn() } as unknown as Duplex;
-    const head = Buffer.alloc(0);
-
-    handleUpgrade(mockWss, request, socket, head);
-
-    expect(mockWss.handleUpgrade).not.toHaveBeenCalled();
-    expect(socket.destroy).toHaveBeenCalled();
-  });
-});

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

@@ -1,51 +0,0 @@
-import type { IncomingMessage } from 'node:http';
-import type { Duplex } from 'node:stream';
-import type { WebSocket } from 'ws';
-import { WebSocketServer } from 'ws';
-
-let wss: WebSocketServer | null = null;
-
-/** Initialise the WebSocket server in noServer mode.
- *  Call `handleUpgrade` from the HTTP server's 'upgrade' event to accept connections.
- *  @returns The created `WebSocketServer` instance. */
-export function initWs(): WebSocketServer {
-  wss = new WebSocketServer({ noServer: true });
-  return wss;
-}
-
-/** Handle an HTTP upgrade request for the `/ws` path.
- *  If the URL does not start with `/ws`, the socket is destroyed.
- *  @param wss — The WebSocket server to upgrade to.
- *  @param request — The incoming HTTP upgrade request.
- *  @param socket — The raw TCP socket.
- *  @param head — The first packet of the upgraded connection. */
-export function handleUpgrade(wss: WebSocketServer, request: IncomingMessage, socket: Duplex, head: Buffer): void {
-  const url = request.url || '';
-  if (url.startsWith('/ws')) {
-    wss.handleUpgrade(request, socket, head, (ws: WebSocket) => {
-      wss.emit('connection', ws, request);
-    });
-  } else {
-    socket.destroy();
-  }
-}
-
-/** Broadcast a JSON event to all connected WebSocket clients.
- *  No-op if the server is not initialised or no clients are connected.
- *  @param event — Event name (e.g. `'turn:started'`, `'item:completed'`).
- *  @param data — Payload object to serialise as JSON. */
-export function broadcast(event: string, data: unknown): void {
-  if (!wss) return;
-  const message = JSON.stringify({ event, data });
-  for (const client of wss.clients) {
-    if (client.readyState === client.OPEN) {
-      client.send(message);
-    }
-  }
-}
-
-/** Get the current WebSocket server instance.
- *  @returns The `WebSocketServer`, or `null` if not initialised. */
-export function getWss(): WebSocketServer | null {
-  return wss;
-}

package/agent-pane/backend/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "dist",
-    "resolveJsonModule": true,
-    "declaration": false,
-    "sourceMap": true,
-    "forceConsistentCasingInFileNames": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "allowImportingTsExtensions": true,
-    "paths": {
-      "@agentpane/shared": ["../shared/types.ts"]
-    }
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/agent-pane/backend/vitest.config.ts

@@ -1,20 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-/**
- * Backend vitest configuration.
- *
- * RAM mitigation: single-fork mode + no file parallelism.
- * Runs all test files in one Node.js process, one file at a time.
- */
-export default defineConfig({
-  test: {
-    environment: 'node',
-    // RAM: single process, one file at a time
-    pool: 'forks',
-    poolOptions: {
-      forks: { singleFork: true },
-    },
-    fileParallelism: false,
-    maxConcurrency: 1,
-  },
-});

package/agent-pane/eslint.config.js

@@ -1,33 +0,0 @@
-import js from '@eslint/js';
-import tseslint from 'typescript-eslint';
-import prettier from 'eslint-config-prettier';
-
-export default [
-  {
-    ignores: ['**/dist/**', '**/node_modules/**', '**/*.config.{js,ts}'],
-  },
-  js.configs.recommended,
-  ...tseslint.configs.recommended,
-  prettier,
-  {
-    languageOptions: {
-      ecmaVersion: 2022,
-      sourceType: 'module',
-    },
-    rules: {
-      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
-      '@typescript-eslint/no-explicit-any': 'warn',
-      'no-console': 'off',
-      'prefer-const': 'error',
-    },
-  },
-  {
-    // React frontend rules
-    files: ['frontend/**/*.tsx', 'frontend/**/*.ts'],
-    languageOptions: {
-      parserOptions: {
-        ecmaFeatures: { jsx: true },
-      },
-    },
-  },
-];