agentgui 1.0.770 → 1.0.771

package/CLAUDE.md

@@ -50,6 +50,7 @@ lib/routes-speech.js   Speech/TTS HTTP route handlers (stt, tts, voices, speech-
 lib/routes-oauth.js    OAuth HTTP route handlers (gemini-oauth/*, codex-oauth/*)
 lib/routes-tools.js    Tool management HTTP route handlers (list, install, update, history, refresh)
 lib/routes-util.js     Utility HTTP route handlers (clone, folders, git, home, version, import)
+lib/routes-agents.js   Agent list/search/auth-status/descriptor/models HTTP route handlers
 lib/routes-conversations.js  Conversation CRUD HTTP route handlers (list, create, get, update, delete, archive, restore)
 lib/routes-debug.js    Debug/backup/restore/ws-stats HTTP route handlers
 lib/routes-threads.js  Thread CRUD HTTP route handlers (ACP v0.2.3 thread API)

package/lib/routes-agents.js

@@ -0,0 +1,108 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import { getAgentDescriptor } from './agent-descriptors.js';
+import { discoverExternalACPServers } from './agent-discovery.js';
+
+export function register(deps) {
+  const { sendJSON, parseBody, queries, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, debugLog } = deps;
+  const routes = {};
+
+  routes['GET /api/agents'] = async (req, res) => {
+    debugLog(`[API /api/agents] Returning ${discoveredAgents.length} agents`);
+    sendJSON(req, res, 200, { agents: discoveredAgents });
+  };
+
+  routes['GET /api/acp/status'] = async (req, res) => {
+    sendJSON(req, res, 200, { tools: getACPStatus() });
+  };
+
+  routes['POST /api/agents/search'] = async (req, res) => {
+    const body = await parseBody(req);
+    try {
+      const localResult = queries.searchAgents(discoveredAgents, body);
+      const externalAgents = await discoverExternalACPServers(discoveredAgents);
+      const externalResult = queries.searchAgents(externalAgents, body);
+      sendJSON(req, res, 200, {
+        agents: [...localResult.agents, ...externalResult.agents],
+        total: localResult.total + externalResult.total,
+        limit: body.limit || 50, offset: body.offset || 0,
+        hasMore: localResult.hasMore || externalResult.hasMore,
+      });
+    } catch (error) {
+      console.error('Error searching agents:', error);
+      sendJSON(req, res, 200, queries.searchAgents(discoveredAgents, body));
+    }
+  };
+
+  routes['GET /api/agents/auth-status'] = async (req, res) => {
+    const statuses = discoveredAgents.map(agent => {
+      const status = { id: agent.id, name: agent.name, authenticated: false, detail: '' };
+      try {
+        if (agent.id === 'claude-code') {
+          const credFile = path.join(os.homedir(), '.claude', '.credentials.json');
+          if (fs.existsSync(credFile)) {
+            const creds = JSON.parse(fs.readFileSync(credFile, 'utf-8'));
+            if (creds.claudeAiOauth && creds.claudeAiOauth.expiresAt > Date.now()) {
+              status.authenticated = true;
+              status.detail = creds.claudeAiOauth.subscriptionType || 'authenticated';
+            } else { status.detail = 'expired'; }
+          } else { status.detail = 'no credentials'; }
+        } else if (agent.id === 'gemini') {
+          const oauthFile = path.join(os.homedir(), '.gemini', 'oauth_creds.json');
+          const acctFile = path.join(os.homedir(), '.gemini', 'google_accounts.json');
+          let hasOAuth = false;
+          if (fs.existsSync(oauthFile)) {
+            try { const creds = JSON.parse(fs.readFileSync(oauthFile, 'utf-8')); if (creds.refresh_token || creds.access_token) hasOAuth = true; } catch (_) {}
+          }
+          if (fs.existsSync(acctFile)) {
+            const accts = JSON.parse(fs.readFileSync(acctFile, 'utf-8'));
+            if (accts.active) { status.authenticated = true; status.detail = accts.active; }
+            else if (hasOAuth) { status.authenticated = true; status.detail = 'oauth'; }
+            else { status.detail = 'logged out'; }
+          } else if (hasOAuth) { status.authenticated = true; status.detail = 'oauth'; }
+          else { status.detail = 'no credentials'; }
+        } else if (agent.id === 'opencode') {
+          const out = execSync('opencode auth list 2>&1', { encoding: 'utf-8', timeout: 5000 });
+          const countMatch = out.match(/(\d+)\s+credentials?/);
+          if (countMatch && parseInt(countMatch[1], 10) > 0) { status.authenticated = true; status.detail = countMatch[1] + ' credential(s)'; }
+          else { status.detail = 'no credentials'; }
+        } else { status.detail = 'unknown'; }
+      } catch (e) { status.detail = 'check failed'; }
+      return status;
+    });
+    sendJSON(req, res, 200, { agents: statuses });
+  };
+
+  routes['_match'] = (method, pathOnly) => {
+    const key = `${method} ${pathOnly}`;
+    if (routes[key]) return routes[key];
+    let m;
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/agents\/([^/]+)$/)))
+      return (req, res) => handleGetAgent(req, res, m[1]);
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/agents\/([^/]+)\/descriptor$/)))
+      return (req, res) => { const d = getAgentDescriptor(m[1]); d ? sendJSON(req, res, 200, d) : sendJSON(req, res, 404, { error: 'Agent not found' }); };
+    if (method === 'GET' && (m = pathOnly.match(/^\/api\/agents\/([^/]+)\/models$/)))
+      return (req, res) => handleGetModels(req, res, m[1]);
+    return null;
+  };
+
+  async function handleGetAgent(req, res, agentId) {
+    const agent = discoveredAgents.find(a => a.id === agentId);
+    if (!agent) { sendJSON(req, res, 404, { error: 'Agent not found' }); return; }
+    sendJSON(req, res, 200, { id: agent.id, name: agent.name, description: agent.description || '', icon: agent.icon || null, status: 'available' });
+  }
+
+  async function handleGetModels(req, res, agentId) {
+    const cached = modelCache.get(agentId);
+    if (cached && (Date.now() - cached.timestamp) < 300000) { sendJSON(req, res, 200, { models: cached.models }); return; }
+    try {
+      const models = await getModelsForAgent(agentId);
+      modelCache.set(agentId, { models, timestamp: Date.now() });
+      sendJSON(req, res, 200, { models });
+    } catch (err) { sendJSON(req, res, 200, { models: [] }); }
+  }
+
+  return routes;
+}

package/package.json

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

package/server.js

@@ -25,6 +25,7 @@ import { register as registerToolRoutes } from './lib/routes-tools.js';
 import { register as registerThreadRoutes } from './lib/routes-threads.js';
 import { register as registerDebugRoutes } from './lib/routes-debug.js';
 import { register as registerConvRoutes } from './lib/routes-conversations.js';
+import { register as registerAgentRoutes } from './lib/routes-agents.js';
 import { startCodexOAuth, exchangeCodexOAuthCode, handleCodexOAuthCallback, getCodexOAuthStatus, getCodexOAuthState, CODEX_HOME, CODEX_AUTH_FILE } from './lib/oauth-codex.js';
 import { WSOptimizer } from './lib/ws-optimizer.js';
 import { WsRouter } from './lib/ws-protocol.js';
@@ -1109,168 +1110,8 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    if (pathOnly === '/api/agents' && req.method === 'GET') {
-      debugLog(`[API /api/agents] Returning ${discoveredAgents.length} agents`);
-            sendJSON(req, res, 200, { agents: discoveredAgents });
-      return;
-    }
-
-    if (pathOnly === '/api/acp/status' && req.method === 'GET') {
-      sendJSON(req, res, 200, { tools: getACPStatus() });
-      return;
-    }
-
-
-
-    const debugHandler = _debugRoutes._match(req.method, pathOnly);
-    if (debugHandler) { await debugHandler(req, res); return; }
-
-    if (pathOnly === '/api/agents/search' && req.method === 'POST') {
-      const body = await parseBody(req);
-      try {
-        // Get local agents
-        const localResult = queries.searchAgents(discoveredAgents, body);
-        
-        // Get external agents from ACP servers
-        const externalAgents = await discoverExternalACPServers(discoveredAgents);
-        const externalResult = queries.searchAgents(externalAgents, body);
-        
-        // Combine results
-        const combinedAgents = [...localResult.agents, ...externalResult.agents];
-        const total = localResult.total + externalResult.total;
-        const hasMore = localResult.hasMore || externalResult.hasMore;
-        
-        sendJSON(req, res, 200, {
-          agents: combinedAgents,
-          total,
-          limit: body.limit || 50,
-          offset: body.offset || 0,
-          hasMore,
-        });
-      } catch (error) {
-        console.error('Error searching agents:', error);
-        const result = queries.searchAgents(discoveredAgents, body);
-        sendJSON(req, res, 200, result);
-      }
-      return;
-    }
-
-    if (pathOnly === '/api/agents/auth-status' && req.method === 'GET') {
-      const statuses = discoveredAgents.map(agent => {
-        const status = { id: agent.id, name: agent.name, authenticated: false, detail: '' };
-        try {
-          if (agent.id === 'claude-code') {
-            const credFile = path.join(os.homedir(), '.claude', '.credentials.json');
-            if (fs.existsSync(credFile)) {
-              const creds = JSON.parse(fs.readFileSync(credFile, 'utf-8'));
-              if (creds.claudeAiOauth && creds.claudeAiOauth.expiresAt > Date.now()) {
-                status.authenticated = true;
-                status.detail = creds.claudeAiOauth.subscriptionType || 'authenticated';
-              } else {
-                status.detail = 'expired';
-              }
-            } else {
-              status.detail = 'no credentials';
-            }
-          } else if (agent.id === 'gemini') {
-            const oauthFile = path.join(os.homedir(), '.gemini', 'oauth_creds.json');
-            const acctFile = path.join(os.homedir(), '.gemini', 'google_accounts.json');
-            let hasOAuth = false;
-            if (fs.existsSync(oauthFile)) {
-              try {
-                const creds = JSON.parse(fs.readFileSync(oauthFile, 'utf-8'));
-                if (creds.refresh_token || creds.access_token) hasOAuth = true;
-              } catch (_) {}
-            }
-            if (fs.existsSync(acctFile)) {
-              const accts = JSON.parse(fs.readFileSync(acctFile, 'utf-8'));
-              if (accts.active) {
-                status.authenticated = true;
-                status.detail = accts.active;
-              } else if (hasOAuth) {
-                status.authenticated = true;
-                status.detail = 'oauth';
-              } else {
-                status.detail = 'logged out';
-              }
-            } else if (hasOAuth) {
-              status.authenticated = true;
-              status.detail = 'oauth';
-            } else {
-              status.detail = 'no credentials';
-            }
-          } else if (agent.id === 'opencode') {
-            const out = execSync('opencode auth list 2>&1', { encoding: 'utf-8', timeout: 5000 });
-            const countMatch = out.match(/(\d+)\s+credentials?/);
-            if (countMatch && parseInt(countMatch[1], 10) > 0) {
-              status.authenticated = true;
-              status.detail = countMatch[1] + ' credential(s)';
-            } else {
-              status.detail = 'no credentials';
-            }
-          } else {
-            status.detail = 'unknown';
-          }
-        } catch (e) {
-          status.detail = 'check failed';
-        }
-        return status;
-      });
-      sendJSON(req, res, 200, { agents: statuses });
-      return;
-    }
-
-    const agentByIdMatch = pathOnly.match(/^\/api\/agents\/([^/]+)$/);
-    if (agentByIdMatch && req.method === 'GET') {
-      const agentId = agentByIdMatch[1];
-      const agent = discoveredAgents.find(a => a.id === agentId);
-      
-      if (!agent) {
-        sendJSON(req, res, 404, { error: 'Agent not found' });
-        return;
-      }
-
-      sendJSON(req, res, 200, {
-        id: agent.id,
-        name: agent.name,
-        description: agent.description || '',
-        icon: agent.icon || null,
-        status: 'available'
-      });
-      return;
-    }
-
-    const agentDescriptorMatch = pathOnly.match(/^\/api\/agents\/([^/]+)\/descriptor$/);
-    if (agentDescriptorMatch && req.method === 'GET') {
-      const agentId = agentDescriptorMatch[1];
-      const descriptor = getAgentDescriptor(agentId);
-
-      if (!descriptor) {
-        sendJSON(req, res, 404, { error: 'Agent not found' });
-        return;
-      }
-
-      sendJSON(req, res, 200, descriptor);
-      return;
-    }
-
-    const modelsMatch = pathOnly.match(/^\/api\/agents\/([^/]+)\/models$/);
-    if (modelsMatch && req.method === 'GET') {
-      const agentId = modelsMatch[1];
-      const cached = modelCache.get(agentId);
-      if (cached && (Date.now() - cached.timestamp) < 300000) {
-        sendJSON(req, res, 200, { models: cached.models });
-        return;
-      }
-      try {
-        const models = await getModelsForAgent(agentId);
-        modelCache.set(agentId, { models, timestamp: Date.now() });
-        sendJSON(req, res, 200, { models });
-      } catch (err) {
-        sendJSON(req, res, 200, { models: [] });
-      }
-      return;
-    }
+    const agentHandler = _agentRoutes._match(req.method, pathOnly);
+    if (agentHandler) { await agentHandler(req, res); return; }
 
     if (pathOnly === '/api/runs' && req.method === 'POST') {
       const body = await parseBody(req);
@@ -2766,6 +2607,7 @@ const _toolRoutes = registerToolRoutes({ sendJSON, parseBody, queries, broadcast
 const _threadRoutes = registerThreadRoutes({ sendJSON, parseBody, queries });
 const _debugRoutes = registerDebugRoutes({ sendJSON, queries, activeExecutions, messageQueues, syncClients, wsOptimizer, _errLogPath });
 const _convRoutes = registerConvRoutes({ sendJSON, parseBody, queries, activeExecutions, broadcastSync });
+const _agentRoutes = registerAgentRoutes({ sendJSON, parseBody, queries, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, debugLog });
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, rateLimitState,