agentgui 1.0.831 → 1.0.833

package/lib/plugins/agents-plugin.js

@@ -1,7 +1,4 @@
-// Agents plugin - agent discovery, runner spawning, process management
-
 import path from 'path';
-import { runClaudeWithStreaming } from '../claude-runner.js';
 
 export default {
   name: 'agents',

package/lib/speech-manager.js

@@ -2,7 +2,6 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { createRequire } from 'module';
-
 let speechModule = null;
 let _broadcastSync = null;
 let _syncClients = null;
@@ -13,18 +12,15 @@ export function initSpeechManager({ broadcastSync, syncClients, queries }) {
   _syncClients = syncClients;
   _queries = queries;
 }
-
 export async function ensurePocketTtsSetup(onProgress) {
   const r = createRequire(import.meta.url);
   const serverTTS = r('webtalk/server-tts');
   return serverTTS.ensureInstalled(onProgress);
 }
-
 export async function getSpeech() {
   if (!speechModule) speechModule = await import('./speech.js');
   return speechModule;
 }
-
 const ttsTextAccumulators = new Map();
 
 export const voiceCacheManager = {
@@ -58,7 +54,6 @@ export const voiceCacheManager = {
     }
   }
 };
-
 export const modelDownloadState = {
   downloading: false,
   progress: null,
@@ -68,7 +63,6 @@ export const modelDownloadState = {
   downloadMetrics: new Map(),
   waiters: []
 };
-
 export function broadcastModelProgress(progress) {
   modelDownloadState.progress = progress;
   const broadcastData = {
@@ -203,4 +197,4 @@ function pushTTSAudio(cacheKey, wav, conversationId, sessionId, voiceId) {
     sessionId,
     timestamp: Date.now()
   });
-}
+}

package/lib/ws-handlers-conv.js

@@ -14,7 +14,6 @@ function validate(schema, params) {
 
 const ConvNewSchema = z.object({ agentId: z.string().optional(), title: z.string().optional(), workingDirectory: z.string().optional(), model: z.string().optional(), subAgent: z.string().optional() }).passthrough();
 const ConvUpdSchema = z.object({ id: z.string().min(1, 'id required') }).passthrough();
-const ConvSteerSchema = z.object({ id: z.string().min(1, 'conversation id required'), content: z.union([z.string(), z.record(z.any())]).refine(v => v !== undefined && v !== null && v !== '', { message: 'content required' }) }).passthrough();
 
 export function register(router, deps) {
   const { queries, activeExecutions, rateLimitState,
@@ -72,7 +71,6 @@ export function register(router, deps) {
   });
 
   router.handle('conv.del.all', (p) => {
-    // Clean up all execution machine actors
     const convs = queries.getConversationsList();
     for (const c of convs) { cleanupExecution(c.id); execMachine.remove(c.id); }
     if (!queries.deleteAllConversations()) fail(500, 'Failed to delete all conversations');
@@ -137,146 +135,4 @@ export function register(router, deps) {
     }
     return { ok: true };
   });
-
-  router.handle('conv.export', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound();
-    const msgs = queries.getConversationMessages(p.id);
-    const format = p.format || 'markdown';
-    if (format === 'json') return { conversation: conv, messages: msgs };
-    let md = `# ${conv.title || 'Conversation'}\n\n`;
-    md += `Agent: ${conv.agentType || 'unknown'} | Created: ${new Date(conv.created_at).toISOString()}\n\n---\n\n`;
-    for (const m of msgs) {
-      const role = m.role === 'user' ? 'User' : 'Assistant';
-      md += `## ${role}\n\n`;
-      let content = m.content;
-      try { const parsed = JSON.parse(content); if (Array.isArray(parsed)) { content = parsed.map(b => b.text || b.content || JSON.stringify(b)).join('\n'); } } catch {}
-      md += content + '\n\n---\n\n';
-    }
-    return { markdown: md, title: conv.title };
-  });
-
-  router.handle('conv.import', (p) => {
-    if (!p.conversation || !p.messages) throw Object.assign(new Error('Missing conversation or messages'), { code: 400 });
-    const src = p.conversation;
-    const conv = queries.createConversation(
-      src.agentId || src.agentType || 'claude-code',
-      src.title || 'Imported Conversation',
-      src.workingDirectory || null,
-      src.model || null
-    );
-    for (const msg of p.messages) {
-      queries.createMessage(conv.id, msg.role || 'user', msg.content || '');
-    }
-    broadcastSync({ type: 'conversation_created', conversation: queries.getConversation(conv.id) });
-    return { conversation: queries.getConversation(conv.id), importedMessages: p.messages.length };
-  });
-
-  router.handle('conv.sync', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound();
-    const machineSnap = execMachine.snapshot(p.id);
-    const executionState = machineSnap?.value || 'idle';
-    const latestSession = queries.getLatestSession(p.id);
-    const sinceSeq = parseInt(p.sinceSeq || '-1');
-    const since = parseInt(p.since || '0');
-    let missedChunks = [];
-    if (latestSession && sinceSeq >= 0) {
-      missedChunks = queries.getChunksSinceSeq(latestSession.id, sinceSeq);
-    } else if (latestSession && since > 0) {
-      missedChunks = queries.getConversationChunksSince(p.id, since);
-    }
-    return {
-      conversation: conv,
-      executionState,
-      isActivelyStreaming: execMachine.isActive(p.id),
-      latestSession,
-      missedChunks,
-      missedCount: missedChunks.length,
-      queueLength: machineSnap?.context?.queue?.length || 0
-    };
-  });
-
-  router.handle('conv.search', (p) => {
-    if (!p.query || typeof p.query !== 'string' || p.query.trim().length < 2) return { results: [] };
-    const limit = Math.min(parseInt(p.limit || '50'), 200);
-    return { results: queries.searchMessages(p.query.trim(), limit) };
-  });
-
-  router.handle('conv.prune', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound();
-    const keep = Math.max(parseInt(p.keep || '500'), 100);
-    const sessions = queries.getConversationSessions(p.id);
-    if (!sessions || sessions.length === 0) return { pruned: 0 };
-    const latestSessionId = sessions[0]?.id;
-    let pruned = 0;
-    for (const sess of sessions) {
-      if (sess.id === latestSessionId) continue;
-      const count = queries.getSessionChunks(sess.id)?.length || 0;
-      if (count > 0) { queries.deleteSessionChunks(sess.id); pruned += count; }
-    }
-    return { pruned, kept: latestSessionId, sessionsProcessed: sessions.length };
-  });
-
-  router.handle('conv.cancel', (p) => {
-    if (!execMachine.isActive(p.id)) notFound('No active execution to cancel');
-    const ctx = execMachine.getContext(p.id);
-    const pid = ctx?.pid || activeExecutions.get(p.id)?.pid;
-    const sessionId = ctx?.sessionId || activeExecutions.get(p.id)?.sessionId;
-    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() });
-    cleanupExecution(p.id, false);
-    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 message = queries.createMessage(p.id, 'user', '[INJECTED] ' + p.content);
-    if (!execMachine.isActive(p.id)) {
-      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, conv.subAgent || null);
-    }
-    return { ok: true, injected: true, conversationId: p.id, messageId: message.id };
-  });
-
-  router.handle('conv.steer', (p) => {
-    p = validate(ConvSteerSchema, p);
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound('Conversation not found');
-
-    if (!execMachine.isActive(p.id)) fail(409, 'No active execution to steer');
-
-    const ctx = execMachine.getContext(p.id);
-    const pid = ctx?.pid || activeExecutions.get(p.id)?.pid;
-    const sessionId = ctx?.sessionId || activeExecutions.get(p.id)?.sessionId;
-
-    if (pid) {
-      try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch (e) {} }
-    }
-
-    if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
-    cleanupExecution(p.id);
-
-    // Clear claudeSessionId so new execution starts fresh without --resume on a killed session
-    queries.setClaudeSessionId(p.id, null);
-
-    broadcastSync({ type: 'streaming_complete', sessionId, conversationId: p.id, interrupted: true, timestamp: Date.now() });
-
-    const agentId = conv.agentType || conv.agentId || 'claude-code';
-    const model = conv.model || null;
-    const subAgent = conv.subAgent || null;
-    const steerContent = typeof p.content === 'string' ? p.content : (p.content ? JSON.stringify(p.content) : '');
-    const message = queries.createMessage(p.id, 'user', steerContent);
-    queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
-    broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
-    startExecution(p.id, message, agentId, model, steerContent, subAgent);
-
-    return { ok: true, steered: true, conversationId: p.id, messageId: message.id };
-  });
-
 }

package/lib/ws-handlers-conv2.js

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+import * as execMachine from './execution-machine.js';
+
+function fail(code, message) { const e = new Error(message); e.code = code; throw e; }
+function notFound(msg = 'Not found') { fail(404, msg); }
+function validate(schema, params) {
+  const result = schema.safeParse(params);
+  if (!result.success) fail(400, result.error.issues.map(i => i.message).join('; '));
+  return result.data;
+}
+
+const ConvSteerSchema = z.object({ id: z.string().min(1, 'conversation id required'), content: z.union([z.string(), z.record(z.any())]).refine(v => v !== undefined && v !== null && v !== '', { message: 'content required' }) }).passthrough();
+
+export function register(router, deps) {
+  const { queries, activeExecutions, rateLimitState,
+    broadcastSync, processMessageWithStreaming, cleanupExecution,
+    getJsonlWatcher = () => null, logError = () => {} } = deps;
+
+  function startExecution(convId, message, agentId, model, content, subAgent) {
+    const session = queries.createSession(convId);
+    queries.createEvent('session.created', { messageId: message.id, sessionId: session.id }, convId, session.id);
+    execMachine.send(convId, { type: 'START', sessionId: 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, subAgent).catch(e => logError('startExecution', e, { convId }));
+    return session;
+  }
+
+  router.handle('conv.export', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound();
+    const msgs = queries.getConversationMessages(p.id);
+    const format = p.format || 'markdown';
+    if (format === 'json') return { conversation: conv, messages: msgs };
+    let md = `# ${conv.title || 'Conversation'}\n\n`;
+    md += `Agent: ${conv.agentType || 'unknown'} | Created: ${new Date(conv.created_at).toISOString()}\n\n---\n\n`;
+    for (const m of msgs) {
+      const role = m.role === 'user' ? 'User' : 'Assistant';
+      md += `## ${role}\n\n`;
+      let content = m.content;
+      try { const parsed = JSON.parse(content); if (Array.isArray(parsed)) { content = parsed.map(b => b.text || b.content || JSON.stringify(b)).join('\n'); } } catch {}
+      md += content + '\n\n---\n\n';
+    }
+    return { markdown: md, title: conv.title };
+  });
+
+  router.handle('conv.import', (p) => {
+    if (!p.conversation || !p.messages) throw Object.assign(new Error('Missing conversation or messages'), { code: 400 });
+    const src = p.conversation;
+    const conv = queries.createConversation(
+      src.agentId || src.agentType || 'claude-code',
+      src.title || 'Imported Conversation',
+      src.workingDirectory || null,
+      src.model || null
+    );
+    for (const msg of p.messages) {
+      queries.createMessage(conv.id, msg.role || 'user', msg.content || '');
+    }
+    broadcastSync({ type: 'conversation_created', conversation: queries.getConversation(conv.id) });
+    return { conversation: queries.getConversation(conv.id), importedMessages: p.messages.length };
+  });
+
+  router.handle('conv.sync', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound();
+    const machineSnap = execMachine.snapshot(p.id);
+    const executionState = machineSnap?.value || 'idle';
+    const latestSession = queries.getLatestSession(p.id);
+    const sinceSeq = parseInt(p.sinceSeq || '-1');
+    const since = parseInt(p.since || '0');
+    let missedChunks = [];
+    if (latestSession && sinceSeq >= 0) {
+      missedChunks = queries.getChunksSinceSeq(latestSession.id, sinceSeq);
+    } else if (latestSession && since > 0) {
+      missedChunks = queries.getConversationChunksSince(p.id, since);
+    }
+    return {
+      conversation: conv,
+      executionState,
+      isActivelyStreaming: execMachine.isActive(p.id),
+      latestSession,
+      missedChunks,
+      missedCount: missedChunks.length,
+      queueLength: machineSnap?.context?.queue?.length || 0
+    };
+  });
+
+  router.handle('conv.search', (p) => {
+    if (!p.query || typeof p.query !== 'string' || p.query.trim().length < 2) return { results: [] };
+    const limit = Math.min(parseInt(p.limit || '50'), 200);
+    return { results: queries.searchMessages(p.query.trim(), limit) };
+  });
+
+  router.handle('conv.prune', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound();
+    const keep = Math.max(parseInt(p.keep || '500'), 100);
+    const sessions = queries.getConversationSessions(p.id);
+    if (!sessions || sessions.length === 0) return { pruned: 0 };
+    const latestSessionId = sessions[0]?.id;
+    let pruned = 0;
+    for (const sess of sessions) {
+      if (sess.id === latestSessionId) continue;
+      const count = queries.getSessionChunks(sess.id)?.length || 0;
+      if (count > 0) { queries.deleteSessionChunks(sess.id); pruned += count; }
+    }
+    return { pruned, kept: latestSessionId, sessionsProcessed: sessions.length };
+  });
+
+  router.handle('conv.cancel', (p) => {
+    if (!execMachine.isActive(p.id)) notFound('No active execution to cancel');
+    const ctx = execMachine.getContext(p.id);
+    const pid = ctx?.pid || activeExecutions.get(p.id)?.pid;
+    const sessionId = ctx?.sessionId || activeExecutions.get(p.id)?.sessionId;
+    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() });
+    cleanupExecution(p.id, false);
+    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 message = queries.createMessage(p.id, 'user', '[INJECTED] ' + p.content);
+    if (!execMachine.isActive(p.id)) {
+      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, conv.subAgent || null);
+    }
+    return { ok: true, injected: true, conversationId: p.id, messageId: message.id };
+  });
+
+  router.handle('conv.steer', (p) => {
+    p = validate(ConvSteerSchema, p);
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound('Conversation not found');
+
+    if (!execMachine.isActive(p.id)) fail(409, 'No active execution to steer');
+
+    const ctx = execMachine.getContext(p.id);
+    const pid = ctx?.pid || activeExecutions.get(p.id)?.pid;
+    const sessionId = ctx?.sessionId || activeExecutions.get(p.id)?.sessionId;
+
+    if (pid) {
+      try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch (e) {} }
+    }
+
+    if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
+    cleanupExecution(p.id);
+
+    queries.setClaudeSessionId(p.id, null);
+
+    broadcastSync({ type: 'streaming_complete', sessionId, conversationId: p.id, interrupted: true, timestamp: Date.now() });
+
+    const agentId = conv.agentType || conv.agentId || 'claude-code';
+    const model = conv.model || null;
+    const subAgent = conv.subAgent || null;
+    const steerContent = typeof p.content === 'string' ? p.content : (p.content ? JSON.stringify(p.content) : '');
+    const message = queries.createMessage(p.id, 'user', steerContent);
+    queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
+    broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
+    startExecution(p.id, message, agentId, model, steerContent, subAgent);
+
+    return { ok: true, steered: true, conversationId: p.id, messageId: message.id };
+  });
+}

package/lib/ws-handlers-session.js

@@ -1,79 +1,7 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { execSync, spawn } from 'child_process';
-import { ensureRunning, touch, queryModels } from './acp-sdk-manager.js';
-
-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;
-}
-
-async function acpFetch(port, pth, body = null) {
-  const opts = { headers: { 'Content-Type': 'application/json' }, signal: AbortSignal.timeout(3000) };
-  if (body !== null) { opts.method = 'POST'; opts.body = JSON.stringify(body); }
-  const res = await fetch(`http://localhost:${port}${pth}`, opts);
-  if (!res.ok) return null;
-  return res.json();
-}
-
+import { queryModels } from './acp-sdk-manager.js';
 
 export function register(router, deps) {
-  const { db, discoveredAgents, modelCache,
-    getAgentDescriptor, activeScripts, broadcastSync, startGeminiOAuth,
-    geminiOAuthState } = deps;
+  const { db, discoveredAgents, modelCache, getAgentDescriptor } = deps;
   console.log('[ws-handlers-session] register() called with discoveredAgents.length:', discoveredAgents.length);
 
   router.handle('sess.get', (p) => {
@@ -129,8 +57,6 @@ export function register(router, deps) {
       }))
     };
   });
-  // Note: agent.subagents is handled by ws-handlers-util.js which is registered after this file
-  // Keeping this note to avoid duplicate handler registration
 
   router.handle('agent.get', (p) => {
     const a = discoveredAgents.find(x => x.id === p.id);
@@ -165,44 +91,4 @@ export function register(router, deps) {
   });
 
   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 };
-  });
-}
+}

package/lib/ws-handlers-session2.js

@@ -0,0 +1,106 @@
+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 { discoveredAgents, modelCache, activeScripts, broadcastSync,
+    startGeminiOAuth, geminiOAuthState } = deps;
+
+  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 };
+  });
+}

package/package.json

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