agentgui 1.0.582 → 1.0.583

package/docs/index.html

@@ -364,6 +364,31 @@
     </div>
   </section>
 
+  <!-- Why AgentGUI -->
+  <section class="section">
+    <div class="container">
+      <h2 class="section-title">Why AgentGUI?</h2>
+      <p class="section-subtitle">Stop juggling multiple terminal windows. Work with all your AI agents in one unified interface.</p>
+
+      <div class="features-grid">
+        <div class="feature-card">
+          <h3>📊 Compare Side-by-Side</h3>
+          <p>Test the same prompt across Claude Code, Gemini CLI, OpenCode, and others to find the best approach for your task.</p>
+        </div>
+
+        <div class="feature-card">
+          <h3>💾 Never Lose Context</h3>
+          <p>Every conversation, file change, and terminal output is automatically saved. Resume interrupted work exactly where you left off.</p>
+        </div>
+
+        <div class="feature-card">
+          <h3>👁️ See Everything</h3>
+          <p>Watch streaming responses, file changes, and tool calls in real-time instead of parsing raw JSON in your terminal.</p>
+        </div>
+      </div>
+    </div>
+  </section>
+
   <!-- Features -->
   <section class="section" style="background: #f9fafb;">
     <div class="container">
@@ -450,6 +475,46 @@
     </div>
   </section>
 
+  <!-- Use Cases -->
+  <section class="section">
+    <div class="container">
+      <h2 class="section-title">Use Cases</h2>
+      <p class="section-subtitle">Practical scenarios where AgentGUI shines</p>
+
+      <div class="features-grid">
+        <div class="feature-card">
+          <h3>Multi-Agent Comparison</h3>
+          <p>Run the same task through different agents to compare approaches, code quality, and execution speed.</p>
+        </div>
+
+        <div class="feature-card">
+          <h3>Long-Running Projects</h3>
+          <p>Build complex features across multiple sessions without losing context or conversation history.</p>
+        </div>
+
+        <div class="feature-card">
+          <h3>Team Collaboration</h3>
+          <p>Share conversation URLs and working directories for pair programming with AI agents.</p>
+        </div>
+
+        <div class="feature-card">
+          <h3>Agent Development</h3>
+          <p>Test and debug custom agents with full visibility into streaming events and tool calls.</p>
+        </div>
+
+        <div class="feature-card">
+          <h3>Offline Speech</h3>
+          <p>Use local speech-to-text and text-to-speech without API costs or internet dependency.</p>
+        </div>
+
+        <div class="feature-card">
+          <h3>Code Review Sessions</h3>
+          <p>Review AI-generated changes in a visual diff view with file browser integration.</p>
+        </div>
+      </div>
+    </div>
+  </section>
+
   <!-- Architecture -->
   <section class="section" style="background: #f9fafb;">
     <div class="container">

package/lib/acp-sdk-manager.js

@@ -0,0 +1,225 @@
+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 HEALTH_INTERVAL_MS = 30000;
+const STARTUP_GRACE_MS = 5000;
+const MAX_RESTARTS = 10;
+const RESTART_WINDOW_MS = 300000;
+const IDLE_TIMEOUT_MS = 120000;
+
+const processes = new Map();
+let healthTimer = null;
+let shuttingDown = false;
+
+function log(msg) { console.log('[ACP-SDK] ' + 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 cmd = resolveBinary(tool.cmd);
+  const entry = {
+    id: tool.id,
+    port: tool.port,
+    startedAt: Date.now(),
+    lastUsed: Date.now(),
+    lastHealthCheck: 0,
+    healthy: false,
+    process: null,
+    pid: null,
+    restarts: [],
+    idleTimer: null,
+    providerInfo: null,
+    _stopping: false
+  };
+
+  try {
+    entry.process = spawn(cmd, tool.args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: false
+    });
+    entry.pid = entry.process.pid;
+
+    entry.process.on('close', (code) => {
+      entry.healthy = false;
+      if (shuttingDown || entry._stopping) return;
+      log(tool.id + ' exited code ' + code);
+      const window = Date.now() - RESTART_WINDOW_MS;
+      entry.restarts = entry.restarts.filter(t => t > window);
+      if (entry.restarts.length < MAX_RESTARTS) {
+        const delay = Math.min(1000 * Math.pow(2, entry.restarts.length), 30000);
+        entry.restarts.push(Date.now());
+        setTimeout(() => startProcess(tool), delay);
+      } else {
+        log(tool.id + ' max restarts reached');
+      }
+    });
+
+    processes.set(tool.id, entry);
+    log(tool.id + ' started port ' + tool.port + ' pid ' + entry.pid);
+    setTimeout(() => checkHealth(tool.id), STARTUP_GRACE_MS);
+    resetIdleTimer(tool.id);
+  } catch (err) {
+    log(tool.id + ' spawn failed: ' + err.message);
+  }
+
+  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);
+}
+
+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)
+    });
+    entry.healthy = res.ok;
+    if (res.ok) {
+      entry.providerInfo = await res.json();
+    }
+  } 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,
+      providerInfo: e?.providerInfo || null,
+    };
+  });
+}
+
+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 + '/models', {
+      signal: AbortSignal.timeout(3000)
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.models || [];
+  } catch (_) { return []; }
+}
+
+export function isAvailable(agentId) {
+  const tool = ACP_TOOLS.find(t => t.id === agentId);
+  return !!tool;
+}

package/lib/ws-handlers-session.js

@@ -2,7 +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';
+import { ensureRunning, touch, queryModels } from './acp-sdk-manager.js';
 
 function spawnScript(cmd, args, convId, scriptName, agentId, deps) {
   const { activeScripts, broadcastSync, modelCache } = deps;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.582",
+  "version": "1.0.583",
   "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, ensureRunning, queryModels as queryACPModels, touch as touchACP } from './lib/acp-manager.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 { installGMAgentConfigs } from './lib/gm-agent-configs.js';
 import * as toolManager from './lib/tool-manager.js';
 import { pm2Manager } from './lib/pm2-manager.js';
@@ -398,27 +398,54 @@ function findCommand(cmd) {
 }
 
 async function queryACPServerAgents(baseUrl) {
-  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}`);
+  const endpoint = baseUrl.endsWith('/') ? baseUrl + 'agents/search' : baseUrl + '/agents/search';
+  try {
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+      body: JSON.stringify({}),
+      signal: AbortSignal.timeout(5000)
+    });
+    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 [];
+    }
+    return data.agents.map(agent => ({
+      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',
+      path: baseUrl
+    }));
+  } catch (error) {
+    console.error(`ACP agents query failed for ${baseUrl}: ${error.message}`);
     return [];
   }
-
-  return result.data.agents.map(agent => {
-    const complete = extractCompleteAgentData(agent);
-    return {
-      ...complete,
-      path: baseUrl
-    };
-  });
 }
 
 function discoverAgents() {

package/static/js/client.js

@@ -1317,11 +1317,11 @@ class AgentGUIClient {
     this.enableControls();
   }
 
-  handleAllConversationsDeleted(data) {
+  async handleAllConversationsDeleted(data) {
     this.state.currentConversation = null;
     window.dispatchEvent(new CustomEvent('conversation-deselected'));
     if (window.conversationManager) {
-      window.conversationManager.loadConversations();
+      await window.conversationManager.loadConversations();
     }
   }