agentgui 1.0.438 → 1.0.440

package/lib/acp-manager.js

@@ -17,6 +17,7 @@ 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;
@@ -32,6 +33,9 @@ function resolveBinary(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() };
@@ -44,6 +48,7 @@ function startProcess(tool) {
   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', () => {});
@@ -57,7 +62,7 @@ function startProcess(tool) {
 
   proc.on('close', (code) => {
     entry.healthy = false;
-    if (shuttingDown) return;
+    if (shuttingDown || entry._stopping) return;
     log(tool.id + ' exited code ' + code);
     scheduleRestart(tool, entry.restarts);
   });
@@ -65,9 +70,29 @@ function startProcess(tool) {
   processes.set(tool.id, entry);
   log(tool.id + ' started port ' + tool.port + ' pid ' + proc.pid);
   setTimeout(() => checkHealth(tool.id), STARTUP_GRACE_MS);
+  resetIdleTimer(tool.id);
   return entry;
 }
 
+function resetIdleTimer(toolId) {
+  const entry = processes.get(toolId);
+  if (!entry) return;
+  entry.lastUsed = Date.now();
+  if (entry.idleTimer) clearTimeout(entry.idleTimer);
+  entry.idleTimer = setTimeout(() => stopTool(toolId), IDLE_TIMEOUT_MS);
+}
+
+function stopTool(toolId) {
+  const entry = processes.get(toolId);
+  if (!entry) return;
+  log(toolId + ' idle, stopping to free RAM');
+  entry._stopping = true;
+  if (entry.idleTimer) clearTimeout(entry.idleTimer);
+  try { entry.process.kill('SIGTERM'); } catch (_) {}
+  setTimeout(() => { try { entry.process.kill('SIGKILL'); } catch (_) {} }, 5000);
+  processes.delete(toolId);
+}
+
 function scheduleRestart(tool, prevRestarts = []) {
   if (shuttingDown) return;
   const now = Date.now();
@@ -98,16 +123,30 @@ async function checkHealth(toolId) {
   entry.lastHealthCheck = Date.now();
 }
 
-export async function startAll() {
-  log('starting ACP tools...');
-  for (const tool of ACP_TOOLS) {
-    const bin = resolveBinary(tool.cmd);
-    if (bin === tool.cmd && !fs.existsSync(bin)) {
-      log(tool.id + ' not found, skipping');
-      continue;
-    }
-    startProcess(tool);
+export async function ensureRunning(agentId) {
+  const tool = ACP_TOOLS.find(t => t.id === agentId);
+  if (!tool) return null;
+  let entry = processes.get(agentId);
+  if (entry?.healthy) { resetIdleTimer(agentId); return entry.port; }
+  if (!entry || entry._stopping) {
+    entry = startProcess(tool);
+    if (!entry) return null;
   }
+  for (let i = 0; i < 20; i++) {
+    await new Promise(r => setTimeout(r, 500));
+    await checkHealth(agentId);
+    if (processes.get(agentId)?.healthy) { resetIdleTimer(agentId); return tool.port; }
+  }
+  return null;
+}
+
+export function touch(agentId) {
+  const entry = processes.get(agentId);
+  if (entry) resetIdleTimer(agentId);
+}
+
+export async function startAll() {
+  log('ACP tools available (on-demand start)');
   healthTimer = setInterval(() => {
     for (const [id] of processes) checkHealth(id);
   }, HEALTH_INTERVAL_MS);
@@ -118,6 +157,7 @@ export async function stopAll() {
   if (healthTimer) { clearInterval(healthTimer); healthTimer = null; }
   const kills = [];
   for (const [id, entry] of processes) {
+    if (entry.idleTimer) clearTimeout(entry.idleTimer);
     log('stopping ' + id + ' pid ' + entry.pid);
     kills.push(new Promise(resolve => {
       const t = setTimeout(() => { try { entry.process.kill('SIGKILL'); } catch (_) {} resolve(); }, 5000);
@@ -131,10 +171,14 @@ export async function stopAll() {
 }
 
 export function getStatus() {
-  return Array.from(processes.values()).map(e => ({
-    id: e.id, port: e.port, pid: e.pid, healthy: e.healthy,
-    uptime: Date.now() - e.startedAt, restartCount: e.restarts.length,
-  }));
+  return ACP_TOOLS.map(tool => {
+    const e = processes.get(tool.id);
+    return {
+      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,
+    };
+  });
 }
 
 export function getPort(agentId) {
@@ -151,17 +195,16 @@ export function getRunningPorts() {
 export async function restart(agentId) {
   const tool = ACP_TOOLS.find(t => t.id === agentId);
   if (!tool) return false;
-  const entry = processes.get(agentId);
-  if (entry) { try { entry.process.kill('SIGTERM'); } catch (_) {} processes.delete(agentId); }
+  stopTool(agentId);
   startProcess(tool);
   return true;
 }
 
 export async function queryModels(agentId) {
-  const entry = processes.get(agentId);
-  if (!entry?.healthy) return [];
+  const port = await ensureRunning(agentId);
+  if (!port) return [];
   try {
-    const res = await fetch('http://127.0.0.1:' + entry.port + '/provider', {
+    const res = await fetch('http://127.0.0.1:' + port + '/provider', {
       signal: AbortSignal.timeout(5000), headers: { 'Accept': 'application/json' }
     });
     if (!res.ok) return [];
@@ -176,4 +219,11 @@ export async function queryModels(agentId) {
   } 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);
+}
+
 export const ACP_TOOL_CONFIGS = ACP_TOOLS;

package/lib/ws-handlers-session.js

@@ -2,6 +2,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-manager.js';
 
 function spawnScript(cmd, args, convId, scriptName, agentId, deps) {
   const { activeScripts, broadcastSync, modelCache } = deps;
@@ -109,9 +110,11 @@ export function register(router, deps) {
 
   router.handle('agent.subagents', async (p) => {
     const agent = discoveredAgents.find(x => x.id === p.id);
-    if (!agent || agent.protocol !== 'acp' || !agent.acpPort) return { subAgents: [] };
+    if (!agent || agent.protocol !== 'acp') return { subAgents: [] };
+    const port = await ensureRunning(p.id);
+    if (!port) return { subAgents: [] };
     try {
-      const data = await acpFetch(agent.acpPort, '/agents/search', {});
+      const data = await acpFetch(port, '/agents/search', {});
       const list = Array.isArray(data) ? data : (data?.agents || []);
       return { subAgents: list.map(a => ({ id: a.agent_id || a.id, name: a.metadata?.ref?.name || a.name || a.agent_id || a.id })) };
     } catch (_) { return { subAgents: [] }; }
@@ -129,29 +132,25 @@ export function register(router, deps) {
     return d;
   });
 
-  router.handle('agent.models', async (p) => {
-    const cached = modelCache.get(p.id);
-    if (cached && (Date.now() - cached.ts) < 300000) return { models: cached.models };
-    let models = [];
-    if (p.id === 'claude-code') {
-      models = [
-        { id: 'claude-haiku', label: 'Haiku' },
-        { id: 'claude-sonnet', label: 'Sonnet' },
-        { id: 'claude-opus', label: 'Opus' }
-      ];
-    } else {
-      const agent = discoveredAgents.find(x => x.id === p.id);
-      if (agent?.protocol === 'acp' && agent.acpPort) {
-        try {
-          const data = await acpFetch(agent.acpPort, '/models');
-          const list = data?.data || data?.models || (Array.isArray(data) ? data : []);
-          models = list.map(m => ({ id: m.id || m.model_id, label: m.name || m.display_name || m.id || m.model_id })).filter(m => m.id);
-        } catch (_) {}
-      }
-    }
-    if (models.length > 0) modelCache.set(p.id, { models, ts: Date.now() });
-    return { models };
-  });
+  router.handle('agent.models', async (p) => {
+    const cached = modelCache.get(p.id);
+    if (cached && (Date.now() - cached.ts) < 300000) return { models: cached.models };
+    let models = [];
+    if (p.id === 'claude-code') {
+      models = [
+        { id: 'haiku', label: 'Haiku' },
+        { id: 'sonnet', label: 'Sonnet' },
+        { id: 'opus', label: 'Opus' }
+      ];
+    } else {
+      const agent = discoveredAgents.find(x => x.id === p.id);
+      if (agent?.protocol === 'acp') {
+        models = await queryModels(p.id);
+      }
+    }
+    if (models.length > 0) modelCache.set(p.id, { models, ts: Date.now() });
+    return { models };
+  });
 
   router.handle('agent.search', (p) => db.searchAgents(discoveredAgents, p.query || p));
 

package/package.json

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

package/server.js

@@ -22,7 +22,7 @@ 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 { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, queryModels as queryACPModels } from './lib/acp-manager.js';
+import { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, queryModels as queryACPModels, touch as touchACP } from './lib/acp-manager.js';
 
 
 process.on('uncaughtException', (err, origin) => {
@@ -433,30 +433,14 @@ async function getModelsForAgent(agentId) {
   let models = [];
   if (agentId === 'claude-code') {
     models = [
-      { id: 'claude-haiku', label: 'Haiku' },
-      { id: 'claude-sonnet', label: 'Sonnet' },
-      { id: 'claude-opus', label: 'Opus' }
+      { id: 'haiku', label: 'Haiku' },
+      { id: 'sonnet', label: 'Sonnet' },
+      { id: 'opus', label: 'Opus' }
     ];
   } else {
     const agent = discoveredAgents.find(a => a.id === agentId);
     if (agent?.protocol === 'acp') {
-      const acpPort = getACPPort(agentId) || agent.acpPort;
-      if (acpPort) {
-        try {
-          models = await queryACPModels(agentId);
-          if (!models.length) {
-            const res = await fetch(`http://localhost:${acpPort}/models`, {
-              headers: { 'Content-Type': 'application/json' },
-              signal: AbortSignal.timeout(3000)
-            });
-            if (res.ok) {
-              const data = await res.json();
-              const list = data?.data || data?.models || (Array.isArray(data) ? data : []);
-              models = list.map(m => ({ id: m.id || m.model_id, label: m.name || m.display_name || m.id || m.model_id })).filter(m => m.id);
-            }
-          }
-        } catch (_) {}
-      }
+      try { models = await queryACPModels(agentId); } catch (_) {}
     }
   }
   modelCache.set(agentId, { models, timestamp: Date.now() });
@@ -3166,6 +3150,7 @@ function createChunkBatcher() {
 
 async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId, model) {
   const startTime = Date.now();
+  touchACP(agentId);
   
   const conv = queries.getConversation(conversationId);
   if (!conv) {