agentgui 1.0.1117 → 1.0.1119

package/lib/ws-handlers/agents.js

@@ -0,0 +1,137 @@
+import { registry } from '../claude-runner-agents.js';
+import { restart as restartAcpAgent } from '../acp-sdk-manager.js';
+import { err } from './shared.js';
+import { spawnSync } from 'child_process';
+
+const SUB_AGENT_MAP = {
+  'opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }], 'cli-opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }],
+  'gemini': [{ id: 'gm-gc', name: 'GM Gemini' }], 'cli-gemini': [{ id: 'gm-gc', name: 'GM Gemini' }],
+  'kilo': [{ id: 'gm-kilo', name: 'GM Kilo' }], 'cli-kilo': [{ id: 'gm-kilo', name: 'GM Kilo' }],
+  'codex': [], 'cli-codex': []
+};
+
+export function register(router, deps) {
+  const { getProviderConfigs, getModelsForAgent } = deps;
+
+  // --- agents.list: enumerate registered ACP agents + claude-code ---
+  router.handle('agents.list', () => {
+    const agents = registry.list().map(a => ({
+      id: a.id,
+      name: a.name,
+      protocol: a.protocol,
+      supportsStdin: !!a.supportsStdin,
+      features: a.supportedFeatures || [],
+      available: registry.isAvailable(a.id),
+      npxInstallable: !!a.npxPackage,
+      // The CLI binary name a manual (non-npx) install would need - lets the
+      // settings panel say what to install instead of just "not installed".
+      cmd: a.command || null,
+    }));
+    return { agents };
+  });
+
+  // --- agents.models: model choices for a given agent ---
+  router.handle('agents.models', async (p) => {
+    const id = p?.id || p?.agentId;
+    if (!id) err(400, 'agent id required');
+    if (id === 'claude-code') {
+      return { models: [
+        { id: 'sonnet', name: 'Claude Sonnet (latest)' },
+        { id: 'opus', name: 'Claude Opus (latest)' },
+        { id: 'haiku', name: 'Claude Haiku (latest)' },
+      ] };
+    }
+    // Other agents: discover their models via getModelsForAgent (queries the
+    // running ACP server). Fail closed to an empty list on any error or when
+    // the dep isn't a function.
+    if (typeof getModelsForAgent === 'function') {
+      try {
+        const raw = await getModelsForAgent(id);
+        const list = Array.isArray(raw) ? raw : (raw?.models || []);
+        return { models: list.map(m => ({ id: m.id, name: m.name || m.label || m.id })) };
+      } catch { return { models: [] }; }
+    }
+    return { models: [] };
+  });
+
+  router.handle('acp.restart', async (p) => {
+    if (!p.id) err(400, 'Missing agent id');
+    const ok = await restartAcpAgent(p.id);
+    return { ok: !!ok };
+  });
+
+  router.handle('agent.subagents', async (p) => {
+    if (!p.id) err(400, 'Missing agent id');
+    if (p.id === 'claude-code' || p.id === 'cli-claude') {
+      const spawnEnv = { ...process.env }; delete spawnEnv.CLAUDECODE;
+      const result = spawnSync('claude', ['agents', 'list'], { encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'], env: spawnEnv });
+      if (result.status !== 0 || !result.stdout) return { subAgents: [] };
+      const agents = result.stdout.trim().split('\n').filter(l => l.trim()).map(l => l.match(/^  (\S+)\s+·/)).filter(Boolean).map(m => ({ id: m[1], name: m[1] }));
+      return { subAgents: agents };
+    }
+    return { subAgents: SUB_AGENT_MAP[p.id] || [] };
+  });
+
+  // --- models.availability: composes agentgui's REAL model surface into the
+  // ModelsConfig component's shape (design SDK's ModelsConfig.js). agentgui
+  // has no freddie-style probed-availability matrix (no /v1/models round-trip
+  // per mode) - what it actually has is: discovered agent CLIs (registry,
+  // same data agents.list already exposes), each agent's model choices
+  // (agents.models' getModelsForAgent), and per-provider API-key presence
+  // (auth.configs' getProviderConfigs). This handler is a read-only
+  // composition of those three real sources, not a new probe and not fake
+  // data - "usable_in_any_mode" is derived from registry.isAvailable(agentId)
+  // (the CLI binary was actually found on this server), and "key_present"
+  // comes straight from getProviderConfigs' filesystem check.
+  router.handle('models.availability', async () => {
+    const agents = registry.list();
+    const providerConfigs = typeof getProviderConfigs === 'function' ? getProviderConfigs() : {};
+    const providers = [];
+    for (const a of agents) {
+      const available = registry.isAvailable(a.id);
+      let models = [];
+      if (a.id === 'claude-code') {
+        models = [
+          { id: 'sonnet', name: 'Claude Sonnet (latest)' },
+          { id: 'opus', name: 'Claude Opus (latest)' },
+          { id: 'haiku', name: 'Claude Haiku (latest)' },
+        ];
+      } else if (typeof getModelsForAgent === 'function') {
+        try {
+          const raw = await getModelsForAgent(a.id);
+          const list = Array.isArray(raw) ? raw : (raw?.models || []);
+          models = list.map((m) => ({ id: m.id, name: m.name || m.label || m.id }));
+        } catch { models = []; }
+      }
+      // Map onto agentgui's one real signal per model: is the agent CLI itself
+      // available on this server (registry.isAvailable). agentgui does not
+      // probe individual (model, mode) cells the way freddie's matrix does,
+      // so every model under an available agent reports the same single
+      // 'cli' mode rather than fabricating per-mode probe results.
+      providers.push({
+        id: a.id,
+        key_present: !!(providerConfigs[a.id] && providerConfigs[a.id].hasKey) || available,
+        discovery_error: available ? null : ((a.name || a.id) + ' CLI not found on this server'),
+        models: models.map((m) => ({
+          id: m.id,
+          name: m.name,
+          discovered_via: a.protocol || 'cli',
+          modes: { cli: { ok: !!available, skipped: !available, reason: available ? undefined : 'agent_not_installed' } },
+          usable_in_any_mode: !!available,
+        })),
+      });
+    }
+    const totalModels = providers.reduce((n, p) => n + p.models.length, 0);
+    const usableModels = providers.reduce((n, p) => n + p.models.filter((m) => m.usable_in_any_mode).length, 0);
+    return {
+      timestamp: new Date().toISOString(),
+      providers,
+      sampler: [],
+      summary: {
+        total_providers: providers.length,
+        total_models: totalModels,
+        usable_in_any_mode: usableModels,
+      },
+    };
+  });
+}

package/lib/ws-handlers/chat.js

@@ -0,0 +1,157 @@
+import crypto from 'crypto';
+import { runClaudeWithStreaming } from '../claude-runner-run.js';
+import { registry } from '../claude-runner-agents.js';
+import { confineToRoots, fsAllowRoots } from '../http-handler.js';
+import { err } from './shared.js';
+import { recordTerminal, getTerminal } from './terminal-state.js';
+
+export function register(router, deps) {
+  const { wsOptimizer, broadcastSync, STARTUP_CWD, subscriptionIndex, activeChats } = deps;
+
+  // --- conversation.subscribe: register this ws for sessionId broadcasts ---
+  router.handle('conversation.subscribe', (p, ws) => {
+    const sid = p?.sessionId;
+    if (!sid || typeof sid !== 'string') err(400, 'sessionId required');
+    if (!subscriptionIndex.has(sid)) subscriptionIndex.set(sid, new Set());
+    subscriptionIndex.get(sid).add(ws);
+    ws.subscriptions = ws.subscriptions || new Set();
+    ws.subscriptions.add(sid);
+    // Replay a buffered terminal frame (complete/error/cancelled) so a client
+    // that re-subscribes after a ws drop learns the turn already ended.
+    const term = getTerminal(sid);
+    if (term) { try { wsOptimizer.sendToClient(ws, { ...term, replayed: true }); } catch {} }
+    return { subscribed: true, sessionId: sid, replayedTerminal: !!term };
+  });
+
+  // --- chat.sendMessage: start a one-shot streaming chat with an agent.
+  // Bypasses the gutted db-queries layer entirely; calls runClaudeWithStreaming
+  // directly and broadcasts streaming_* events scoped to an ephemeral sessionId.
+  router.handle('chat.sendMessage', async (p, ws) => {
+    let content = (p?.content || '').toString();
+    if (!content) err(400, 'content required');
+    const agentId = p?.agentId || 'claude-code';
+    // For non-resume agents (not claude-code which uses --resume), prepend prior
+    // conversation turns so the agent has context. claude-code handles multi-turn
+    // natively via resumeSessionId; direct runners (agy, etc.) get a preamble.
+    const priorMessages = Array.isArray(p?.messages) ? p.messages.filter(m => m?.role && m?.content) : [];
+    if (agentId !== 'claude-code' && !p?.resumeSid && !p?.resumeSessionId && priorMessages.length > 0) {
+      const preamble = priorMessages.map(m => (m.role === 'user' ? 'User: ' : 'Assistant: ') + (m.content || '').trim()).join('\n\n');
+      content = '[Prior conversation]\n' + preamble + '\n\n[Current message]\n' + content;
+    }
+    const model = p?.model || undefined;
+    const subAgent = p?.subAgent || undefined;
+    const cwd = p?.cwd || STARTUP_CWD;
+    const resumeSessionId = p?.resumeSid || p?.resumeSessionId || undefined;
+    if (!registry.has(agentId)) err(404, `Unknown agentId: ${agentId}`);
+    // A client-supplied cwd must be confined to the SAME allowlist as the Files
+    // routes (fsAllowRoots) - an unconfined cwd would let a client spawn the
+    // agent CLI anywhere on disk. Use the realpath-resolved value as the spawn
+    // cwd (defeats symlink escape, same as the HTTP file routes). No p.cwd ->
+    // STARTUP_CWD, which is itself an allowed root, so it needs no check.
+    let spawnCwd = STARTUP_CWD;
+    if (p?.cwd) {
+      const conf = confineToRoots(cwd, fsAllowRoots());
+      if (!conf.ok) err(conf.reason === 'not found' ? 400 : 403, `cwd outside allowed roots: ${cwd}`);
+      spawnCwd = conf.realPath;
+    }
+
+    const sessionId = 'chat-' + crypto.randomBytes(8).toString('hex');
+    // Auto-subscribe the originating ws so it receives its own broadcasts.
+    if (!subscriptionIndex.has(sessionId)) subscriptionIndex.set(sessionId, new Set());
+    subscriptionIndex.get(sessionId).add(ws);
+    ws.subscriptions = ws.subscriptions || new Set();
+    ws.subscriptions.add(sessionId);
+
+    const ctrl = { aborted: false, proc: null, agentId, model, cwd: spawnCwd, startedAt: Date.now() };
+    activeChats.set(sessionId, ctrl);
+    // Push-driven hint so clients refresh active-session state without
+    // waiting for the 3s chat.active poll (finding 48).
+    broadcastSync({ type: 'chat_active_changed', reason: 'started', sessionId, agentId, timestamp: Date.now() });
+
+    // Fire-and-forget. Errors broadcast as streaming_error.
+    (async () => {
+      let eventCount = 0;
+      broadcastSync({ type: 'streaming_start', sessionId, agentId, timestamp: Date.now() });
+      let claudeSessionBroadcast = false;
+      const onEvent = (parsed) => {
+        eventCount++;
+        // Surface claude's REAL session id (from the stream) once, so the client
+        // can --resume this conversation on its next turn. The ephemeral
+        // 'chat-...' sessionId is not a claude session id and cannot be resumed.
+        if (!claudeSessionBroadcast && parsed?.session_id) {
+          claudeSessionBroadcast = true;
+          ctrl.claudeSessionId = parsed.session_id;
+          broadcastSync({ type: 'streaming_session', sessionId, claudeSessionId: parsed.session_id, agentId, timestamp: Date.now() });
+        }
+        if (parsed?.type === 'assistant' && parsed.message?.content) {
+          for (const block of parsed.message.content) {
+            broadcastSync({ type: 'streaming_progress', sessionId, block, blockRole: 'assistant', seq: eventCount, timestamp: Date.now() });
+          }
+        } else if (parsed?.type === 'user' && parsed.message?.content) {
+          const blocks = Array.isArray(parsed.message.content) ? parsed.message.content : [];
+          for (const block of blocks) {
+            if (block?.type === 'tool_result') {
+              broadcastSync({ type: 'streaming_progress', sessionId, block, blockRole: 'tool_result', seq: eventCount, timestamp: Date.now() });
+            }
+          }
+        } else if (parsed?.type === 'result') {
+          const block = { type: 'result', result: parsed.result, subtype: parsed.subtype, duration_ms: parsed.duration_ms, total_cost_usd: parsed.total_cost_usd, is_error: !!parsed.is_error };
+          broadcastSync({ type: 'streaming_progress', sessionId, block, blockRole: 'result', seq: eventCount, isResult: true, timestamp: Date.now() });
+        }
+      };
+      try {
+        const config = {
+          verbose: true, outputFormat: 'stream-json', timeout: 1800000, print: true,
+          model, subAgent, onEvent, resumeSessionId,
+          onPid: () => {}, onProcess: (proc) => { ctrl.proc = proc; },
+        };
+        await runClaudeWithStreaming(content, spawnCwd, agentId, config);
+        if (!ctrl.aborted) {
+          const ev = { type: 'streaming_complete', sessionId, claudeSessionId: ctrl.claudeSessionId || null, agentId, eventCount, timestamp: Date.now() };
+          recordTerminal(sessionId, ev);
+          broadcastSync(ev);
+        }
+      } catch (e) {
+        if (!ctrl.aborted) {
+          const ev = { type: 'streaming_error', sessionId, claudeSessionId: ctrl.claudeSessionId || null, agentId, error: e.message || String(e), recoverable: false, timestamp: Date.now() };
+          recordTerminal(sessionId, ev);
+          broadcastSync(ev);
+        }
+      } finally {
+        activeChats.delete(sessionId);
+        broadcastSync({ type: 'chat_active_changed', reason: 'ended', sessionId, agentId, timestamp: Date.now() });
+      }
+    })();
+
+    return { sessionId, started: true };
+  });
+
+  // --- chat.active: list in-flight chats started via this server ---
+  router.handle('chat.active', () => {
+    const sessions = [];
+    for (const [sid, c] of activeChats) {
+      sessions.push({ sessionId: sid, claudeSessionId: c.claudeSessionId || null, agentId: c.agentId || null, model: c.model || null, cwd: c.cwd || null, startedAt: c.startedAt || null, pid: c.proc?.pid || null });
+    }
+    return { sessions };
+  });
+
+  // --- chat.cancel: abort an in-flight chat ---
+  router.handle('chat.cancel', (p) => {
+    const sid = p?.sessionId;
+    if (!sid) err(400, 'sessionId required');
+    const ctrl = activeChats.get(sid);
+    if (!ctrl) return { cancelled: false, reason: 'not-found' };
+    ctrl.aborted = true;
+    // Broadcast the terminal 'cancelled' frame BEFORE killing the proc so a
+    // remote cancellation (other tab, dashboard stop-all) does not read as a
+    // normal completion (finding 44). streaming_cancelled is in BROADCAST_TYPES
+    // so every connected client sees it; it is also buffered for re-subscribers.
+    const ev = { type: 'streaming_cancelled', sessionId: sid, claudeSessionId: ctrl.claudeSessionId || null, agentId: ctrl.agentId || null, cancelled: true, timestamp: Date.now() };
+    recordTerminal(sid, ev);
+    broadcastSync(ev);
+    try { ctrl.proc?.kill?.(); } catch {}
+    activeChats.delete(sid);
+    broadcastSync({ type: 'chat_active_changed', reason: 'cancelled', sessionId: sid, agentId: ctrl.agentId || null, timestamp: Date.now() });
+    return { cancelled: true };
+  });
+}

package/lib/ws-handlers/git.js

@@ -0,0 +1,159 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { execSync, execFileSync } from 'child_process';
+import { err, execFileP, resolveGitCwd, assertSafeRelPath, assertSafeBranch } from './shared.js';
+
+export function register(router, deps) {
+  const { STARTUP_CWD } = deps;
+
+  router.handle('clone', (p) => {
+    const repo = (p.repo || '').trim();
+    if (!repo || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(repo)) {
+      err(400, 'Invalid repo format. Use org/repo or user/repo');
+    }
+    const cloneDir = STARTUP_CWD || os.homedir();
+    const repoName = repo.split('/')[1];
+    const targetPath = path.join(cloneDir, repoName);
+    if (fs.existsSync(targetPath)) err(409, `Directory already exists: ${repoName}`);
+    try {
+      execFileSync('git', ['clone', 'https://github.com/' + repo + '.git'], {
+        cwd: cloneDir, encoding: 'utf-8', timeout: 120000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+      });
+      return { ok: true, repo, path: targetPath, name: repoName };
+    } catch (e) { err(500, (e.stderr || e.message || 'Clone failed').trim()); }
+  });
+
+  router.handle('git.check', () => {
+    try {
+      const isWindows = os.platform() === 'win32';
+      const devnull = isWindows ? '' : ' 2>/dev/null';
+      const remoteUrl = execSync('git remote get-url origin' + devnull, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows }).trim();
+      const statusResult = execSync('git status --porcelain' + devnull, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      const hasChanges = statusResult.trim().length > 0;
+      const unpushedResult = execSync('git rev-list --count --not --remotes' + devnull, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      const hasUnpushed = parseInt(unpushedResult.trim() || '0', 10) > 0;
+      const githubUser = process.env.GITHUB_USER;
+      const ownsRemote = !remoteUrl.includes('github.com/') || (!!githubUser && remoteUrl.includes(githubUser));
+      return { ownsRemote, hasChanges, hasUnpushed, remoteUrl };
+    } catch {
+      return { ownsRemote: false, hasChanges: false, hasUnpushed: false, remoteUrl: '' };
+    }
+  });
+
+  router.handle('git.push', (p) => {
+    if (!p?.confirm) err(400, 'confirm required: git.push commits and pushes the entire working tree');
+    try {
+      const isWindows = os.platform() === 'win32';
+      const cmd = isWindows
+        ? 'git add -A & git commit -m "Auto-commit" & git push'
+        : 'git add -A && git commit -m "Auto-commit" && git push';
+      execSync(cmd, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
+      return { success: true };
+    } catch (e) { err(500, e.message); }
+  });
+
+  // --- git.status: changed-file list (staged/unstaged/untracked) for
+  // GitStatusPanel. Porcelain=v1 line format "XY PATH" (rename: "XY OLD -> NEW"),
+  // X = index state, Y = worktree state, '?'/' ' = untouched/untracked.
+  router.handle('git.status', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    try {
+      const { stdout } = await execFileP('git', ['status', '--porcelain=v1'], { cwd });
+      const files = [];
+      for (const line of stdout.split('\n')) {
+        if (!line) continue;
+        const x = line[0], y = line[1];
+        const filePath = line.slice(3);
+        if (x === '?' && y === '?') { files.push({ path: filePath, status: '?' }); continue; }
+        if (x !== ' ' && x !== '?') files.push({ path: filePath, status: x, staged: true });
+        else if (y !== ' ' && y !== '?') files.push({ path: filePath, status: y, staged: false });
+      }
+      return { files };
+    } catch (e) { err(500, (e.stderr || e.message || 'git status failed').trim()); }
+  });
+
+  // --- git.diff: unified diff for a single file or the whole working tree.
+  // p.cwd (optional) is confined via confineToRoots/fsAllowRoots, same as
+  // chat.sendMessage; p.file (optional) is validated to reject flags/shell
+  // metacharacters. execFile array-args form only, never a shell string.
+  router.handle('git.diff', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    const args = ['diff', '--no-color'];
+    if (p?.staged) args.push('--staged');
+    if (p?.file) args.push('--', assertSafeRelPath(p.file, 'file'));
+    try {
+      const { stdout } = await execFileP('git', args, { cwd });
+      // git prints "Binary files a/x and b/x differ" for binary paths instead
+      // of a unified diff - an empty `diff` string then reads to the client as
+      // "no diff to show" with no explanation. Detect it so the UI can say why.
+      const binary = /^Binary files .* differ$/m.test(stdout);
+      return { diff: stdout, binary, file: p?.file || null, staged: !!p?.staged };
+    } catch (e) { err(500, (e.stderr || e.message || 'git diff failed').trim()); }
+  });
+
+  // --- git.log: recent commit list, limit param (default 20, capped 200).
+  router.handle('git.log', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    const limit = Math.max(1, Math.min(200, parseInt(p?.limit, 10) || 20));
+    const FIELD_SEP = '\x1f';
+    const REC_SEP = '\x1e';
+    const args = ['log', `-n${limit}`, `--pretty=format:%H${FIELD_SEP}%an${FIELD_SEP}%ad${FIELD_SEP}%s${REC_SEP}`, '--date=iso-strict'];
+    try {
+      const { stdout } = await execFileP('git', args, { cwd });
+      const commits = stdout.split(REC_SEP).map(s => s.trim()).filter(Boolean).map(rec => {
+        const [hash, author, date, ...rest] = rec.split(FIELD_SEP);
+        return { hash, author, date, subject: rest.join(FIELD_SEP) };
+      });
+      return { commits };
+    } catch (e) { err(500, (e.stderr || e.message || 'git log failed').trim()); }
+  });
+
+  // --- worktree.list / create / remove ---
+  router.handle('worktree.list', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    try {
+      const { stdout } = await execFileP('git', ['worktree', 'list', '--porcelain'], { cwd });
+      // Parse the porcelain block format: records separated by blank lines,
+      // each line "key value" or a bare flag ("bare", "detached", "locked").
+      const worktrees = [];
+      let cur = null;
+      for (const line of stdout.split('\n')) {
+        if (!line.trim()) { if (cur) { worktrees.push(cur); cur = null; } continue; }
+        if (!cur) cur = {};
+        const sp = line.indexOf(' ');
+        if (sp === -1) { cur[line] = true; continue; }
+        cur[line.slice(0, sp)] = line.slice(sp + 1);
+      }
+      if (cur) worktrees.push(cur);
+      return { worktrees: worktrees.map(w => ({ path: w.worktree || null, head: w.HEAD || null, branch: w.branch || null, bare: !!w.bare, detached: !!w.detached, locked: !!w.locked })) };
+    } catch (e) { err(500, (e.stderr || e.message || 'git worktree list failed').trim()); }
+  });
+
+  router.handle('worktree.create', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    const wtPath = assertSafeRelPath(p?.path, 'path');
+    const args = ['worktree', 'add'];
+    if (p?.newBranch) { args.push('-b', assertSafeBranch(p.newBranch, 'newBranch')); }
+    args.push(wtPath);
+    if (p?.branch) args.push(assertSafeBranch(p.branch, 'branch'));
+    try {
+      const { stdout, stderr } = await execFileP('git', args, { cwd });
+      return { ok: true, output: (stdout || stderr || '').trim(), path: wtPath };
+    } catch (e) { err(500, (e.stderr || e.message || 'git worktree add failed').trim()); }
+  });
+
+  router.handle('worktree.remove', async (p) => {
+    const cwd = resolveGitCwd(p, STARTUP_CWD);
+    const wtPath = assertSafeRelPath(p?.path, 'path');
+    const args = ['worktree', 'remove'];
+    if (p?.force) args.push('--force');
+    args.push(wtPath);
+    try {
+      const { stdout, stderr } = await execFileP('git', args, { cwd });
+      return { ok: true, output: (stdout || stderr || '').trim() };
+    } catch (e) { err(500, (e.stderr || e.message || 'git worktree remove failed').trim()); }
+  });
+}

package/lib/ws-handlers/misc.js

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { err } from './shared.js';
+
+export function register(router, deps) {
+  const { queries, wsOptimizer, getProviderConfigs, saveProviderConfig, STARTUP_CWD } = deps;
+
+  router.handle('home', () => ({ home: os.homedir(), cwd: STARTUP_CWD }));
+
+  router.handle('folders', (p) => {
+    const folderPath = p.path || STARTUP_CWD;
+    try {
+      const raw = folderPath.startsWith('~') ? folderPath.replace('~', os.homedir()) : folderPath;
+      const entries = fs.readdirSync(path.resolve(raw), { withFileTypes: true });
+      return { folders: entries.filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => ({ name: e.name })).sort((a, b) => a.name.localeCompare(b.name)) };
+    } catch (e) { err(400, e.message); }
+  });
+
+  router.handle('auth.configs', () => getProviderConfigs());
+
+  router.handle('auth.save', (p) => {
+    const { providerId, apiKey, defaultModel } = p;
+    if (typeof providerId !== 'string' || !providerId.length || providerId.length > 100) err(400, 'Invalid providerId');
+    if (typeof apiKey !== 'string' || !apiKey.length || apiKey.length > 10000) err(400, 'Invalid apiKey');
+    if (defaultModel !== undefined && (typeof defaultModel !== 'string' || defaultModel.length > 200)) err(400, 'Invalid defaultModel');
+    const configPath = saveProviderConfig(providerId, apiKey, defaultModel || '');
+    return { success: true, path: configPath };
+  });
+
+  router.handle('import.claude', () => ({ imported: queries.importClaudeCodeConversations() }));
+
+  router.handle('discover.claude', () => ({ discovered: queries.discoverClaudeCodeConversations() }));
+
+  router.handle('ws.stats', () => wsOptimizer.getStats());
+}

package/lib/ws-handlers/shared.js

@@ -0,0 +1,47 @@
+import { execFile } from 'child_process';
+import { confineToRoots, fsAllowRoots } from '../http-handler.js';
+
+export function err(code, message) { const e = new Error(message); e.code = code; throw e; }
+
+// Promisified execFile — array-args form only, never a shell string, so a
+// crafted branch/path/file value cannot be interpreted as a shell command.
+export function execFileP(cmd, args, opts) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { encoding: 'utf-8', timeout: 30000, maxBuffer: 20 * 1024 * 1024, ...opts }, (e, stdout, stderr) => {
+      if (e) { e.stdout = stdout; e.stderr = stderr; reject(e); return; }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+// Resolve + confine a client-supplied cwd to the same allowlist the file
+// explorer / chat.sendMessage use (fsAllowRoots via confineToRoots). Falls
+// back to STARTUP_CWD (itself an allowed root) when no cwd is given.
+export function resolveGitCwd(p, STARTUP_CWD) {
+  if (!p?.cwd) return STARTUP_CWD;
+  const conf = confineToRoots(p.cwd, fsAllowRoots());
+  if (!conf.ok) err(conf.reason === 'not found' ? 400 : 403, `cwd outside allowed roots: ${p.cwd}`);
+  return conf.realPath;
+}
+
+// A relative in-repo file path: no leading '-' (flag injection), no shell
+// metacharacters, no absolute path (git resolves it relative to cwd already).
+const SAFE_REL_PATH_RE = /^[^\0]{1,4096}$/;
+export function assertSafeRelPath(v, label) {
+  if (typeof v !== 'string' || !v.length) err(400, `${label} required`);
+  if (v.startsWith('-')) err(400, `${label} must not start with '-'`);
+  if (/[\0]/.test(v)) err(400, `${label} contains invalid characters`);
+  if (!SAFE_REL_PATH_RE.test(v)) err(400, `${label} invalid`);
+  return v;
+}
+
+// A git branch/ref name — conservative allowlist (git's own ref-format is
+// more permissive, but this blocks every shell-metacharacter and flag-
+// injection vector while still covering normal branch names).
+const SAFE_BRANCH_RE = /^[A-Za-z0-9][A-Za-z0-9_.\/-]{0,199}$/;
+export function assertSafeBranch(v, label) {
+  if (typeof v !== 'string' || !v.length) err(400, `${label} required`);
+  if (v.startsWith('-') || v.includes('..') || v.includes('//')) err(400, `${label} invalid`);
+  if (!SAFE_BRANCH_RE.test(v)) err(400, `${label} invalid`);
+  return v;
+}

package/lib/ws-handlers/terminal-state.js

@@ -0,0 +1,16 @@
+// Short-lived per-session terminal-event buffer (finding 35): a turn that
+// completes/errors/cancels while a client ws is down would otherwise be a
+// fire-and-forget broadcast the client never sees, hanging it busy forever.
+// A re-subscribing client gets the buffered terminal frame replayed.
+const TERMINAL_TTL_MS = 60000;
+const terminalEvents = new Map(); // sessionId -> terminal event
+
+export function recordTerminal(sessionId, event) {
+  terminalEvents.set(sessionId, event);
+  const t = setTimeout(() => {
+    if (terminalEvents.get(sessionId) === event) terminalEvents.delete(sessionId);
+  }, TERMINAL_TTL_MS);
+  if (typeof t.unref === 'function') t.unref();
+}
+
+export function getTerminal(sessionId) { return terminalEvents.get(sessionId); }