agentgui 1.0.437 → 1.0.439

package/CLAUDE.md

@@ -17,6 +17,7 @@ Server starts on `http://localhost:3000`, redirects to `/gm/`.
 server.js              HTTP server + WebSocket + all API routes (raw http.createServer)
 database.js            SQLite setup (WAL mode), schema, query functions
 lib/claude-runner.js   Agent framework - spawns CLI processes, parses stream-json output
+lib/acp-manager.js     ACP tool lifecycle - auto-starts opencode/kilo HTTP servers, restart on crash
 lib/speech.js          Speech-to-text and text-to-speech via @huggingface/transformers
 bin/gmgui.cjs          CLI entry point (npx agentgui / bunx agentgui)
 static/index.html      Main HTML shell
@@ -49,6 +50,14 @@ static/templates/                 31 HTML template fragments for event rendering
 - `STARTUP_CWD` - Working directory passed to agents
 - `HOT_RELOAD` - Set to "false" to disable watch mode
 
+## ACP Tool Lifecycle
+
+On startup, agentgui auto-launches bundled ACP tools (opencode, kilo) as HTTP servers:
+- OpenCode: port 18100 (`opencode acp --port 18100`)
+- Kilo: port 18101 (`kilo acp --port 18101`)
+
+Managed by `lib/acp-manager.js`. Features: crash restart with exponential backoff (max 10 in 5min), health checks every 30s via `GET /provider`, clean shutdown on SIGTERM. The `acpPort` field on discovered agents is set automatically once healthy. Models are queried from the running ACP HTTP servers via their `/provider` endpoint.
+
 ## REST API
 
 All routes are prefixed with `BASE_URL` (default `/gm`).
@@ -68,6 +77,7 @@ All routes are prefixed with `BASE_URL` (default `/gm`).
 - `GET /api/sessions/:id/chunks` - Get session chunks (query: since)
 - `GET /api/sessions/:id/execution` - Get execution events (query: limit, offset, filterType)
 - `GET /api/agents` - List discovered agents
+- `GET /api/acp/status` - ACP tool lifecycle status (ports, health, PIDs, restart counts)
 - `GET /api/home` - Get home directory
 - `POST /api/stt` - Speech-to-text (raw audio body)
 - `POST /api/tts` - Text-to-speech (body: text)

package/build-portable.js

@@ -122,6 +122,32 @@ const audioDeps = new Set();
 collectDeps('audio-decode', audioDeps);
 for (const dep of audioDeps) copyPkg(dep);
 
+log('Copying ACP tools (opencode, kilo, gemini) for portable...');
+const acpNativeTools = [
+  { wrapper: 'opencode-ai', platformPrefix: 'opencode-windows-x64' },
+  { wrapper: '@kilocode/cli', platformPrefix: '@kilocode/cli-windows-x64' },
+];
+for (const tool of acpNativeTools) {
+  const wrapperSrc = path.join(nm, tool.wrapper);
+  if (fs.existsSync(wrapperSrc)) copyDir(wrapperSrc, path.join(destNm, tool.wrapper));
+  for (const suffix of ['', '-baseline']) {
+    const platPkg = tool.platformPrefix + suffix;
+    const platSrc = path.join(nm, platPkg);
+    if (fs.existsSync(platSrc)) {
+      copyDir(platSrc, path.join(destNm, platPkg));
+      log(`  ${platPkg} (${Math.round(sizeOf(platSrc) / 1024 / 1024)}MB)`);
+    }
+  }
+}
+const geminiSrc = path.join(nm, '@google', 'gemini-cli');
+if (fs.existsSync(geminiSrc)) {
+  copyDir(geminiSrc, path.join(destNm, '@google', 'gemini-cli'));
+  const geminiDeps = new Set();
+  collectDeps('@google/gemini-cli', geminiDeps);
+  for (const dep of geminiDeps) copyPkg(dep);
+  log(`  gemini-cli + ${geminiDeps.size} deps`);
+}
+
 log('Copying @anthropic-ai/claude-code ripgrep (win32)...');
 const claudeSrc = path.join(nm, '@anthropic-ai', 'claude-code');
 const claudeDest = path.join(destNm, '@anthropic-ai', 'claude-code');
@@ -157,17 +183,8 @@ if (process.env.NO_BUNDLE_MODELS === 'true') {
   }
 }
 
-fs.writeFileSync(path.join(out, 'README.txt'), [
-  '# AgentGUI Portable',
-  '',
-  'No installation required. Double-click agentgui.exe to start.',
-  '',
-  'Web interface: http://localhost:3000/gm/',
-  '',
-  'Data is stored in the data/ folder next to the executable.',
-  '',
-  'Requirements: None - fully self-contained.',
-].join('\n'));
+fs.writeFileSync(path.join(out, 'README.txt'),
+  '# AgentGUI Portable\n\nDouble-click agentgui.exe to start.\nWeb interface: http://localhost:3000/gm/\nData stored in data/ folder. Fully self-contained.\n');
 
 const totalMB = Math.round(sizeOf(out) / 1024 / 1024);
 log(`Build complete! Total: ${totalMB}MB  Output: ${out}`);

package/lib/acp-manager.js

@@ -0,0 +1,229 @@
+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';
+
+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; });
+
+  proc.on('close', (code) => {
+    entry.healthy = false;
+    if (shuttingDown || entry._stopping) return;
+    log(tool.id + ' exited code ' + code);
+    scheduleRestart(tool, entry.restarts);
+  });
+
+  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();
+  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; }
+  entry.lastHealthCheck = Date.now();
+}
+
+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);
+}
+
+export async function stopAll() {
+  shuttingDown = true;
+  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);
+      entry.process.on('close', () => { clearTimeout(t); resolve(); });
+      try { entry.process.kill('SIGTERM'); } catch (_) {}
+    }));
+  }
+  await Promise.all(kills);
+  processes.clear();
+  log('all stopped');
+}
+
+export function getStatus() {
+  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) {
+  const e = processes.get(agentId);
+  return e?.healthy ? e.port : null;
+}
+
+export function getRunningPorts() {
+  const ports = {};
+  for (const [id, e] of processes) if (e.healthy) ports[id] = e.port;
+  return ports;
+}
+
+export async function restart(agentId) {
+  const tool = ACP_TOOLS.find(t => t.id === agentId);
+  if (!tool) return false;
+  stopTool(agentId);
+  startProcess(tool);
+  return true;
+}
+
+export async function queryModels(agentId) {
+  const port = await ensureRunning(agentId);
+  if (!port) return [];
+  try {
+    const res = await fetch('http://127.0.0.1:' + port + '/provider', {
+      signal: AbortSignal.timeout(5000), headers: { 'Accept': 'application/json' }
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    const models = [];
+    for (const prov of (data.all || [])) {
+      for (const m of Object.values(prov.models || {})) {
+        models.push({ id: m.id, label: m.name || m.id, provider: prov.name || prov.id });
+      }
+    }
+    return 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);
+}
+
+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 } 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,32 @@ 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') {
+        const port = await ensureRunning(p.id);
+        if (port) {
+          try {
+            const data = await acpFetch(port, '/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.search', (p) => db.searchAgents(discoveredAgents, p.query || p));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.437",
+  "version": "1.0.439",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -33,7 +33,7 @@
     "fsbrowse": "^0.2.18",
     "google-auth-library": "^10.5.0",
     "onnxruntime-node": "1.21.0",
-    "opencode-ai": "latest",
+    "opencode-ai": "^1.2.15",
     "puppeteer-core": "^24.37.5",
     "webtalk": "^1.0.31",
     "ws": "^8.14.2"

package/server.js

@@ -22,6 +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, touch as touchACP } from './lib/acp-manager.js';
 
 
 process.on('uncaughtException', (err, origin) => {
@@ -432,24 +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' && agent.acpPort) {
-      try {
-        const res = await fetch(`http://localhost:${agent.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 (_) {}
+    if (agent?.protocol === 'acp') {
+      try { models = await queryACPModels(agentId); } catch (_) {}
     }
   }
   modelCache.set(agentId, { models, timestamp: Date.now() });
@@ -1747,6 +1738,11 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (pathOnly === '/api/acp/status' && req.method === 'GET') {
+      sendJSON(req, res, 200, { tools: getACPStatus() });
+      return;
+    }
+
     if (pathOnly === '/api/ws-stats' && req.method === 'GET') {
       const stats = wsOptimizer.getStats();
       sendJSON(req, res, 200, stats);
@@ -3154,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) {
@@ -3965,7 +3962,11 @@ if (watch) {
 
 process.on('SIGTERM', () => {
   console.log('[SIGNAL] SIGTERM received - graceful shutdown');
-  wss.close(() => server.close(() => process.exit(0)));
+  stopACPTools().then(() => {
+    wss.close(() => server.close(() => process.exit(0)));
+  }).catch(() => {
+    wss.close(() => server.close(() => process.exit(0)));
+  });
 });
 
 server.on('error', (err) => {
@@ -4168,6 +4169,21 @@ function onServerReady() {
 
   resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
 
+  startACPTools().then(() => {
+    setTimeout(() => {
+      const acpStatus = getACPStatus();
+      for (const s of acpStatus) {
+        if (s.healthy) {
+          const agent = discoveredAgents.find(a => a.id === s.id);
+          if (agent) { agent.acpPort = s.port; }
+        }
+      }
+      if (acpStatus.length > 0) {
+        console.log(`[ACP] Tools ready: ${acpStatus.filter(s => s.healthy).map(s => s.id + ':' + s.port).join(', ') || 'none healthy yet'}`);
+      }
+    }, 6000);
+  }).catch(err => console.error('[ACP] Startup error:', err.message));
+
   ensureModelsDownloaded().then(async ok => {
     if (ok) console.log('[MODELS] Speech models ready');
     else console.log('[MODELS] Speech model download failed');