agentgui 1.0.398 → 1.0.399

package/lib/ws-events.js

@@ -0,0 +1,20 @@
+const S2L = {
+  's.start': 'streaming_start', 's.prog': 'streaming_progress',
+  's.done': 'streaming_complete', 's.err': 'streaming_error',
+  's.cancel': 'streaming_cancelled', 'conv.new': 'conversation_created',
+  'conv.upd': 'conversation_updated', 'convs.upd': 'conversations_updated',
+  'conv.del': 'conversation_deleted', 'msg.new': 'message_created',
+  'q.stat': 'queue_status', 'q.upd': 'queue_updated',
+  'rl.hit': 'rate_limit_hit', 'rl.clr': 'rate_limit_clear',
+  'scr.start': 'script_started', 'scr.stop': 'script_stopped',
+  'scr.out': 'script_output', 'mdl.prog': 'model_download_progress',
+  'stt.prog': 'stt_progress', 'tts.prog': 'tts_setup_progress',
+  'voice.ls': 'voice_list', 'sub.ok': 'subscription_confirmed',
+  'term.out': 'terminal_output', 'term.exit': 'terminal_exit',
+  'term.start': 'terminal_started'
+};
+const L2S = Object.fromEntries(Object.entries(S2L).map(([k, v]) => [v, k]));
+const toLong = (s) => S2L[s] || s;
+const toShort = (l) => L2S[l] || l;
+if (typeof window !== 'undefined') window.wsEvents = { S2L, L2S, toLong, toShort };
+export { S2L, L2S, toLong, toShort };

package/lib/ws-handlers-conv.js

@@ -0,0 +1,183 @@
+import path from 'path';
+
+function fail(code, message) { const e = new Error(message); e.code = code; throw e; }
+function notFound(msg = 'Not found') { fail(404, msg); }
+
+export function register(router, deps) {
+  const { queries, activeExecutions, messageQueues, rateLimitState,
+    broadcastSync, processMessageWithStreaming } = deps;
+
+  router.handle('conv.ls', () => {
+    const conversations = queries.getConversationsList();
+    for (const c of conversations) { if (c.isStreaming && !activeExecutions.has(c.id)) c.isStreaming = 0; }
+    return { conversations };
+  });
+
+  router.handle('conv.new', (p) => {
+    const wd = p.workingDirectory ? path.resolve(p.workingDirectory) : null;
+    const conv = queries.createConversation(p.agentId, p.title, wd, p.model || null);
+    queries.createEvent('conversation.created', { agentId: p.agentId, workingDirectory: conv.workingDirectory, model: conv.model }, conv.id);
+    broadcastSync({ type: 'conversation_created', conversation: conv });
+    return { conversation: conv };
+  });
+
+  router.handle('conv.get', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound();
+    return { conversation: conv, isActivelyStreaming: activeExecutions.has(p.id), latestSession: queries.getLatestSession(p.id) };
+  });
+
+  router.handle('conv.upd', (p) => {
+    const { id, ...data } = p;
+    if (data.workingDirectory) data.workingDirectory = path.resolve(data.workingDirectory);
+    const conv = queries.updateConversation(id, data);
+    if (!conv) notFound('Conversation not found');
+    queries.createEvent('conversation.updated', data, id);
+    broadcastSync({ type: 'conversation_updated', conversation: conv });
+    return { conversation: conv };
+  });
+
+  router.handle('conv.del', (p) => {
+    if (!queries.deleteConversation(p.id)) notFound();
+    broadcastSync({ type: 'conversation_deleted', conversationId: p.id });
+    return { deleted: true };
+  });
+
+  router.handle('conv.full', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound();
+    const chunkLimit = Math.min(p.chunkLimit || 500, 5000);
+    const totalChunks = queries.getConversationChunkCount(p.id);
+    const chunks = (p.allChunks || totalChunks <= chunkLimit)
+      ? queries.getConversationChunks(p.id) : queries.getRecentConversationChunks(p.id, chunkLimit);
+    return {
+      conversation: conv, isActivelyStreaming: activeExecutions.has(p.id),
+      latestSession: queries.getLatestSession(p.id), chunks, totalChunks,
+      messages: queries.getPaginatedMessages(p.id, 100, 0).messages,
+      rateLimitInfo: rateLimitState.get(p.id) || null
+    };
+  });
+
+  router.handle('conv.chunks', (p) => {
+    if (!queries.getConversation(p.id)) notFound('Conversation not found');
+    const since = parseInt(p.since || '0');
+    const allChunks = queries.getConversationChunks(p.id);
+    return { ok: true, chunks: since > 0 ? allChunks.filter(c => c.created_at > since) : allChunks };
+  });
+
+  router.handle('conv.cancel', (p) => {
+    const entry = activeExecutions.get(p.id);
+    if (!entry) notFound('No active execution to cancel');
+    const { pid, sessionId } = entry;
+    if (pid) { try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch {} } }
+    if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
+    queries.setIsStreaming(p.id, false);
+    activeExecutions.delete(p.id);
+    broadcastSync({ type: 'streaming_complete', sessionId, conversationId: p.id, interrupted: true, timestamp: Date.now() });
+    return { ok: true, cancelled: true, conversationId: p.id, sessionId };
+  });
+
+  router.handle('conv.inject', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound('Conversation not found');
+    if (!p.content) fail(400, 'Missing content');
+    const entry = activeExecutions.get(p.id);
+    if (entry && p.eager) fail(409, 'Cannot eagerly inject while execution is running - message queued');
+    const message = queries.createMessage(p.id, 'user', '[INJECTED] ' + p.content);
+    if (!entry) {
+      const agentId = conv.agentId || 'claude-code';
+      const session = queries.createSession(p.id, agentId, 'pending');
+      processMessageWithStreaming(p.id, message.id, session.id, message.content, agentId, conv.model || null);
+    }
+    return { ok: true, injected: true, conversationId: p.id, messageId: message.id };
+  });
+
+  router.handle('msg.ls', (p) => {
+    return queries.getPaginatedMessages(p.id, Math.min(p.limit || 50, 100), Math.max(p.offset || 0, 0));
+  });
+
+  function startExecution(convId, message, agentId, model, content) {
+    const session = queries.createSession(convId);
+    queries.createEvent('session.created', { messageId: message.id, sessionId: session.id }, convId, session.id);
+    activeExecutions.set(convId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
+    queries.setIsStreaming(convId, true);
+    broadcastSync({ type: 'streaming_start', sessionId: session.id, conversationId: convId, messageId: message.id, agentId, timestamp: Date.now() });
+    processMessageWithStreaming(convId, message.id, session.id, content, agentId, model).catch(() => {});
+    return session;
+  }
+
+  function enqueue(convId, content, agentId, model, messageId) {
+    if (!messageQueues.has(convId)) messageQueues.set(convId, []);
+    messageQueues.get(convId).push({ content, agentId, model, messageId });
+    const queueLength = messageQueues.get(convId).length;
+    broadcastSync({ type: 'queue_status', conversationId: convId, queueLength, messageId, timestamp: Date.now() });
+    return queueLength;
+  }
+
+  router.handle('msg.send', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound('Conversation not found');
+    const agentId = p.agentId || conv.agentType || conv.agentId || 'claude-code';
+    const model = p.model || conv.model || null;
+    const idempotencyKey = p.idempotencyKey || null;
+    const message = queries.createMessage(p.id, 'user', p.content, idempotencyKey);
+    queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
+    broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
+    if (activeExecutions.has(p.id)) {
+      const qp = enqueue(p.id, p.content, agentId, model, message.id);
+      return { message, queued: true, queuePosition: qp, idempotencyKey };
+    }
+    const session = startExecution(p.id, message, agentId, model, p.content);
+    return { message, session, idempotencyKey };
+  });
+
+  router.handle('msg.get', (p) => {
+    const msg = queries.getMessage(p.messageId);
+    if (!msg || msg.conversationId !== p.id) notFound();
+    return { message: msg };
+  });
+
+  router.handle('msg.stream', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound('Conversation not found');
+    const prompt = p.content || p.message || '';
+    const agentId = p.agentId || conv.agentType || conv.agentId || 'claude-code';
+    const model = p.model || conv.model || null;
+    const userMessage = queries.createMessage(p.id, 'user', prompt);
+    queries.createEvent('message.created', { role: 'user', messageId: userMessage.id }, p.id);
+    broadcastSync({ type: 'message_created', conversationId: p.id, message: userMessage, timestamp: Date.now() });
+    if (activeExecutions.has(p.id)) {
+      const qp = enqueue(p.id, prompt, agentId, model, userMessage.id);
+      return { message: userMessage, queued: true, queuePosition: qp };
+    }
+    const session = startExecution(p.id, userMessage, agentId, model, prompt);
+    return { message: userMessage, session, streamId: session.id };
+  });
+
+  router.handle('q.ls', (p) => {
+    if (!queries.getConversation(p.id)) notFound('Conversation not found');
+    return { queue: messageQueues.get(p.id) || [] };
+  });
+
+  router.handle('q.del', (p) => {
+    const queue = messageQueues.get(p.id);
+    if (!queue) notFound('Queue not found');
+    const idx = queue.findIndex(q => q.messageId === p.messageId);
+    if (idx === -1) notFound('Queued message not found');
+    queue.splice(idx, 1);
+    if (queue.length === 0) messageQueues.delete(p.id);
+    broadcastSync({ type: 'queue_status', conversationId: p.id, queueLength: queue?.length || 0, timestamp: Date.now() });
+    return { deleted: true };
+  });
+
+  router.handle('q.upd', (p) => {
+    const queue = messageQueues.get(p.id);
+    if (!queue) notFound('Queue not found');
+    const item = queue.find(q => q.messageId === p.messageId);
+    if (!item) notFound('Queued message not found');
+    if (p.content !== undefined) item.content = p.content;
+    if (p.agentId !== undefined) item.agentId = p.agentId;
+    broadcastSync({ type: 'queue_updated', conversationId: p.id, messageId: p.messageId, content: item.content, agentId: item.agentId, timestamp: Date.now() });
+    return { updated: true, item };
+  });
+}

package/lib/ws-handlers-run.js

@@ -0,0 +1,157 @@
+function err(code, message) { const e = new Error(message); e.code = code; throw e; }
+function need(p, key) { if (!p[key]) err(400, `Missing required param: ${key}`); return p[key]; }
+
+function register(router, deps) {
+  const { queries, discoveredAgents, activeExecutions, activeProcessesByRunId, broadcastSync, processMessageWithStreaming } = deps;
+
+  function findAgent(id) { const a = discoveredAgents.find(x => x.id === id); if (!a) err(404, 'Agent not found'); return a; }
+  function getRunOrThrow(id) { const r = queries.getRun(id); if (!r) err(404, 'Run not found'); return r; }
+  function getThreadOrThrow(id) { const t = queries.getThread(id); if (!t) err(404, 'Thread not found'); return t; }
+
+  function killExecution(threadId, runId) {
+    const ex = activeExecutions.get(threadId);
+    if (ex?.pid) {
+      try { process.kill(-ex.pid, 'SIGTERM'); } catch { try { process.kill(ex.pid, 'SIGTERM'); } catch {} }
+      setTimeout(() => { try { process.kill(-ex.pid, 'SIGKILL'); } catch { try { process.kill(ex.pid, 'SIGKILL'); } catch {} } }, 3000);
+    }
+    if (ex?.sessionId) queries.updateSession(ex.sessionId, { status: 'error', error: 'Cancelled by user', completed_at: Date.now() });
+    activeExecutions.delete(threadId);
+    activeProcessesByRunId.delete(runId);
+    queries.setIsStreaming(threadId, false);
+    return ex;
+  }
+
+  function startExecution(runId, threadId, agentId, input, config) {
+    const conv = queries.getConversation(threadId);
+    if (!conv || !input?.content) return;
+    const session = queries.createSession(threadId);
+    queries.updateRunStatus(runId, 'active');
+    activeExecutions.set(threadId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
+    activeProcessesByRunId.set(runId, { threadId, sessionId: session.id });
+    queries.setIsStreaming(threadId, true);
+    processMessageWithStreaming(threadId, null, session.id, input.content, agentId, config?.model || null)
+      .then(() => { queries.updateRunStatus(runId, 'success'); activeProcessesByRunId.delete(runId); })
+      .catch(() => { queries.updateRunStatus(runId, 'error'); activeProcessesByRunId.delete(runId); });
+  }
+
+  router.handle('run.new', async (p) => {
+    findAgent(need(p, 'agent_id'));
+    return queries.createRun(p.agent_id, p.thread_id || null, p.input || null, p.config || null, p.webhook_url || null);
+  });
+
+  router.handle('run.get', async (p) => getRunOrThrow(need(p, 'id')));
+
+  router.handle('run.del', async (p) => {
+    try { queries.deleteRun(need(p, 'id')); } catch { err(404, 'Run not found'); }
+    return { deleted: true };
+  });
+
+  router.handle('run.resume', async (p) => {
+    const id = need(p, 'id'), run = getRunOrThrow(id);
+    if (run.status !== 'pending') err(409, 'Run is not resumable');
+    if (run.thread_id) startExecution(id, run.thread_id, run.agent_id, p.input, p.config);
+    return queries.getRun(id) || run;
+  });
+
+  router.handle('run.cancel', async (p) => {
+    const id = need(p, 'id'), run = getRunOrThrow(id);
+    if (['success', 'error', 'cancelled'].includes(run.status)) err(409, 'Run already completed or cancelled');
+    const cancelled = queries.cancelRun(id);
+    if (run.thread_id) {
+      const ex = killExecution(run.thread_id, id);
+      broadcastSync({ type: 'streaming_cancelled', sessionId: ex?.sessionId || id, conversationId: run.thread_id, runId: id, timestamp: Date.now() });
+    }
+    return cancelled;
+  });
+
+  router.handle('run.search', async (p) => queries.searchRuns(p));
+
+  router.handle('run.wait', async (p) => {
+    const id = need(p, 'id');
+    getRunOrThrow(id);
+    const timeout = p.timeout || 30000, start = Date.now();
+    return new Promise((resolve) => {
+      const poll = setInterval(() => {
+        const cur = queries.getRun(id);
+        if (cur && ['success', 'error', 'cancelled'].includes(cur.status)) { clearInterval(poll); resolve(cur); }
+        else if (Date.now() - start > timeout) { clearInterval(poll); resolve({ error: 'Run still pending', run_id: id, status: cur?.status }); }
+      }, 500);
+    });
+  });
+
+  router.handle('run.stream', async (p) => {
+    const agent_id = need(p, 'agent_id');
+    findAgent(agent_id);
+    const run = queries.createRun(agent_id, null, p.input, p.config);
+    const threadId = queries.getRun(run.run_id)?.thread_id;
+    if (threadId) startExecution(run.run_id, threadId, agent_id, p.input, p.config);
+    return run;
+  });
+
+  router.handle('run.stream.get', async (p) => getRunOrThrow(need(p, 'id')));
+
+  router.handle('thread.new', async (p) => queries.createThread(p.metadata || {}));
+  router.handle('thread.search', async (p) => queries.searchThreads(p));
+  router.handle('thread.get', async (p) => getThreadOrThrow(need(p, 'id')));
+
+  router.handle('thread.upd', async (p) => {
+    try { return queries.patchThread(need(p, 'id'), p); } catch (e) {
+      if (e.message.includes('not found')) err(404, e.message);
+      throw e;
+    }
+  });
+
+  router.handle('thread.del', async (p) => {
+    try { queries.deleteThread(need(p, 'id')); return { deleted: true }; } catch (e) {
+      if (e.message.includes('not found')) err(404, e.message);
+      if (e.message.includes('pending runs')) err(409, e.message);
+      throw e;
+    }
+  });
+
+  router.handle('thread.history', async (p) => {
+    const id = need(p, 'id'), limit = p.limit || 50, offset = p.before ? parseInt(p.before, 10) : 0;
+    const result = queries.getThreadHistory(id, limit, offset);
+    return { states: result.states, next_cursor: result.hasMore ? String(offset + limit) : null };
+  });
+
+  router.handle('thread.copy', async (p) => {
+    try {
+      const nt = queries.copyThread(need(p, 'id'));
+      return p.metadata ? queries.patchThread(nt.thread_id, { metadata: p.metadata }) : nt;
+    } catch (e) {
+      if (e.message.includes('not found')) err(404, e.message);
+      throw e;
+    }
+  });
+
+  router.handle('thread.run.stream', async (p) => {
+    const threadId = need(p, 'id'), agent_id = need(p, 'agent_id');
+    const thread = getThreadOrThrow(threadId);
+    if (thread.status !== 'idle') err(409, 'Thread has pending runs');
+    findAgent(agent_id);
+    const run = queries.createRun(agent_id, threadId, p.input, p.config);
+    startExecution(run.run_id, threadId, agent_id, p.input, p.config);
+    return run;
+  });
+
+  router.handle('thread.run.cancel', async (p) => {
+    const threadId = need(p, 'id'), runId = need(p, 'runId'), run = getRunOrThrow(runId);
+    if (run.thread_id !== threadId) err(400, 'Run does not belong to specified thread');
+    if (['success', 'error', 'cancelled'].includes(run.status)) err(409, 'Run already completed or cancelled');
+    const cancelled = queries.cancelRun(runId);
+    const ex = killExecution(threadId, runId);
+    broadcastSync({ type: 'run_cancelled', runId, threadId, sessionId: ex?.sessionId, timestamp: Date.now() });
+    return cancelled;
+  });
+
+  router.handle('thread.run.stream.get', async (p) => {
+    const threadId = need(p, 'id'), runId = need(p, 'runId');
+    getThreadOrThrow(threadId);
+    const run = queries.getRun(runId);
+    if (!run || run.thread_id !== threadId) err(404, 'Run not found on thread');
+    return run;
+  });
+}
+
+export { register };

package/lib/ws-handlers-session.js

@@ -0,0 +1,165 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execSync, spawn } from 'child_process';
+
+function spawnScript(cmd, args, convId, scriptName, agentId, deps) {
+  const { activeScripts, broadcastSync, modelCache } = deps;
+  if (activeScripts.has(convId)) throw { code: 409, message: 'Process already running' };
+  const child = spawn(cmd, args, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env, FORCE_COLOR: '1' },
+    shell: os.platform() === 'win32'
+  });
+  activeScripts.set(convId, { process: child, script: scriptName, startTime: Date.now() });
+  broadcastSync({ type: 'script_started', conversationId: convId, script: scriptName, agentId, timestamp: Date.now() });
+  const relay = (stream) => (chunk) => {
+    broadcastSync({ type: 'script_output', conversationId: convId, data: chunk.toString(), stream, timestamp: Date.now() });
+  };
+  child.stdout.on('data', relay('stdout'));
+  child.stderr.on('data', relay('stderr'));
+  child.on('error', (err) => {
+    activeScripts.delete(convId);
+    broadcastSync({ type: 'script_stopped', conversationId: convId, code: 1, error: err.message, timestamp: Date.now() });
+  });
+  child.on('close', (code) => {
+    activeScripts.delete(convId);
+    if (modelCache && agentId) modelCache.delete(agentId);
+    broadcastSync({ type: 'script_stopped', conversationId: convId, code: code || 0, timestamp: Date.now() });
+  });
+  return child.pid;
+}
+
+function readJson(filePath) {
+  try { return fs.existsSync(filePath) ? JSON.parse(fs.readFileSync(filePath, 'utf-8')) : null; } catch { return null; }
+}
+
+function checkAgentAuth(agent) {
+  const s = { id: agent.id, name: agent.name, authenticated: false, detail: '' };
+  try {
+    if (agent.id === 'claude-code') {
+      const creds = readJson(path.join(os.homedir(), '.claude', '.credentials.json'));
+      if (creds?.claudeAiOauth?.expiresAt > Date.now()) {
+        s.authenticated = true;
+        s.detail = creds.claudeAiOauth.subscriptionType || 'authenticated';
+      } else { s.detail = creds ? 'expired' : 'no credentials'; }
+    } else if (agent.id === 'gemini') {
+      const oauth = readJson(path.join(os.homedir(), '.gemini', 'oauth_creds.json'));
+      const accts = readJson(path.join(os.homedir(), '.gemini', 'google_accounts.json'));
+      const hasOAuth = !!(oauth?.refresh_token || oauth?.access_token);
+      if (accts?.active) { s.authenticated = true; s.detail = accts.active; }
+      else if (hasOAuth) { s.authenticated = true; s.detail = 'oauth'; }
+      else { s.detail = accts ? 'logged out' : 'no credentials'; }
+    } else if (agent.id === 'opencode') {
+      const out = execSync('opencode auth list 2>&1', { encoding: 'utf-8', timeout: 5000 });
+      const m = out.match(/(\d+)\s+credentials?/);
+      if (m && parseInt(m[1], 10) > 0) { s.authenticated = true; s.detail = m[1] + ' credential(s)'; }
+      else { s.detail = 'no credentials'; }
+    } else { s.detail = 'unknown'; }
+  } catch { s.detail = 'check failed'; }
+  return s;
+}
+
+export function register(router, deps) {
+  const { db, discoveredAgents, getModelsForAgent, modelCache,
+    getAgentDescriptor, activeScripts, broadcastSync, startGeminiOAuth,
+    geminiOAuthState } = deps;
+
+  router.handle('sess.get', (p) => {
+    const sess = db.getSession(p.id);
+    if (!sess) throw { code: 404, message: 'Not found' };
+    return { session: sess, events: db.getSessionEvents(p.id) };
+  });
+
+  router.handle('sess.latest', (p) => {
+    const s = db.getLatestSession(p.id);
+    if (!s) return { session: null };
+    return { session: s, events: db.getSessionEvents(s.id) };
+  });
+
+  router.handle('sess.chunks', (p) => {
+    if (!db.getSession(p.id)) throw { code: 404, message: 'Session not found' };
+    const sinceSeq = parseInt(p.sinceSeq ?? '-1');
+    const since = parseInt(p.since ?? '0');
+    const chunks = sinceSeq >= 0 ? db.getChunksSinceSeq(p.id, sinceSeq) : db.getChunksSince(p.id, since);
+    return { ok: true, chunks };
+  });
+
+  router.handle('sess.exec', (p) => {
+    const limit = Math.min(parseInt(p.limit || '1000'), 5000);
+    const offset = Math.max(parseInt(p.offset || '0'), 0);
+    const filterType = p.filterType || null;
+    const data = {
+      sessionId: p.id, events: [], total: 0, limit, offset, hasMore: false,
+      metadata: { status: 'pending', startTime: Date.now(), duration: 0, eventCount: 0 }
+    };
+    if (filterType) data.events = data.events.filter(e => e.type === filterType);
+    return data;
+  });
+
+  router.handle('agent.ls', () => ({ agents: discoveredAgents }));
+
+  router.handle('agent.get', (p) => {
+    const a = discoveredAgents.find(x => x.id === p.id);
+    if (!a) throw { code: 404, message: 'Agent not found' };
+    return { id: a.id, name: a.name, description: a.description || '', icon: a.icon || null, status: 'available' };
+  });
+
+  router.handle('agent.desc', (p) => {
+    const d = getAgentDescriptor(p.id);
+    if (!d) throw { code: 404, message: 'Agent not found' };
+    return d;
+  });
+
+  router.handle('agent.models', async (p) => {
+    const cached = modelCache.get(p.id);
+    if (cached && (Date.now() - cached.ts) < 300000) return { models: cached.models };
+    try {
+      const models = await getModelsForAgent(p.id);
+      modelCache.set(p.id, { models, ts: Date.now() });
+      return { models };
+    } catch { return { models: [] }; }
+  });
+
+  router.handle('agent.search', (p) => db.searchAgents(discoveredAgents, p.query || p));
+
+  router.handle('agent.auth', async (p) => {
+    const agentId = p.id;
+    if (!discoveredAgents.find(a => a.id === agentId)) throw { code: 404, message: 'Agent not found' };
+    if (agentId === 'gemini') {
+      const result = await startGeminiOAuth();
+      const cid = '__agent_auth__';
+      broadcastSync({ type: 'script_started', conversationId: cid, script: 'auth-gemini', agentId: 'gemini', timestamp: Date.now() });
+      broadcastSync({ type: 'script_output', conversationId: cid, data: `\x1b[36mOpening Google OAuth...\x1b[0m\r\n\r\nVisit:\r\n${result.authUrl}\r\n`, stream: 'stdout', timestamp: Date.now() });
+      const pollId = setInterval(() => {
+        const st = geminiOAuthState();
+        if (st.status === 'success') {
+          clearInterval(pollId);
+          broadcastSync({ type: 'script_output', conversationId: cid, data: `\r\n\x1b[32mAuth OK${st.email ? ' (' + st.email + ')' : ''}\x1b[0m\r\n`, stream: 'stdout', timestamp: Date.now() });
+          broadcastSync({ type: 'script_stopped', conversationId: cid, code: 0, timestamp: Date.now() });
+        } else if (st.status === 'error') {
+          clearInterval(pollId);
+          broadcastSync({ type: 'script_output', conversationId: cid, data: `\r\n\x1b[31mAuth failed: ${st.error}\x1b[0m\r\n`, stream: 'stderr', timestamp: Date.now() });
+          broadcastSync({ type: 'script_stopped', conversationId: cid, code: 1, error: st.error, timestamp: Date.now() });
+        }
+      }, 1000);
+      setTimeout(() => clearInterval(pollId), 5 * 60 * 1000);
+      return { ok: true, agentId, authUrl: result.authUrl, mode: result.mode };
+    }
+    const cmds = { 'claude-code': { cmd: 'claude', args: ['setup-token'] }, 'opencode': { cmd: 'opencode', args: ['auth', 'login'] } };
+    const c = cmds[agentId];
+    if (!c) throw { code: 400, message: 'No auth command for this agent' };
+    const pid = spawnScript(c.cmd, c.args, '__agent_auth__', 'auth-' + agentId, agentId, { activeScripts, broadcastSync });
+    return { ok: true, agentId, pid };
+  });
+
+  router.handle('agent.authstat', () => ({ agents: discoveredAgents.map(checkAgentAuth) }));
+
+  router.handle('agent.update', (p) => {
+    const cmds = { 'claude-code': { cmd: 'claude', args: ['update', '--yes'] } };
+    const c = cmds[p.id];
+    if (!c) throw { code: 400, message: 'No update command for this agent' };
+    const pid = spawnScript(c.cmd, c.args, '__agent_update__', 'update-' + p.id, p.id, { activeScripts, broadcastSync, modelCache });
+    return { ok: true, agentId: p.id, pid };
+  });
+}