agentgui 1.0.1117 → 1.0.1118

package/lib/ws-handlers-util.js

@@ -1,529 +1,11 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import crypto from 'crypto';
-import { execSync, spawnSync, execFile } from 'child_process';
-import { runClaudeWithStreaming } from './claude-runner-run.js';
-import { registry } from './claude-runner-agents.js';
-import { confineToRoots, fsAllowRoots } from './http-handler.js';
-import { restart as restartAcpAgent } from './acp-sdk-manager.js';
-
-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.
-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.
-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}$/;
-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}$/;
-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;
-}
-
-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': []
-};
+import { register as registerAgents } from './ws-handlers/agents.js';
+import { register as registerChat } from './ws-handlers/chat.js';
+import { register as registerGit } from './ws-handlers/git.js';
+import { register as registerMisc } from './ws-handlers/misc.js';
 
 export function register(router, deps) {
-  const { queries, wsOptimizer, broadcastSync, getProviderConfigs, saveProviderConfig, STARTUP_CWD, discoveredAgents, subscriptionIndex, activeChats, getModelsForAgent } = deps;
-
-  // 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
-  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();
-  }
-
-  // --- 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: [] };
-  });
-
-  // --- 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 = terminalEvents.get(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 };
-  });
-
-
-
-  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('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 {
-      const isWindows = os.platform() === 'win32';
-      execSync('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' },
-        shell: isWindows
-      });
-      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', () => {
-    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 path = line.slice(3);
-        if (x === '?' && y === '?') { files.push({ path, status: '?' }); continue; }
-        if (x !== ' ' && x !== '?') files.push({ path, status: x, staged: true });
-        else if (y !== ' ' && y !== '?') files.push({ path, 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()); }
-  });
-
-  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());
-
-  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,
-      },
-    };
-  });
+  registerAgents(router, deps);
+  registerChat(router, deps);
+  registerGit(router, deps);
+  registerMisc(router, deps);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.1117",
+  "version": "1.0.1118",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/site/app/js/app.js

@@ -1,5 +1,6 @@
 import { h, mount, installStyles, components as C } from 'anentrypoint-design';
 import * as B from './backend.js';
+import { createChatPersistence } from './chat-persistence.js';
 
 installStyles().catch(() => {});
 
@@ -2916,109 +2917,13 @@ function cancelChat() {
   render();
 }
 
-const CHAT_KEY = 'agentgui.chat';
-// An assistant turn with no content AND no parts is an empty shell (an aborted
-// turn that produced nothing). The view already renders it as nothing; drop it
-// from persisted/in-memory state so a restored chat never carries blank bubbles.
-function isEmptyTurn(m) {
-  return m.role === 'assistant' && !m.content && !(Array.isArray(m.parts) && m.parts.length);
-}
-// Cap the persisted footprint: the last 100 messages, with any tool args/result
-// payload over 4KB truncated in the SAVED copy only (in-memory state keeps the
-// full payload). A quota failure is surfaced once instead of silently dropping
-// persistence forever.
-const PERSIST_MSG_CAP = 100;
-const PERSIST_PART_CAP = 4096;
-let _persistFailedOnce = false;
-let _lastPersistTs = 0;
-function trimPartForStorage(p) {
-  if (!p || typeof p !== 'object') return p;
-  let out = p;
-  for (const k of ['result', 'args']) {
-    const v = out[k];
-    if (v == null) continue;
-    let s;
-    if (typeof v === 'string') s = v;
-    else { try { s = JSON.stringify(v); } catch { s = String(v); } }
-    if (s.length > PERSIST_PART_CAP) {
-      if (out === p) out = { ...p };
-      out[k] = s.slice(0, PERSIST_PART_CAP);
-      out.truncatedForStorage = true;
-    }
-  }
-  return out;
-}
-function persistChat() {
-  try {
-    const eligible = state.chat.messages.filter(m => !isEmptyTurn(m));
-    // On-screen transcript can exceed the cap; a reload only restores the last
-    // PERSIST_MSG_CAP turns - surface that once so it's not a silent surprise,
-    // same Alert pattern as the sibling quota-failure banner below.
-    const wasCapped = eligible.length > PERSIST_MSG_CAP;
-    if (wasCapped !== !!state.chat.persistTruncated) {
-      state.chat.persistTruncated = wasCapped;
-      scheduleRender();
-    }
-    const msgs = eligible
-      .slice(-PERSIST_MSG_CAP)
-      .map(m => ({ id: m.id, role: m.role, content: m.content, time: m.time, costUsd: m.costUsd, stopped: m.stopped || undefined, parts: Array.isArray(m.parts) ? m.parts.map(trimPartForStorage) : m.parts }));
-    const draft = (state.chat.draft || '').trim() ? state.chat.draft : '';
-    // Persist when there is a transcript OR a non-empty draft (a typed-but-not-
-    // sent message must survive a reload too).
-    if (!msgs.length && !draft) { lsRemove(CHAT_KEY); return; }
-    _lastPersistTs = Date.now();
-    localStorage.setItem(CHAT_KEY, JSON.stringify({ ts: _lastPersistTs, messages: msgs, draft, resumeSid: state.chat.resumeSid, totalCost: state.chat.totalCost || 0, agent: state.selectedAgent, model: state.selectedModel }));
-  } catch {
-    if (!_persistFailedOnce) {
-      _persistFailedOnce = true;
-      state.chat.persistError = true;
-      announce('chat too large to save locally - export it from settings');
-      scheduleRender();
-    }
-  }
-}
-const debouncedPersistDraft = debounce(persistChat, 500);
-// Another GUI tab rewrote the shared chat key: never silently diverge - surface
-// a banner offering to reload the newer copy (last-writer-wins with a ts guard).
-window.addEventListener('storage', (e) => {
-  if (e.key !== CHAT_KEY || !e.newValue) return;
-  try {
-    const remote = JSON.parse(e.newValue);
-    if (remote && remote.ts && remote.ts > _lastPersistTs) {
-      state.chat.externalUpdate = true;
-      scheduleRender();
-    }
-  } catch {}
-});
-function restoreChat() {
-  try {
-    const raw = lsGet(CHAT_KEY);
-    if (!raw) return;
-    const saved = JSON.parse(raw);
-    if (typeof saved.draft === 'string' && saved.draft.trim()) {
-      state.chat.draft = saved.draft;
-      // A restored draft is set programmatically, so Ctrl+Z has nothing in the
-      // browser's native undo history to act on - a one-time note explains why
-      // undo appears to do nothing right after a reload.
-      announce('draft restored - note: undo history does not carry over a reload');
-    }
-    if (typeof saved.totalCost === 'number') state.chat.totalCost = saved.totalCost;
-    if (Array.isArray(saved.messages) && saved.messages.length) {
-      state.chat.messages = saved.messages
-        .filter(m => !isEmptyTurn(m))
-        .map(m => ({ ...m, parts: Array.isArray(m.parts) ? m.parts : [] }));
-      // Prefer the per-message cost sum when present (it self-corrects after
-      // edit/retry truncation); the scalar is only the legacy fallback.
-      const derived = computeTotalCost();
-      if (derived) state.chat.totalCost = derived;
-      state.chat.resumeSid = saved.resumeSid || null;
-      // Restore the agent/model the transcript belongs to, so a restored chat
-      // isn't silently shown under whatever agent the picker defaulted to.
-      state.chat.restoredAgent = saved.agent || null;
-      state.chat.restoredModel = saved.model || null;
-    }
-  } catch {}
-}
+// Chat transcript localStorage persistence - extracted to chat-persistence.js
+// (vertical slice per AGENTS.md SOLID/Clean-Architecture preferences). The
+// factory closes over the SAME live `state` object every other app.js concern
+// mutates by reference, so every call site below (persistChat/restoreChat/
+// debouncedPersistDraft/isEmptyTurn) keeps working unchanged.
+const { persistChat, restoreChat, debouncedPersistDraft, isEmptyTurn } =
+  createChatPersistence(state, { announce, scheduleRender, lsGet, lsRemove, debounce });
 
 // Flatten a message's content (string content or md/text/tool parts) to plain
 // text for the copy action.