agentgui 1.0.533 → 1.0.535

package/lib/acp-http-client.js

@@ -0,0 +1,125 @@
+/**
+ * ACP HTTP Client with comprehensive request/response logging
+ */
+
+function logACPCall(method, url, requestData, responseData, error = null) {
+  const timestamp = new Date().toISOString();
+  const logEntry = {
+    timestamp,
+    method,
+    url,
+    request: requestData,
+    response: responseData,
+    error: error ? error.message : null
+  };
+  
+  console.log('[ACP-HTTP]', JSON.stringify(logEntry, null, 2));
+  return logEntry;
+}
+
+export async function fetchACPProvider(baseUrl, port) {
+  const url = baseUrl + ':' + port + '/provider';
+  const startTime = Date.now();
+  
+  try {
+    console.log('[ACP-HTTP] → GET ' + url);
+    
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: { 'Accept': 'application/json' },
+      signal: AbortSignal.timeout(3000)
+    });
+    
+    const data = response.ok ? await response.json() : null;
+    const duration = Date.now() - startTime;
+    
+    logACPCall('GET', url, {
+      headers: { 'Accept': 'application/json' },
+      timeout: 3000
+    }, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: data,
+      duration_ms: duration
+    });
+    
+    return { ok: response.ok, status: response.status, data };
+  } catch (error) {
+    logACPCall('GET', url, { headers: { 'Accept': 'application/json' } }, null, error);
+    return { ok: false, status: 0, data: null, error: error.message };
+  }
+}
+
+export async function fetchACPAgents(baseUrl) {
+  const endpoint = baseUrl.endsWith('/') ? baseUrl + 'agents/search' : baseUrl + '/agents/search';
+  const requestBody = {};
+  const startTime = Date.now();
+  
+  try {
+    console.log('[ACP-HTTP] → POST ' + endpoint);
+    console.log('[ACP-HTTP]   Request body: ' + JSON.stringify(requestBody));
+    
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json'
+      },
+      body: JSON.stringify(requestBody),
+      signal: AbortSignal.timeout(5000)
+    });
+    
+    const data = response.ok ? await response.json() : null;
+    const duration = Date.now() - startTime;
+    
+    logACPCall('POST', endpoint, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json'
+      },
+      body: requestBody,
+      timeout: 5000
+    }, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: data,
+      duration_ms: duration
+    });
+    
+    return { ok: response.ok, status: response.status, data };
+  } catch (error) {
+    logACPCall('POST', endpoint, { body: requestBody }, null, error);
+    return { ok: false, status: 0, data: null, error: error.message };
+  }
+}
+
+export function extractCompleteAgentData(agent) {
+  return {
+    id: agent.agent_id || agent.id,
+    name: agent.metadata?.ref?.name || agent.name || 'Unknown Agent',
+    metadata: {
+      ref: {
+        name: agent.metadata?.ref?.name,
+        version: agent.metadata?.ref?.version,
+        url: agent.metadata?.ref?.url,
+        tags: agent.metadata?.ref?.tags
+      },
+      description: agent.metadata?.description,
+      author: agent.metadata?.author,
+      license: agent.metadata?.license
+    },
+    specs: agent.specs ? {
+      capabilities: agent.specs.capabilities,
+      input_schema: agent.specs.input_schema || agent.specs.input,
+      output_schema: agent.specs.output_schema || agent.specs.output,
+      thread_state_schema: agent.specs.thread_state_schema || agent.specs.thread_state,
+      config_schema: agent.specs.config_schema || agent.specs.config,
+      custom_streaming_update_schema: agent.specs.custom_streaming_update_schema || agent.specs.custom_streaming_update
+    } : null,
+    custom_data: agent.custom_data,
+    icon: agent.metadata?.ref?.name?.charAt(0) || 'A',
+    protocol: 'acp'
+  };
+}

package/lib/acp-manager.js

@@ -1,74 +1,35 @@
-import { spawn } from 'child_process';
-import path from 'path';
-import os from 'os';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const projectRoot = path.resolve(__dirname, '..');
-const isWindows = os.platform() === 'win32';
+import { startProcess as startProc, scheduleRestart as scheduleRestart, MAX_RESTARTS, RESTART_WINDOW_MS, IDLE_TIMEOUT_MS } from './acp-process-lifecycle.js';
 
 const ACP_TOOLS = [
   { id: 'opencode', cmd: 'opencode', args: ['acp'], port: 18100, npxPkg: 'opencode-ai' },
   { id: 'kilo', cmd: 'kilo', args: ['acp'], port: 18101, npxPkg: '@kilocode/cli' },
 ];
 
-const MAX_RESTARTS = 10;
-const RESTART_WINDOW_MS = 300000;
 const HEALTH_INTERVAL_MS = 30000;
 const STARTUP_GRACE_MS = 5000;
-const IDLE_TIMEOUT_MS = 120000;
 const processes = new Map();
 let healthTimer = null;
 let shuttingDown = false;
 
 function log(msg) { console.log('[ACP] ' + msg); }
 
-function resolveBinary(cmd) {
-  const ext = isWindows ? '.cmd' : '';
-  const localBin = path.join(projectRoot, 'node_modules', '.bin', cmd + ext);
-  if (fs.existsSync(localBin)) return localBin;
-  return cmd;
-}
-
 function startProcess(tool) {
   if (shuttingDown) return null;
   const existing = processes.get(tool.id);
   if (existing?.process && !existing.process.killed) return existing;
 
-  const bin = resolveBinary(tool.cmd);
-  const args = [...tool.args, '--port', String(tool.port)];
-  const opts = { stdio: ['pipe', 'pipe', 'pipe'], cwd: process.cwd() };
-  if (isWindows) opts.shell = true;
-
-  let proc;
-  try { proc = spawn(bin, args, opts); }
-  catch (err) { log(tool.id + ' spawn failed: ' + err.message); return null; }
-
-  const entry = {
-    id: tool.id, port: tool.port, process: proc, pid: proc.pid,
-    startedAt: Date.now(), restarts: [], healthy: false, lastHealthCheck: 0,
-    lastUsed: Date.now(), idleTimer: null,
-  };
-
-  proc.stdout.on('data', () => {});
-  proc.stderr.on('data', (d) => {
-    const t = d.toString().trim();
-    if (t) log(tool.id + ': ' + t.substring(0, 200));
-  });
-  proc.stdout.on('error', () => {});
-  proc.stderr.on('error', () => {});
-  proc.on('error', (err) => { log(tool.id + ' error: ' + err.message); entry.healthy = false; });
+  const entry = startProc(tool, log);
+  if (!entry) return null;
 
-  proc.on('close', (code) => {
+  entry.process.on('close', (code) => {
     entry.healthy = false;
     if (shuttingDown || entry._stopping) return;
     log(tool.id + ' exited code ' + code);
-    scheduleRestart(tool, entry.restarts);
+    scheduleRestart(tool, entry.restarts, log, startProcess, () => shuttingDown);
   });
 
   processes.set(tool.id, entry);
-  log(tool.id + ' started port ' + tool.port + ' pid ' + proc.pid);
+  log(tool.id + ' started port ' + tool.port + ' pid ' + entry.process.pid);
   setTimeout(() => checkHealth(tool.id), STARTUP_GRACE_MS);
   resetIdleTimer(tool.id);
   return entry;
@@ -93,34 +54,19 @@ function stopTool(toolId) {
   processes.delete(toolId);
 }
 
-function scheduleRestart(tool, prevRestarts = []) {
-  if (shuttingDown) return;
-  const now = Date.now();
-  const recent = prevRestarts.filter(t => now - t < RESTART_WINDOW_MS);
-  if (recent.length >= MAX_RESTARTS) {
-    log(tool.id + ' exceeded restart limit, giving up');
-    processes.delete(tool.id);
-    return;
-  }
-  const delay = Math.min(1000 * Math.pow(2, recent.length), 30000);
-  log(tool.id + ' restarting in ' + delay + 'ms');
-  setTimeout(() => {
-    if (shuttingDown) return;
-    const entry = startProcess(tool);
-    if (entry) entry.restarts = [...recent, Date.now()];
-  }, delay);
-}
-
 async function checkHealth(toolId) {
   const entry = processes.get(toolId);
   if (!entry || shuttingDown) return;
-  try {
-    const res = await fetch('http://127.0.0.1:' + entry.port + '/provider', {
-      signal: AbortSignal.timeout(3000), headers: { 'Accept': 'application/json' }
-    });
-    entry.healthy = res.ok;
-  } catch (_) { entry.healthy = false; }
+
+  const { fetchACPProvider } = await import('./acp-http-client.js');
+  const result = await fetchACPProvider('http://127.0.0.1', entry.port);
+
+  entry.healthy = result.ok;
   entry.lastHealthCheck = Date.now();
+
+  if (result.data) {
+    entry.providerInfo = result.data;
+  }
 }
 
 export async function ensureRunning(agentId) {
@@ -177,6 +123,7 @@ export function getStatus() {
       id: tool.id, port: tool.port, running: !!e, healthy: e?.healthy || false,
       pid: e?.pid, uptime: e ? Date.now() - e.startedAt : 0,
       restartCount: e?.restarts.length || 0, idleMs: e ? Date.now() - e.lastUsed : 0,
+      providerInfo: e?.providerInfo || null,
     };
   });
 }
@@ -201,33 +148,17 @@ export async function restart(agentId) {
 }
 
 export async function queryModels(agentId) {
-  const port = await ensureRunning(agentId);
+  const port = getPort(agentId);
   if (!port) return [];
   try {
-    const res = await fetch('http://127.0.0.1:' + port + '/provider', {
-      signal: AbortSignal.timeout(5000), headers: { 'Accept': 'application/json' }
-    });
+    const res = await fetch('http://127.0.0.1:' + port + '/models');
     if (!res.ok) return [];
     const data = await res.json();
-    const connected = new Set(data.connected || []);
-    const providers = (data.all || []).filter(p => connected.has(p.id));
-    const seen = new Map();
-    for (const prov of providers) {
-      for (const m of Object.values(prov.models || {})) {
-        if (!seen.has(m.id)) {
-          seen.set(m.id, { id: m.id, label: m.name || m.id, provider: prov.name || prov.id });
-        }
-      }
-    }
-    return Array.from(seen.values());
+    return data.models || [];
   } catch (_) { return []; }
 }
 
 export function isAvailable(agentId) {
   const tool = ACP_TOOLS.find(t => t.id === agentId);
-  if (!tool) return false;
-  const bin = resolveBinary(tool.cmd);
-  return bin !== tool.cmd || fs.existsSync(bin);
+  return !!tool;
 }
-
-export const ACP_TOOL_CONFIGS = ACP_TOOLS;

package/lib/acp-process-lifecycle.js

@@ -0,0 +1,65 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '..');
+const isWindows = os.platform() === 'win32';
+
+export const MAX_RESTARTS = 10;
+export const RESTART_WINDOW_MS = 300000;
+export const IDLE_TIMEOUT_MS = 120000;
+
+export function resolveBinary(cmd) {
+  const ext = isWindows ? '.cmd' : '';
+  const localBin = path.join(projectRoot, 'node_modules', '.bin', cmd + ext);
+  if (fs.existsSync(localBin)) return localBin;
+  return cmd;
+}
+
+export function startProcess(tool, log) {
+  const bin = resolveBinary(tool.cmd);
+  const args = [...tool.args, '--port', String(tool.port)];
+  const opts = { stdio: ['pipe', 'pipe', 'pipe'], cwd: process.cwd() };
+  if (isWindows) opts.shell = true;
+
+  let proc;
+  try { proc = spawn(bin, args, opts); }
+  catch (err) { log(tool.id + ' spawn failed: ' + err.message); return null; }
+
+  const entry = {
+    id: tool.id, port: tool.port, process: proc, pid: proc.pid,
+    startedAt: Date.now(), restarts: [], healthy: false, lastHealthCheck: 0,
+    lastUsed: Date.now(), idleTimer: null,
+  };
+
+  proc.stdout.on('data', () => {});
+  proc.stderr.on('data', (d) => {
+    const t = d.toString().trim();
+    if (t) log(tool.id + ': ' + t.substring(0, 200));
+  });
+  proc.stdout.on('error', () => {});
+  proc.stderr.on('error', () => {});
+  proc.on('error', (err) => { log(tool.id + ' error: ' + err.message); entry.healthy = false; });
+
+  return entry;
+}
+
+export function scheduleRestart(tool, prevRestarts, log, startProcessFn, shuttingDown) {
+  if (shuttingDown()) return;
+  const now = Date.now();
+  const recent = prevRestarts.filter(t => now - t < RESTART_WINDOW_MS);
+  if (recent.length >= MAX_RESTARTS) {
+    log(tool.id + ' exceeded restart limit, giving up');
+    return null;
+  }
+  const delay = Math.min(1000 * Math.pow(2, recent.length), 30000);
+  log(tool.id + ' restarting in ' + delay + 'ms');
+  setTimeout(() => {
+    if (shuttingDown()) return;
+    const entry = startProcessFn(tool);
+    if (entry) entry.restarts = [...recent, Date.now()];
+  }, delay);
+}

package/lib/tool-manager.js

@@ -5,10 +5,10 @@ import path from 'path';
 
 const isWindows = os.platform() === 'win32';
 const TOOLS = [
-  { id: 'gm-cc', name: 'gm-cc', pkg: '@anthropic-ai/claude-code', pluginId: 'gm-cc' },
-  { id: 'gm-oc', name: 'gm-oc', pkg: 'opencode-ai', pluginId: 'gm-oc' },
-  { id: 'gm-gc', name: 'gm-gc', pkg: '@google/gemini-cli', pluginId: 'gm' },
-  { id: 'gm-kilo', name: 'gm-kilo', pkg: '@kilocode/cli', pluginId: 'gm-kilo' },
+  { id: 'gm-cc', name: 'gm-cc', pkg: 'gm-cc', pluginId: 'gm-cc' },
+  { id: 'gm-oc', name: 'gm-oc', pkg: 'gm-oc', pluginId: 'gm-oc' },
+  { id: 'gm-gc', name: 'gm-gc', pkg: 'gm-gc', pluginId: 'gm' },
+  { id: 'gm-kilo', name: 'gm-kilo', pkg: 'gm-kilo', pluginId: 'gm-kilo' },
 ];
 
 const statusCache = new Map();

package/package.json

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

package/server.js

@@ -397,41 +397,27 @@ function findCommand(cmd) {
 }
 
 async function queryACPServerAgents(baseUrl) {
-  try {
-    // Ensure correct endpoint format (handle both /api and /api/ cases)
-    const endpoint = baseUrl.endsWith('/') ? `${baseUrl}agents/search` : `${baseUrl}/agents/search`;
-    const response = await fetch(endpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({}),
-    });
-    
-    if (!response.ok) {
-      console.error(`Failed to query ACP agents from ${baseUrl}: ${response.status}`);
-      return [];
-    }
-    
-    const data = await response.json();
-    if (!data.agents || !Array.isArray(data.agents)) {
-      console.error(`Invalid agents response from ${baseUrl}`);
-      return [];
-    }
-    
-    // Convert ACP agent format to our internal format
-    return data.agents.map(agent => ({
-      id: agent.agent_id || agent.id,
-      name: agent.metadata?.ref?.name || agent.name || 'Unknown Agent',
-      icon: agent.metadata?.ref?.name?.charAt(0) || 'A',
-      path: baseUrl,
-      protocol: 'acp',
-      description: agent.metadata?.description || '',
-    }));
-  } catch (error) {
-    console.error(`Error querying ACP server ${baseUrl}:`, error.message);
+  const { fetchACPAgents, extractCompleteAgentData } = await import('./lib/acp-http-client.js');
+
+  const result = await fetchACPAgents(baseUrl);
+
+  if (!result.ok) {
+    console.error(`Failed to query ACP agents from ${baseUrl}: ${result.status} ${result.error || ''}`);
+    return [];
+  }
+
+  if (!result.data?.agents || !Array.isArray(result.data.agents)) {
+    console.error(`Invalid agents response from ${baseUrl}`);
     return [];
   }
+
+  return result.data.agents.map(agent => {
+    const complete = extractCompleteAgentData(agent);
+    return {
+      ...complete,
+      path: baseUrl
+    };
+  });
 }
 
 function discoverAgents() {