agentgui 1.0.715 → 1.0.717

package/lib/ws-handlers-msg.js

@@ -0,0 +1,119 @@
+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 MsgStreamSchema = z.object({
+  id: z.string().min(1, 'conversation id required'),
+  content: z.union([z.string(), z.any()]).optional(),
+  message: z.union([z.string(), z.any()]).optional(),
+  agentId: z.string().optional(),
+  model: z.string().optional(),
+  subAgent: z.string().optional(),
+}).passthrough();
+
+export function register(router, deps) {
+  const { queries, activeExecutions, messageQueues,
+    broadcastSync, processMessageWithStreaming, logError = () => {} } = deps;
+
+  const queueSeqByConv = new Map();
+  function getNextQueueSeq(conversationId) {
+    const current = queueSeqByConv.get(conversationId) || 0;
+    const next = current + 1;
+    queueSeqByConv.set(conversationId, next);
+    return next;
+  }
+
+  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;
+  }
+
+  function enqueue(convId, content, agentId, model, messageId, subAgent) {
+    const item = { content, agentId, model, messageId, subAgent };
+    execMachine.send(convId, { type: 'ENQUEUE', item });
+    if (!messageQueues.has(convId)) messageQueues.set(convId, []);
+    messageQueues.get(convId).push(item);
+    const queueLength = execMachine.getQueue(convId).length;
+    broadcastSync({ type: 'queue_status', conversationId: convId, queueLength, messageId, timestamp: Date.now() });
+    return queueLength;
+  }
+
+  function normalizeContent(rawContent, method) {
+    if (rawContent !== undefined && typeof rawContent !== 'string') {
+      console.warn(`[ws-validation] ${method} content is ${typeof rawContent}: ${JSON.stringify(rawContent).slice(0, 200)}`);
+      logError('ws-content-type', new TypeError(`non-string content in ${method}`), { method, type: typeof rawContent });
+    }
+    return typeof rawContent === 'string' ? rawContent : (rawContent ? JSON.stringify(rawContent) : '');
+  }
+
+  router.handle('msg.ls', (p) => {
+    return queries.getPaginatedMessages(p.id, Math.min(p.limit || 50, 100), Math.max(p.offset || 0, 0));
+  });
+
+  router.handle('msg.ls.earlier', (p) => {
+    if (!p.id) fail(400, 'Missing conversation id');
+    if (!p.before) fail(400, 'Missing before messageId parameter');
+    const limit = Math.min(p.limit || 50, 100);
+    const result = queries.getMessagesBefore(p.id, p.before, limit);
+    return { ok: true, messages: result.messages, total: result.total, hasMore: result.hasMore, limit: result.limit };
+  });
+
+  router.handle('msg.get', (p) => {
+    const msg = queries.getMessage(p.messageId);
+    if (!msg || msg.conversationId !== p.id) notFound();
+    return { message: msg };
+  });
+
+  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 subAgent = p.subAgent || conv.subAgent || null;
+    const idempotencyKey = p.idempotencyKey || null;
+    p.content = normalizeContent(p.content, 'msg.send');
+    const message = queries.createMessage(p.id, 'user', p.content, idempotencyKey);
+    queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
+    if (!execMachine.isActive(p.id)) {
+      broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
+      const session = startExecution(p.id, message, agentId, model, p.content, subAgent);
+      return { message, session, idempotencyKey };
+    }
+    const qp = enqueue(p.id, p.content, agentId, model, message.id, subAgent);
+    return { message, queued: true, queuePosition: qp, idempotencyKey };
+  });
+
+  router.handle('msg.stream', (p) => {
+    p = validate(MsgStreamSchema, p);
+    const conv = queries.getConversation(p.id);
+    if (!conv) notFound('Conversation not found');
+    const prompt = normalizeContent(p.content || p.message, 'msg.stream');
+    const agentId = p.agentId || conv.agentType || conv.agentId || 'claude-code';
+    const model = p.model || conv.model || null;
+    const subAgent = p.subAgent || conv.subAgent || null;
+    const userMessage = queries.createMessage(p.id, 'user', prompt);
+    queries.createEvent('message.created', { role: 'user', messageId: userMessage.id }, p.id);
+    if (!execMachine.isActive(p.id)) {
+      broadcastSync({ type: 'message_created', conversationId: p.id, message: userMessage, timestamp: Date.now() });
+      const session = startExecution(p.id, userMessage, agentId, model, prompt, subAgent);
+      return { message: userMessage, session, streamId: session.id };
+    }
+    const qp = enqueue(p.id, prompt, agentId, model, userMessage.id, subAgent);
+    const seq = getNextQueueSeq(p.id);
+    broadcastSync({ type: 'queue_status', conversationId: p.id, queueLength: execMachine.getQueue(p.id).length, seq, timestamp: Date.now() });
+    return { message: userMessage, queued: true, queuePosition: qp };
+  });
+}

package/lib/ws-handlers-oauth.js

@@ -0,0 +1,76 @@
+function err(code, message) { const e = new Error(message); e.code = code; throw e; }
+
+export function register(router, deps) {
+  const { startGeminiOAuth, exchangeGeminiOAuthCode, geminiOAuthState,
+    startCodexOAuth, exchangeCodexOAuthCode, codexOAuthState } = deps;
+
+  router.handle('gemini.start', async () => {
+    try {
+      const result = await startGeminiOAuth();
+      return { authUrl: result.authUrl, mode: result.mode };
+    } catch (e) { err(500, e.message); }
+  });
+
+  router.handle('gemini.status', () => {
+    return typeof geminiOAuthState === 'function' ? geminiOAuthState() : geminiOAuthState;
+  });
+
+  router.handle('gemini.relay', async (p) => {
+    const { code, state } = p;
+    if (!code || !state) err(400, 'Missing code or state');
+    try {
+      const email = await exchangeGeminiOAuthCode(code, state);
+      return { success: true, email };
+    } catch (e) { err(400, e.message); }
+  });
+
+  router.handle('gemini.complete', async (p) => {
+    const pastedUrl = (p.url || '').trim();
+    if (!pastedUrl) err(400, 'No URL provided');
+    let parsed;
+    try { parsed = new URL(pastedUrl); } catch { err(400, 'Invalid URL. Paste the full URL from the browser address bar.'); }
+    const urlError = parsed.searchParams.get('error');
+    if (urlError) return { error: parsed.searchParams.get('error_description') || urlError };
+    const code = parsed.searchParams.get('code');
+    const state = parsed.searchParams.get('state');
+    try {
+      const email = await exchangeGeminiOAuthCode(code, state);
+      return { success: true, email };
+    } catch (e) { err(400, e.message); }
+  });
+
+  router.handle('codex.start', async () => {
+    try {
+      const result = await startCodexOAuth();
+      return { authUrl: result.authUrl, mode: result.mode };
+    } catch (e) { err(500, e.message); }
+  });
+
+  router.handle('codex.status', () => {
+    return typeof codexOAuthState === 'function' ? codexOAuthState() : codexOAuthState;
+  });
+
+  router.handle('codex.relay', async (p) => {
+    const { code, state } = p;
+    if (!code || !state) err(400, 'Missing code or state');
+    try {
+      const email = await exchangeCodexOAuthCode(code, state);
+      return { success: true, email };
+    } catch (e) { err(400, e.message); }
+  });
+
+  router.handle('codex.complete', async (p) => {
+    const pastedUrl = (p.url || '').trim();
+    if (!pastedUrl) err(400, 'No URL provided');
+    let parsed;
+    try { parsed = new URL(pastedUrl); } catch { err(400, 'Invalid URL. Paste the full URL from the browser address bar.'); }
+    const urlError = parsed.searchParams.get('error');
+    if (urlError) return { error: parsed.searchParams.get('error_description') || urlError };
+    const code = parsed.searchParams.get('code');
+    const state = parsed.searchParams.get('state');
+    try {
+      const email = await exchangeCodexOAuthCode(code, state);
+      return { success: true, email };
+    } catch (e) { err(400, e.message); }
+  });
+}

package/lib/ws-handlers-queue.js

@@ -0,0 +1,56 @@
+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); }
+
+export function register(router, deps) {
+  const { queries, messageQueues, broadcastSync } = deps;
+
+  const queueSeqByConv = new Map();
+  function getNextQueueSeq(conversationId) {
+    const current = queueSeqByConv.get(conversationId) || 0;
+    const next = current + 1;
+    queueSeqByConv.set(conversationId, next);
+    return next;
+  }
+
+  router.handle('q.ls', (p) => {
+    if (!queries.getConversation(p.id)) notFound('Conversation not found');
+    const machineQueue = execMachine.getQueue(p.id);
+    return { queue: machineQueue.length > 0 ? machineQueue : (messageQueues.get(p.id) || []) };
+  });
+
+  router.handle('q.del', (p) => {
+    const machineQueue = execMachine.getQueue(p.id);
+    const mapQueue = messageQueues.get(p.id);
+    if (!machineQueue.length && !mapQueue) notFound('Queue not found');
+    const idx = machineQueue.findIndex(q => q.messageId === p.messageId);
+    if (idx === -1 && (!mapQueue || mapQueue.findIndex(q => q.messageId === p.messageId) === -1)) notFound('Queued message not found');
+    if (idx !== -1) {
+      const newQueue = [...machineQueue];
+      newQueue.splice(idx, 1);
+      execMachine.send(p.id, { type: 'SET_QUEUE', queue: newQueue });
+    }
+    if (mapQueue) {
+      const mi = mapQueue.findIndex(q => q.messageId === p.messageId);
+      if (mi !== -1) mapQueue.splice(mi, 1);
+      if (mapQueue.length === 0) messageQueues.delete(p.id);
+    }
+    const seq = getNextQueueSeq(p.id);
+    broadcastSync({ type: 'queue_status', conversationId: p.id, queueLength: execMachine.getQueue(p.id).length, seq, timestamp: Date.now() });
+    return { deleted: true };
+  });
+
+  router.handle('q.upd', (p) => {
+    const machineQueue = execMachine.getQueue(p.id);
+    const mapQueue = messageQueues.get(p.id);
+    if (!machineQueue.length && !mapQueue) notFound('Queue not found');
+    const item = machineQueue.find(q => q.messageId === p.messageId) || mapQueue?.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;
+    const seq = getNextQueueSeq(p.id);
+    broadcastSync({ type: 'queue_updated', conversationId: p.id, messageId: p.messageId, content: item.content, agentId: item.agentId, seq, timestamp: Date.now() });
+    return { updated: true, item };
+  });
+}

package/lib/ws-handlers-scripts.js

@@ -0,0 +1,58 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { spawn } from 'child_process';
+
+function err(code, message) { const e = new Error(message); e.code = code; throw e; }
+
+export function register(router, deps) {
+  const { queries, broadcastSync, STARTUP_CWD, activeScripts } = deps;
+
+  router.handle('conv.scripts', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) err(404, 'Not found');
+    const wd = conv.workingDirectory || STARTUP_CWD;
+    let hasStart = false, hasDev = false;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
+      const scripts = pkg.scripts || {};
+      hasStart = !!scripts.start;
+      hasDev = !!scripts.dev;
+    } catch {}
+    const running = activeScripts.has(p.id);
+    const runningScript = running ? activeScripts.get(p.id).script : null;
+    return { hasStart, hasDev, running, runningScript };
+  });
+
+  router.handle('conv.run-script', (p) => {
+    const conv = queries.getConversation(p.id);
+    if (!conv) err(404, 'Not found');
+    if (activeScripts.has(p.id)) err(409, 'Script already running');
+    const script = p.script;
+    if (script !== 'start' && script !== 'dev') err(400, 'Invalid script');
+    const wd = conv.workingDirectory || STARTUP_CWD;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
+      if (!pkg.scripts || !pkg.scripts[script]) err(400, `Script "${script}" not found`);
+    } catch (e) { if (e.code) throw e; err(400, 'No package.json'); }
+    const childEnv = { ...process.env, FORCE_COLOR: '1' };
+    delete childEnv.PORT; delete childEnv.BASE_URL; delete childEnv.HOT_RELOAD;
+    const isWindows = os.platform() === 'win32';
+    const child = spawn('npm', ['run', script], { cwd: wd, stdio: ['ignore', 'pipe', 'pipe'], detached: true, env: childEnv, shell: isWindows });
+    activeScripts.set(p.id, { process: child, script, startTime: Date.now() });
+    broadcastSync({ type: 'script_started', conversationId: p.id, script, timestamp: Date.now() });
+    const onData = (stream) => (chunk) => broadcastSync({ type: 'script_output', conversationId: p.id, data: chunk.toString(), stream, timestamp: Date.now() });
+    child.stdout.on('data', onData('stdout'));
+    child.stderr.on('data', onData('stderr'));
+    child.on('error', (e) => { activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: 1, error: e.message, timestamp: Date.now() }); });
+    child.on('close', (code) => { activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: code || 0, timestamp: Date.now() }); });
+    return { ok: true, script, pid: child.pid };
+  });
+
+  router.handle('conv.stop-script', (p) => {
+    const entry = activeScripts.get(p.id);
+    if (!entry) err(404, 'No running script');
+    try { process.kill(-entry.process.pid, 'SIGTERM'); } catch { try { entry.process.kill('SIGTERM'); } catch {} }
+    return { ok: true };
+  });
+}

package/lib/ws-handlers-util.js

@@ -1,33 +1,23 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { execSync, spawn, spawnSync } from 'child_process';
+import { execSync, spawnSync } from 'child_process';
 
 function err(code, message) { const e = new Error(message); e.code = code; throw e; }
 
 export function register(router, deps) {
   const { queries, wsOptimizer, modelDownloadState, ensureModelsDownloaded,
     broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig,
-    startGeminiOAuth, exchangeGeminiOAuthCode, geminiOAuthState,
-    startCodexOAuth, exchangeCodexOAuthCode, codexOAuthState,
-    STARTUP_CWD, activeScripts, voiceCacheManager, toolManager, discoveredAgents } = deps;
+    STARTUP_CWD, voiceCacheManager, toolManager, discoveredAgents } = deps;
 
   router.handle('home', () => ({ home: os.homedir(), cwd: STARTUP_CWD }));
 
-  // NOTE: agent.ls is handled by ws-handlers-session.js to ensure proper agent mapping
-  // Do not re-register here as it will override the session handler
-
   router.handle('folders', (p) => {
     const folderPath = p.path || STARTUP_CWD;
     try {
       const raw = folderPath.startsWith('~') ? folderPath.replace('~', os.homedir()) : folderPath;
-      const expanded = path.resolve(raw);
-      const entries = fs.readdirSync(expanded, { withFileTypes: true });
-      const folders = entries
-        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-        .map(e => ({ name: e.name }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-      return { folders };
+      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); }
   });
 
@@ -80,25 +70,13 @@ export function register(router, deps) {
   });
 
   router.handle('speech.status', async () => {
+    const modelState = { modelsDownloading: modelDownloadState.downloading, modelsComplete: modelDownloadState.complete, modelsError: modelDownloadState.error };
     try {
       const { getStatus } = await getSpeech();
       const base = getStatus();
-      return {
-        ...base,
-        setupMessage: base.ttsReady ? 'pocket-tts ready' : 'Will setup on first TTS request',
-        modelsDownloading: modelDownloadState.downloading,
-        modelsComplete: modelDownloadState.complete,
-        modelsError: modelDownloadState.error,
-        modelsProgress: modelDownloadState.progress,
-      };
+      return { ...base, setupMessage: base.ttsReady ? 'pocket-tts ready' : 'Will setup on first TTS request', ...modelState, modelsProgress: modelDownloadState.progress };
     } catch {
-      return {
-        sttReady: false, ttsReady: false, sttLoading: false, ttsLoading: false,
-        setupMessage: 'Will setup on first TTS request',
-        modelsDownloading: modelDownloadState.downloading,
-        modelsComplete: modelDownloadState.complete,
-        modelsError: modelDownloadState.error,
-      };
+      return { sttReady: false, ttsReady: false, sttLoading: false, ttsLoading: false, setupMessage: 'Will setup on first TTS request', ...modelState };
     }
   });
 
@@ -137,134 +115,8 @@ export function register(router, deps) {
 
   router.handle('discover.claude', () => ({ discovered: queries.discoverClaudeCodeConversations() }));
 
-  router.handle('gemini.start', async () => {
-    try {
-      const result = await startGeminiOAuth();
-      return { authUrl: result.authUrl, mode: result.mode };
-    } catch (e) { err(500, e.message); }
-  });
-
-  router.handle('gemini.status', () => {
-    const st = typeof geminiOAuthState === 'function' ? geminiOAuthState() : geminiOAuthState;
-    return st;
-  });
-
-  router.handle('gemini.relay', async (p) => {
-    const { code, state } = p;
-    if (!code || !state) err(400, 'Missing code or state');
-    try {
-      const email = await exchangeGeminiOAuthCode(code, state);
-      return { success: true, email };
-    } catch (e) { err(400, e.message); }
-  });
-
-  router.handle('gemini.complete', async (p) => {
-    const pastedUrl = (p.url || '').trim();
-    if (!pastedUrl) err(400, 'No URL provided');
-    let parsed;
-    try { parsed = new URL(pastedUrl); } catch { err(400, 'Invalid URL. Paste the full URL from the browser address bar.'); }
-    const urlError = parsed.searchParams.get('error');
-    if (urlError) {
-      const desc = parsed.searchParams.get('error_description') || urlError;
-      return { error: desc };
-    }
-    const code = parsed.searchParams.get('code');
-    const state = parsed.searchParams.get('state');
-    try {
-      const email = await exchangeGeminiOAuthCode(code, state);
-      return { success: true, email };
-    } catch (e) { err(400, e.message); }
-  });
-
-  router.handle('codex.start', async () => {
-    try {
-      const result = await startCodexOAuth();
-      return { authUrl: result.authUrl, mode: result.mode };
-    } catch (e) { err(500, e.message); }
-  });
-
-  router.handle('codex.status', () => {
-    const st = typeof codexOAuthState === 'function' ? codexOAuthState() : codexOAuthState;
-    return st;
-  });
-
-  router.handle('codex.relay', async (p) => {
-    const { code, state } = p;
-    if (!code || !state) err(400, 'Missing code or state');
-    try {
-      const email = await exchangeCodexOAuthCode(code, state);
-      return { success: true, email };
-    } catch (e) { err(400, e.message); }
-  });
-
-  router.handle('codex.complete', async (p) => {
-    const pastedUrl = (p.url || '').trim();
-    if (!pastedUrl) err(400, 'No URL provided');
-    let parsed;
-    try { parsed = new URL(pastedUrl); } catch { err(400, 'Invalid URL. Paste the full URL from the browser address bar.'); }
-    const urlError = parsed.searchParams.get('error');
-    if (urlError) {
-      const desc = parsed.searchParams.get('error_description') || urlError;
-      return { error: desc };
-    }
-    const code = parsed.searchParams.get('code');
-    const state = parsed.searchParams.get('state');
-    try {
-      const email = await exchangeCodexOAuthCode(code, state);
-      return { success: true, email };
-    } catch (e) { err(400, e.message); }
-  });
-
   router.handle('ws.stats', () => wsOptimizer.getStats());
 
-  router.handle('conv.scripts', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) err(404, 'Not found');
-    const wd = conv.workingDirectory || STARTUP_CWD;
-    let hasStart = false, hasDev = false;
-    try {
-      const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
-      const scripts = pkg.scripts || {};
-      hasStart = !!scripts.start;
-      hasDev = !!scripts.dev;
-    } catch {}
-    const running = activeScripts.has(p.id);
-    const runningScript = running ? activeScripts.get(p.id).script : null;
-    return { hasStart, hasDev, running, runningScript };
-  });
-
-  router.handle('conv.run-script', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) err(404, 'Not found');
-    if (activeScripts.has(p.id)) err(409, 'Script already running');
-    const script = p.script;
-    if (script !== 'start' && script !== 'dev') err(400, 'Invalid script');
-    const wd = conv.workingDirectory || STARTUP_CWD;
-    try {
-      const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
-      if (!pkg.scripts || !pkg.scripts[script]) err(400, `Script "${script}" not found`);
-    } catch (e) { if (e.code) throw e; err(400, 'No package.json'); }
-    const childEnv = { ...process.env, FORCE_COLOR: '1' };
-    delete childEnv.PORT; delete childEnv.BASE_URL; delete childEnv.HOT_RELOAD;
-    const isWindows = os.platform() === 'win32';
-    const child = spawn('npm', ['run', script], { cwd: wd, stdio: ['ignore', 'pipe', 'pipe'], detached: true, env: childEnv, shell: isWindows });
-    activeScripts.set(p.id, { process: child, script, startTime: Date.now() });
-    broadcastSync({ type: 'script_started', conversationId: p.id, script, timestamp: Date.now() });
-    const onData = (stream) => (chunk) => broadcastSync({ type: 'script_output', conversationId: p.id, data: chunk.toString(), stream, timestamp: Date.now() });
-    child.stdout.on('data', onData('stdout'));
-    child.stderr.on('data', onData('stderr'));
-    child.on('error', (e) => { activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: 1, error: e.message, timestamp: Date.now() }); });
-    child.on('close', (code) => { activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: code || 0, timestamp: Date.now() }); });
-    return { ok: true, script, pid: child.pid };
-  });
-
-  router.handle('conv.stop-script', (p) => {
-    const entry = activeScripts.get(p.id);
-    if (!entry) err(404, 'No running script');
-    try { process.kill(-entry.process.pid, 'SIGTERM'); } catch { try { entry.process.kill('SIGTERM'); } catch {} }
-    return { ok: true };
-  });
-
   router.handle('voice.cache', async (p) => {
     const { conversationId, text } = p;
     if (!conversationId || !text) err(400, 'Missing conversationId or text');
@@ -289,64 +141,28 @@ export function register(router, deps) {
   router.handle('tools.list', async () => {
     try {
       const tools = await toolManager.getAllToolsAsync();
-      const result = tools.map((t) => ({
-        id: t.id,
-        name: t.name,
-        pkg: t.pkg,
-        category: t.category || 'plugin',
-        installed: t.installed,
-        status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
-        isUpToDate: t.isUpToDate,
-        upgradeNeeded: t.upgradeNeeded,
-        hasUpdate: t.upgradeNeeded && t.installed,
-        installedVersion: t.installedVersion,
-        publishedVersion: t.publishedVersion
-      }));
-      return { tools: result };
-    } catch (e) {
-      err(500, e.message);
-    }
+      return { tools: tools.map((t) => ({ id: t.id, name: t.name, pkg: t.pkg, category: t.category || 'plugin', installed: t.installed, status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed', isUpToDate: t.isUpToDate, upgradeNeeded: t.upgradeNeeded, hasUpdate: t.upgradeNeeded && t.installed, installedVersion: t.installedVersion, publishedVersion: t.publishedVersion })) };
+    } catch (e) { err(500, e.message); }
   });
 
-  router.handle('agent.subagents', async (p) => {
-    const { id } = p;
-    if (!id) err(400, 'Missing agent id');
+  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': []
+  };
 
-    // Claude Code: run 'claude agents list' and parse output
-    if (id === 'claude-code' || 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
-      });
+  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 output = result.stdout.trim();
-      // Output format: '  agentId · model' lines under section headers
-      const agents = [];
-      for (const line of output.split('\n').filter(l => l.trim())) {
-        const match = line.match(/^  (\S+)\s+·/);
-        if (match) {
-          const id = match[1];
-          agents.push({ id, name: id });
-        }
-      }
+      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] }));
       console.log('[agent.subagents] claude agents list found:', agents.map(a => a.id).join(', '));
       return { subAgents: agents };
     }
-
-    // ACP agents: hardcoded map filtered by installed tools
-    const subAgentMap = {
-      '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':    []
-    };
-    const subAgents = subAgentMap[id] || [];
+    const subAgents = SUB_AGENT_MAP[p.id] || [];
     const tools = await toolManager.getAllToolsAsync();
     const installed = new Set(tools.filter(t => t.category === 'plugin' && t.installed).map(t => t.id));
     return { subAgents: subAgents.filter(sa => installed.has(sa.id)) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.715",
+  "version": "1.0.717",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -25,6 +25,10 @@ import { register as registerConvHandlers } from './lib/ws-handlers-conv.js';
 import { register as registerSessionHandlers } from './lib/ws-handlers-session.js';
 import { register as registerRunHandlers } from './lib/ws-handlers-run.js';
 import { register as registerUtilHandlers } from './lib/ws-handlers-util.js';
+import { register as registerOAuthHandlers } from './lib/ws-handlers-oauth.js';
+import { register as registerScriptHandlers } from './lib/ws-handlers-scripts.js';
+import { register as registerQueueHandlers } from './lib/ws-handlers-queue.js';
+import { register as registerMsgHandlers } from './lib/ws-handlers-msg.js';
 import { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, ensureRunning, queryModels as queryACPModels, touch as touchACP } from './lib/acp-sdk-manager.js';
 import * as execMachine from './lib/execution-machine.js';
 import { installGMAgentConfigs } from './lib/gm-agent-configs.js';
@@ -4520,11 +4524,18 @@ function broadcastSync(event) {
 const wsRouter = new WsRouter();
 
 registerConvHandlers(wsRouter, {
-  queries, activeExecutions, messageQueues, rateLimitState,
-  broadcastSync, processMessageWithStreaming, cleanupExecution, logError,
+  queries, activeExecutions, rateLimitState,
+  broadcastSync, processMessageWithStreaming, cleanupExecution,
   getJsonlWatcher: () => jsonlWatcher
 });
 
+registerMsgHandlers(wsRouter, {
+  queries, activeExecutions, messageQueues,
+  broadcastSync, processMessageWithStreaming, logError
+});
+
+registerQueueHandlers(wsRouter, { queries, messageQueues, broadcastSync });
+
 console.log('[INIT] About to call registerSessionHandlers, discoveredAgents.length:', discoveredAgents.length);
 registerSessionHandlers(wsRouter, {
   db: queries, discoveredAgents, modelCache,
@@ -4541,11 +4552,18 @@ registerRunHandlers(wsRouter, {
 registerUtilHandlers(wsRouter, {
   queries, wsOptimizer, modelDownloadState, ensureModelsDownloaded,
   broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig,
+  STARTUP_CWD, voiceCacheManager, toolManager, discoveredAgents
+});
+
+registerScriptHandlers(wsRouter, {
+  queries, broadcastSync, STARTUP_CWD, activeScripts
+});
+
+registerOAuthHandlers(wsRouter, {
   startGeminiOAuth, exchangeGeminiOAuthCode,
   geminiOAuthState: () => geminiOAuthState,
   startCodexOAuth, exchangeCodexOAuthCode,
   codexOAuthState: () => codexOAuthState,
-  STARTUP_CWD, activeScripts, voiceCacheManager, toolManager, discoveredAgents
 });
 
 wsRouter.onLegacy((data, ws) => {