agentgui 1.0.582 → 1.0.584

package/CLAUDE.md

@@ -350,3 +350,39 @@ queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: D
 - Database persists across page reload ✓
 - Frontend shows "Up-to-date" or "Update available" ✓
 - Tool install history records the action ✓
+
+---
+
+## ACP SDK Integration
+
+### Current Status
+- **@agentclientprotocol/sdk** (`^0.4.1`) has been added to dependencies
+- The SDK is positioned as the main protocol for client-server and server-ACP tools communication
+
+### Clear All Conversations Fix
+
+**Issue:** After clicking "Clear All Conversations", the conversation threads would reappear in the sidebar.
+
+**Root Cause:** The `all_conversations_deleted` broadcast event was being sent by the server (in `lib/ws-handlers-conv.js`), but:
+1. The event type was not in the `BROADCAST_TYPES` set in `server.js`, so it wasn't being broadcast to all clients
+2. The conversation manager (`static/js/conversations.js`) had no handler for this event type
+3. Client cleanup in `handleAllConversationsDeleted` was incomplete
+
+**Solution Applied:**
+1. Added `'all_conversations_deleted'` to `BROADCAST_TYPES` set (server.js:4147)
+2. Added event handler in conversation manager to clear all local state (conversations.js:573-577)
+3. Enhanced client cleanup to clear all caches and state before reloading (client.js:1321-1330)
+
+**Files Modified:**
+- `server.js`: Added `all_conversations_deleted` to BROADCAST_TYPES
+- `static/js/conversations.js`: Added handler for all_conversations_deleted event
+- `static/js/client.js`: Enhanced handleAllConversationsDeleted with complete state cleanup
+
+### Next Steps for Full ACP SDK Integration
+The ACP SDK dependency has been added. Full integration would involve:
+1. Replacing custom WebSocket protocol with ACP SDK's RPC/messaging layer
+2. Updating `lib/acp-manager.js` to use ACP SDK for ACP tool communication
+3. Migrating `lib/ws-protocol.js` handlers to use ACP SDK message types
+4. Updating client-side WebSocket handlers to work with ACP SDK events
+
+This refactoring is optional and can be done incrementally as needed.

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-manager.js → acp-sdk-manager.js}

@@ -1,164 +1,225 @@
-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 HEALTH_INTERVAL_MS = 30000;
-const STARTUP_GRACE_MS = 5000;
-const processes = new Map();
-let healthTimer = null;
-let shuttingDown = false;
-
-function log(msg) { console.log('[ACP] ' + msg); }
-
-function startProcess(tool) {
-  if (shuttingDown) return null;
-  const existing = processes.get(tool.id);
-  if (existing?.process && !existing.process.killed) return existing;
-
-  const entry = startProc(tool, log);
-  if (!entry) return null;
-
-  entry.process.on('close', (code) => {
-    entry.healthy = false;
-    if (shuttingDown || entry._stopping) return;
-    log(tool.id + ' exited code ' + code);
-    scheduleRestart(tool, entry.restarts, log, startProcess, () => shuttingDown);
-  });
-
-  processes.set(tool.id, entry);
-  log(tool.id + ' started port ' + tool.port + ' pid ' + entry.process.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);
-}
-
-async function checkHealth(toolId) {
-  const entry = processes.get(toolId);
-  if (!entry || shuttingDown) return;
-
-  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) {
-  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');
-    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;
-}
+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.584",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -21,6 +21,7 @@
     "postinstall": "node scripts/patch-fsbrowse.js"
   },
   "dependencies": {
+    "@agentclientprotocol/sdk": "^0.4.1",
     "@anthropic-ai/claude-code": "^2.1.37",
     "@google/gemini-cli": "latest",
     "@huggingface/transformers": "^3.8.1",

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() {
@@ -4117,7 +4144,7 @@ wss.on('connection', (ws, req) => {
 
 const BROADCAST_TYPES = new Set([
   'message_created', 'conversation_created', 'conversation_updated',
-  'conversations_updated', 'conversation_deleted', 'queue_status', 'queue_updated',
+  'conversations_updated', 'conversation_deleted', 'all_conversations_deleted', 'queue_status', 'queue_updated',
   'rate_limit_hit', 'rate_limit_clear',
   'script_started', 'script_stopped', 'script_output',
   'model_download_progress', 'stt_progress', 'tts_setup_progress', 'voice_list',

package/static/js/client.js

@@ -1317,12 +1317,19 @@ class AgentGUIClient {
     this.enableControls();
   }
 
-  handleAllConversationsDeleted(data) {
+  async handleAllConversationsDeleted(data) {
     this.state.currentConversation = null;
+    this.state.conversations = [];
+    this.state.sessionEvents = [];
+    this.conversationCache.clear();
+    this.conversationListCache = { data: [], timestamp: 0, ttl: 30000 };
+    this.draftPrompts.clear();
     window.dispatchEvent(new CustomEvent('conversation-deselected'));
     if (window.conversationManager) {
-      window.conversationManager.loadConversations();
+      this.state.currentConversation = null;
+      await window.conversationManager.loadConversations();
     }
+    this.clearOutput();
   }
 
   isHtmlContent(text) {

package/static/js/conversations.js

@@ -568,6 +568,11 @@ class ConversationManager {
         this.updateConversation(msg.conversation.id, msg.conversation);
       } else if (msg.type === 'conversation_deleted') {
         this.deleteConversation(msg.conversationId);
+      } else if (msg.type === 'all_conversations_deleted') {
+        this.conversations = [];
+        this.activeId = null;
+        this.streamingConversations.clear();
+        this.showEmpty('No conversations yet');
       } else if (msg.type === 'streaming_start' && msg.conversationId) {
         this.streamingConversations.add(msg.conversationId);
         this.render();

package/lib/acp-http-client.js

@@ -1,125 +0,0 @@
-/**
- * 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-process-lifecycle.js

@@ -1,65 +0,0 @@
-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);
-}