agentgui 1.0.583 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.583",
+  "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

@@ -4144,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

@@ -1319,10 +1319,17 @@ class AgentGUIClient {
 
   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) {
+      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-manager.js

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

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);
-}