agentgui 1.0.454 → 1.0.455

package/lib/tool-manager.js

@@ -6,11 +6,6 @@ import fs from 'fs';
 import fetch from 'node-fetch';
 
 const isWindows = os.platform() === 'win32';
-const INSTALL_TIMEOUT_MS = 300000;
-const VERSION_TIMEOUT_MS = 3000;
-const REGISTRY_TIMEOUT_MS = 5000;
-const VERSION_CACHE_MS = 3600000;
-
 const TOOLS = [
   { id: 'gm-oc', name: 'OpenCode', pkg: 'gm-oc', binary: 'opencode', marker: path.join(os.homedir(), '.config', 'opencode', 'agents') },
   { id: 'gm-gc', name: 'Gemini CLI', pkg: 'gm-gc', binary: 'gemini', marker: path.join(os.homedir(), '.gemini', 'extensions', 'gm', 'agents') },
@@ -21,265 +16,73 @@ const TOOLS = [
 const versionCache = new Map();
 const installLocks = new Map();
 
-function log(msg) { console.log('[TOOL-MANAGER] ' + msg); }
-
-function getTool(toolId) {
-  return TOOLS.find(t => t.id === toolId);
-}
+const getTool = (id) => TOOLS.find(t => t.id === id);
+const isInstalled = (tool) => {
+  const ext = isWindows ? '.cmd' : '';
+  if (fs.existsSync(path.join(process.cwd(), 'node_modules', '.bin', tool.binary + ext))) return true;
+  try { execSync(`${isWindows ? 'where' : 'which'} ${tool.binary}`, { stdio: 'pipe', timeout: 2000 }); return true; } catch (_) { return false; }
+};
+const detectVersion = (binary) => { try { const o = execSync(`${binary} --version 2>&1 || ${binary} -v 2>&1`, { timeout: 3000, encoding: 'utf8', stdio: 'pipe' }); return o.match(/(\d+\.\d+\.\d+)/)?.[1] || null; } catch (_) { return null; } };
+const cmpVer = (v1, v2) => { const [a,b] = [v1?.split('.')?.map(Number) || [], v2?.split('.')?.map(Number) || []]; for(let i=0;i<3;i++) { const n1=a[i]||0, n2=b[i]||0; if(n1<n2)return true; if(n1>n2)return false; } return false; };
 
 export function checkToolStatus(toolId) {
   const tool = getTool(toolId);
   if (!tool) return null;
-
-  const timestamp = Date.now();
-  let installed = false;
-  let hasConfig = false;
-  let version = null;
-
-  const ext = isWindows ? '.cmd' : '';
-  const localBin = path.join(process.cwd(), 'node_modules', '.bin', tool.binary + ext);
-  if (fs.existsSync(localBin)) {
-    installed = true;
-  } else {
-    try {
-      const which = isWindows ? 'where' : 'which';
-      execSync(`${which} ${tool.binary}`, { stdio: 'pipe', timeout: 2000 });
-      installed = true;
-    } catch (_) {
-      installed = false;
-    }
-  }
-
-  if (fs.existsSync(tool.marker)) {
-    hasConfig = true;
-  }
-
-  if (installed && !hasConfig) {
-    installed = false;
-  }
-
-  if (installed) {
-    version = detectVersionSync(tool);
-  }
-
-  return { toolId, installed, version, hasConfig, timestamp };
-}
-
-function detectVersionSync(tool) {
-  try {
-    const output = execSync(`${tool.binary} --version 2>&1 || ${tool.binary} -v 2>&1`, {
-      timeout: VERSION_TIMEOUT_MS,
-      encoding: 'utf8',
-      stdio: 'pipe'
-    });
-    const match = output.match(/(\d+\.\d+\.\d+)/);
-    return match ? match[1] : null;
-  } catch (_) {
-    return null;
-  }
+  const installed = isInstalled(tool) && fs.existsSync(tool.marker);
+  const version = installed ? detectVersion(tool.binary) : null;
+  return { toolId, installed, version, timestamp: Date.now() };
 }
 
 export async function checkForUpdates(toolId, currentVersion) {
+  if (!currentVersion) return { hasUpdate: false, latestVersion: null };
   const tool = getTool(toolId);
-  if (!tool || !currentVersion) return { hasUpdate: false, latestVersion: null };
+  if (!tool) return { hasUpdate: false, latestVersion: null };
 
   try {
     const cached = versionCache.get(toolId);
-    if (cached && Date.now() - cached.timestamp < VERSION_CACHE_MS) {
-      return compareVersions(currentVersion, cached.version) ? { hasUpdate: true, latestVersion: cached.version } : { hasUpdate: false };
-    }
-
-    const response = await fetch(`https://registry.npmjs.org/${tool.pkg}`, {
-      timeout: REGISTRY_TIMEOUT_MS,
-      headers: { 'Accept': 'application/json' }
-    });
-
-    if (!response.ok) return { hasUpdate: false, latestVersion: null };
-
-    const data = await response.json();
-    const latestVersion = data['dist-tags']?.latest;
+    if (cached && Date.now() - cached.timestamp < 3600000) return { hasUpdate: cmpVer(currentVersion, cached.version), latestVersion: cached.version };
 
-    if (latestVersion) {
-      versionCache.set(toolId, { version: latestVersion, timestamp: Date.now() });
-      return { hasUpdate: compareVersions(currentVersion, latestVersion), latestVersion };
-    }
+    const res = await fetch(`https://registry.npmjs.org/${tool.pkg}`, { timeout: 5000, headers: { 'Accept': 'application/json' } });
+    if (!res.ok) return { hasUpdate: false, latestVersion: null };
 
+    const data = await res.json();
+    const latest = data['dist-tags']?.latest;
+    if (latest) { versionCache.set(toolId, { version: latest, timestamp: Date.now() }); return { hasUpdate: cmpVer(currentVersion, latest), latestVersion: latest }; }
     return { hasUpdate: false, latestVersion: null };
-  } catch (_) {
-    return { hasUpdate: false, latestVersion: null };
-  }
+  } catch (_) { return { hasUpdate: false, latestVersion: null }; }
 }
 
-function compareVersions(v1, v2) {
-  const p1 = v1.split('.').map(Number);
-  const p2 = v2.split('.').map(Number);
-  for (let i = 0; i < 3; i++) {
-    const n1 = p1[i] || 0;
-    const n2 = p2[i] || 0;
-    if (n1 > n2) return false;
-    if (n1 < n2) return true;
-  }
-  return false;
-}
+const spawnProc = (toolId, tool, pkg, onProgress) => new Promise((resolve) => {
+  const proc = spawn(isWindows ? 'npx.cmd' : 'npx', ['--yes', pkg], { stdio: ['pipe', 'pipe', 'pipe'], timeout: 300000, shell: isWindows });
+  let completed = false, stderr = '';
+  const timer = setTimeout(() => { if (!completed) { completed = true; try { proc.kill('SIGKILL'); } catch (_) {} resolve({ success: false, error: 'Timeout (5min)' }); }}, 300000);
+  proc.stdout.on('data', (d) => { if (onProgress) onProgress({ type: 'progress', data: d.toString() }); });
+  proc.stderr.on('data', (d) => { stderr += d.toString(); if (onProgress) onProgress({ type: 'error', data: d.toString() }); });
+  proc.on('close', (code) => { clearTimeout(timer); if (completed) return; completed = true; if (code === 0) { const s = checkToolStatus(toolId); resolve(s?.installed ? { success: true, error: null, version: s.version } : { success: false, error: 'Tool not detected' }); } else { resolve({ success: false, error: stderr.substring(0, 1000) || 'Failed' }); } });
+  proc.on('error', (err) => { clearTimeout(timer); if (!completed) { completed = true; resolve({ success: false, error: err.message }); }});
+});
 
 export async function install(toolId, onProgress) {
   const tool = getTool(toolId);
   if (!tool) return { success: false, error: 'Tool not found' };
-
-  if (installLocks.get(toolId)) {
-    return { success: false, error: 'Install already in progress' };
-  }
-
+  if (installLocks.get(toolId)) return { success: false, error: 'Install in progress' };
   installLocks.set(toolId, true);
-
-  try {
-    return new Promise((resolve) => {
-      const npxCmd = isWindows ? 'npx.cmd' : 'npx';
-      const proc = spawn(npxCmd, ['--yes', tool.pkg], {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: INSTALL_TIMEOUT_MS,
-        shell: isWindows
-      });
-
-      let stdout = '';
-      let stderr = '';
-      let completed = false;
-
-      const timer = setTimeout(() => {
-        if (!completed) {
-          completed = true;
-          try { proc.kill('SIGKILL'); } catch (_) {}
-          resolve({ success: false, error: 'Installation timeout (5 minutes)' });
-        }
-      }, INSTALL_TIMEOUT_MS);
-
-      proc.stdout.on('data', (d) => {
-        stdout += d.toString();
-        if (onProgress) onProgress({ type: 'progress', data: d.toString() });
-      });
-
-      proc.stderr.on('data', (d) => {
-        stderr += d.toString();
-        if (onProgress) onProgress({ type: 'error', data: d.toString() });
-      });
-
-      proc.on('close', (code) => {
-        clearTimeout(timer);
-        if (completed) return;
-        completed = true;
-
-        if (code === 0) {
-          const status = checkToolStatus(toolId);
-          if (status && status.installed) {
-            resolve({ success: true, error: null, version: status.version });
-          } else {
-            resolve({ success: false, error: 'Install completed but tool not detected' });
-          }
-        } else {
-          const error = stderr.substring(0, 1000) || 'Installation failed';
-          resolve({ success: false, error });
-        }
-      });
-
-      proc.on('error', (err) => {
-        clearTimeout(timer);
-        if (completed) return;
-        completed = true;
-        resolve({ success: false, error: err.message });
-      });
-    });
-  } finally {
-    installLocks.delete(toolId);
-  }
+  try { return await spawnProc(toolId, tool, tool.pkg, onProgress); } finally { installLocks.delete(toolId); }
 }
 
 export async function update(toolId, targetVersion, onProgress) {
   const tool = getTool(toolId);
   if (!tool) return { success: false, error: 'Tool not found' };
-
   const current = checkToolStatus(toolId);
-  if (!current || !current.installed) {
-    return { success: false, error: 'Tool not installed' };
-  }
+  if (!current?.installed) return { success: false, error: 'Tool not installed' };
+  if (installLocks.get(toolId)) return { success: false, error: 'Install in progress' };
 
-  if (installLocks.get(toolId)) {
-    return { success: false, error: 'Install already in progress' };
-  }
-
-  const target = targetVersion || await checkForUpdates(toolId, current.version).then(r => r.latestVersion);
-  if (!target) {
-    return { success: false, error: 'Unable to determine target version' };
-  }
+  const target = targetVersion || (await checkForUpdates(toolId, current.version)).latestVersion;
+  if (!target) return { success: false, error: 'Unable to determine target version' };
 
   installLocks.set(toolId, true);
-
-  try {
-    return new Promise((resolve) => {
-      const npxCmd = isWindows ? 'npx.cmd' : 'npx';
-      const pkg = `${tool.pkg}@${target}`;
-      const proc = spawn(npxCmd, ['--yes', pkg], {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: INSTALL_TIMEOUT_MS,
-        shell: isWindows
-      });
-
-      let stderr = '';
-      let completed = false;
-
-      const timer = setTimeout(() => {
-        if (!completed) {
-          completed = true;
-          try { proc.kill('SIGKILL'); } catch (_) {}
-          resolve({ success: false, error: 'Update timeout (5 minutes)' });
-        }
-      }, INSTALL_TIMEOUT_MS);
-
-      proc.stdout.on('data', (d) => {
-        if (onProgress) onProgress({ type: 'progress', data: d.toString() });
-      });
-
-      proc.stderr.on('data', (d) => {
-        stderr += d.toString();
-        if (onProgress) onProgress({ type: 'error', data: d.toString() });
-      });
-
-      proc.on('close', (code) => {
-        clearTimeout(timer);
-        if (completed) return;
-        completed = true;
-
-        if (code === 0) {
-          const status = checkToolStatus(toolId);
-          if (status && status.installed) {
-            resolve({ success: true, error: null, version: status.version });
-          } else {
-            resolve({ success: false, error: 'Update completed but tool not detected' });
-          }
-        } else {
-          const error = stderr.substring(0, 1000) || 'Update failed';
-          resolve({ success: false, error });
-        }
-      });
-
-      proc.on('error', (err) => {
-        clearTimeout(timer);
-        if (completed) return;
-        completed = true;
-        resolve({ success: false, error: err.message });
-      });
-    });
-  } finally {
-    installLocks.delete(toolId);
-  }
+  try { return await spawnProc(toolId, tool, `${tool.pkg}@${target}`, onProgress); } finally { installLocks.delete(toolId); }
 }
 
-export function getAllTools() {
-  return TOOLS.map(tool => {
-    const status = checkToolStatus(tool.id);
-    return { ...tool, ...status };
-  });
-}
-
-export function getToolConfig(toolId) {
-  return getTool(toolId) || null;
-}
+export function getAllTools() { return TOOLS.map(tool => ({ ...tool, ...checkToolStatus(tool.id) })); }
+export function getToolConfig(toolId) { return getTool(toolId) || null; }

package/package.json

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

package/static/index.html

@@ -3035,6 +3035,7 @@
     .toast-error { background: var(--color-error); color: white; }
     .toast-warning { background: var(--color-warning); color: white; }
   </style>
+  <link rel="stylesheet" href="/gm/css/tool-status.css">
 </head>
 <body>
   <!-- Sidebar overlay (mobile) -->

package/static/js/tool-status.js

@@ -1,323 +1,48 @@
 const ToolStatusComponent = {
-  state: {
-    tools: [],
-    expandedTool: null,
-    refreshing: false
-  },
+  state: { tools: [], refreshing: false },
 
   init() {
     this.loadTools();
     if (window.wsManager) {
-      window.wsManager.on('tool_install_started', (data) => this.handleInstallStarted(data));
-      window.wsManager.on('tool_install_progress', (data) => this.handleProgress(data));
-      window.wsManager.on('tool_install_complete', (data) => this.handleInstallComplete(data));
-      window.wsManager.on('tool_install_failed', (data) => this.handleInstallFailed(data));
-      window.wsManager.on('tool_update_complete', (data) => this.handleUpdateComplete(data));
-      window.wsManager.on('tool_update_failed', (data) => this.handleUpdateFailed(data));
-      window.wsManager.on('tools_refresh_complete', (data) => this.handleRefreshComplete(data));
+      const events = ['tool_install_started', 'tool_install_progress', 'tool_install_complete', 'tool_install_failed', 'tool_update_complete', 'tool_update_failed', 'tools_refresh_complete'];
+      events.forEach(e => window.wsManager.on(e, (d) => this.handleEvent(e, d)));
     }
   },
 
   async loadTools() {
-    try {
-      const res = await fetch('/gm/api/tools');
-      const data = await res.json();
-      this.state.tools = data.tools || [];
-      this.render();
-    } catch (e) {
-      console.error('[TOOL-STATUS] Load failed:', e.message);
-    }
-  },
-
-  async installTool(toolId) {
-    try {
-      const res = await fetch(`/gm/api/tools/${toolId}/install`, { method: 'POST' });
-      const data = await res.json();
-      if (data.success) {
-        const tool = this.state.tools.find(t => t.id === toolId);
-        if (tool) tool.status = 'installing';
-        this.render();
-      } else {
-        alert('Install failed: ' + (data.error || 'Unknown error'));
-      }
-    } catch (e) {
-      alert('Install failed: ' + e.message);
-    }
-  },
-
-  async updateTool(toolId) {
-    try {
-      const res = await fetch(`/gm/api/tools/${toolId}/update`, { method: 'POST', body: JSON.stringify({}) });
-      const data = await res.json();
-      if (data.success) {
-        const tool = this.state.tools.find(t => t.id === toolId);
-        if (tool) tool.status = 'updating';
-        this.render();
-      } else {
-        alert('Update failed: ' + (data.error || 'Unknown error'));
-      }
-    } catch (e) {
-      alert('Update failed: ' + e.message);
-    }
-  },
-
-  async refreshTools() {
-    this.state.refreshing = true;
-    this.render();
-    try {
-      await fetch('/gm/api/tools/refresh-all', { method: 'POST' });
-    } catch (e) {
-      console.error('[TOOL-STATUS] Refresh failed:', e.message);
-    }
+    try { const res = await fetch('/gm/api/tools'); this.state.tools = (await res.json()).tools || []; this.render(); } catch (e) { console.error('[TOOL-STATUS]', e.message); }
   },
 
-  handleInstallStarted(data) {
-    const tool = this.state.tools.find(t => t.id === data.toolId);
-    if (tool) {
-      tool.status = 'installing';
-      tool.progress = 0;
-      this.render();
-    }
+  async act(action, toolId) {
+    try { const res = await fetch(`/gm/api/tools/${toolId}/${action}`, { method: 'POST' }); const data = await res.json(); if (!data.success) alert(`${action} failed: ${data.error || 'Unknown error'}`); } catch (e) { alert(`${action} failed: ${e.message}`); }
   },
 
-  handleProgress(data) {
-    const tool = this.state.tools.find(t => t.id === data.toolId);
-    if (tool) {
-      tool.progress = Math.min((tool.progress || 0) + 5, 90);
-      this.render();
-    }
-  },
+  async refreshTools() { this.state.refreshing = true; this.render(); try { await fetch('/gm/api/tools/refresh-all', { method: 'POST' }); } catch (e) { console.error('[TOOL-STATUS]', e.message); } },
 
-  handleInstallComplete(data) {
+  handleEvent(event, data) {
     const tool = this.state.tools.find(t => t.id === data.toolId);
-    if (tool) {
-      tool.status = 'installed';
-      tool.version = data.data.version;
-      tool.progress = 100;
-      this.render();
-      setTimeout(() => this.loadTools(), 1000);
-    }
-  },
-
-  handleInstallFailed(data) {
-    const tool = this.state.tools.find(t => t.id === data.toolId);
-    if (tool) {
-      tool.status = 'failed';
-      tool.error_message = data.data.error;
-      tool.progress = 0;
-      this.render();
-    }
-  },
-
-  handleUpdateComplete(data) {
-    const tool = this.state.tools.find(t => t.id === data.toolId);
-    if (tool) {
-      tool.status = 'installed';
-      tool.version = data.data.version;
-      tool.hasUpdate = false;
-      tool.progress = 100;
-      this.render();
-      setTimeout(() => this.loadTools(), 1000);
-    }
-  },
-
-  handleUpdateFailed(data) {
-    const tool = this.state.tools.find(t => t.id === data.toolId);
-    if (tool) {
-      tool.status = 'failed';
-      tool.error_message = data.data.error;
-      this.render();
-    }
+    if (!tool) return;
+    if (event === 'tool_install_started') { tool.status = 'installing'; tool.progress = 0; }
+    else if (event === 'tool_install_progress') { tool.progress = Math.min((tool.progress || 0) + 5, 90); }
+    else if (event.includes('_complete')) { tool.status = 'installed'; tool.version = data.data.version; tool.hasUpdate = false; tool.progress = 100; setTimeout(() => this.loadTools(), 1000); }
+    else if (event.includes('_failed')) { tool.status = 'failed'; tool.error_message = data.data.error; tool.progress = 0; }
+    else if (event === 'tools_refresh_complete') { this.state.refreshing = false; this.loadTools(); return; }
+    this.render();
   },
 
-  handleRefreshComplete(data) {
-    this.state.refreshing = false;
-    this.loadTools();
-  },
+  getStatusColor(tool) { return tool.status === 'installed' && !tool.hasUpdate ? '#4CAF50' : tool.status === 'installed' && tool.hasUpdate ? '#FFC107' : ['installing', 'updating'].includes(tool.status) ? '#2196F3' : tool.status === 'failed' ? '#F44336' : '#9E9E9E'; },
 
-  getStatusColor(tool) {
-    if (tool.status === 'installed' && !tool.hasUpdate) return '#4CAF50';
-    if (tool.status === 'installed' && tool.hasUpdate) return '#FFC107';
-    if (tool.status === 'installing' || tool.status === 'updating') return '#2196F3';
-    if (tool.status === 'failed') return '#F44336';
-    return '#9E9E9E';
-  },
-
-  getStatusText(tool) {
-    if (tool.status === 'installed') {
-      if (tool.hasUpdate) return `Update available (v${tool.latestVersion})`;
-      return `Installed v${tool.version || '?'}`;
-    }
-    if (tool.status === 'installing') return 'Installing...';
-    if (tool.status === 'updating') return 'Updating...';
-    if (tool.status === 'failed') return 'Failed';
-    return 'Not installed';
-  },
+  getStatusText(tool) { return tool.status === 'installed' ? (tool.hasUpdate ? `Update available (v${tool.latestVersion})` : `Installed v${tool.version || '?'}`) : tool.status === 'installing' ? 'Installing...' : tool.status === 'updating' ? 'Updating...' : tool.status === 'failed' ? 'Failed' : 'Not installed'; },
 
   render() {
-    const container = document.getElementById('tool-status-container');
-    if (!container) return;
-
-    const html = `
-      <div class="tool-status-header">
-        <h3>Tools</h3>
-        <button onclick="window.toolStatus.refreshTools()" ${this.state.refreshing ? 'disabled' : ''} class="tool-refresh-btn">
-          ${this.state.refreshing ? 'Refreshing...' : 'Refresh'}
-        </button>
-      </div>
-      <div class="tool-grid">
-        ${this.state.tools.map(tool => `
-          <div class="tool-card" style="border-left: 4px solid ${this.getStatusColor(tool)}">
-            <div class="tool-name">${tool.name || tool.id}</div>
-            <div class="tool-status">${this.getStatusText(tool)}</div>
-            ${tool.progress !== undefined && (tool.status === 'installing' || tool.status === 'updating') ? `
-              <div class="tool-progress">
-                <div class="progress-bar" style="width: ${tool.progress}%"></div>
-              </div>
-            ` : ''}
-            <div class="tool-actions">
-              ${!tool.installed ? `
-                <button onclick="window.toolStatus.installTool('${tool.id}')" class="tool-btn tool-btn-primary">Install</button>
-              ` : tool.hasUpdate ? `
-                <button onclick="window.toolStatus.updateTool('${tool.id}')" class="tool-btn tool-btn-primary">Update</button>
-              ` : `
-                <button onclick="window.toolStatus.refreshTools()" class="tool-btn tool-btn-secondary">Check Updates</button>
-              `}
-              ${tool.status === 'failed' ? `
-                <button onclick="window.toolStatus.installTool('${tool.id}')" class="tool-btn tool-btn-warning">Retry</button>
-              ` : ''}
-              ${tool.error_message ? `
-                <div class="tool-error" title="${tool.error_message}">
-                  Error: ${tool.error_message.substring(0, 30)}...
-                  <a href="#" onclick="alert('${tool.error_message.replace(/"/g, '\\"')}'); return false;">Details</a>
-                </div>
-              ` : ''}
-            </div>
-          </div>
-        `).join('')}
-      </div>
-      <style>
-        #tool-status-container {
-          padding: 16px;
-          border: 1px solid #e0e0e0;
-          border-radius: 4px;
-          margin-bottom: 16px;
-        }
-        .tool-status-header {
-          display: flex;
-          justify-content: space-between;
-          align-items: center;
-          margin-bottom: 16px;
-        }
-        .tool-status-header h3 {
-          margin: 0;
-          font-size: 18px;
-        }
-        .tool-refresh-btn {
-          padding: 6px 12px;
-          background: #2196F3;
-          color: white;
-          border: none;
-          border-radius: 4px;
-          cursor: pointer;
-          font-size: 12px;
-        }
-        .tool-refresh-btn:disabled {
-          opacity: 0.6;
-          cursor: not-allowed;
-        }
-        .tool-grid {
-          display: grid;
-          grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
-          gap: 12px;
-        }
-        .tool-card {
-          padding: 12px;
-          border: 1px solid #ddd;
-          border-radius: 4px;
-          background: #f9f9f9;
-        }
-        .tool-name {
-          font-weight: bold;
-          margin-bottom: 4px;
-          font-size: 14px;
-        }
-        .tool-status {
-          font-size: 12px;
-          color: #666;
-          margin-bottom: 8px;
-        }
-        .tool-progress {
-          width: 100%;
-          height: 6px;
-          background: #e0e0e0;
-          border-radius: 3px;
-          overflow: hidden;
-          margin-bottom: 8px;
-        }
-        .progress-bar {
-          height: 100%;
-          background: #4CAF50;
-          transition: width 0.3s;
-        }
-        .tool-actions {
-          display: flex;
-          flex-direction: column;
-          gap: 6px;
-        }
-        .tool-btn {
-          padding: 6px;
-          border: none;
-          border-radius: 3px;
-          cursor: pointer;
-          font-size: 12px;
-          white-space: nowrap;
-        }
-        .tool-btn-primary {
-          background: #2196F3;
-          color: white;
-        }
-        .tool-btn-primary:hover {
-          background: #1976D2;
-        }
-        .tool-btn-secondary {
-          background: #f0f0f0;
-          color: #333;
-          border: 1px solid #ddd;
-        }
-        .tool-btn-secondary:hover {
-          background: #e0e0e0;
-        }
-        .tool-btn-warning {
-          background: #FF9800;
-          color: white;
-        }
-        .tool-btn-warning:hover {
-          background: #F57C00;
-        }
-        .tool-error {
-          font-size: 11px;
-          color: #F44336;
-          padding: 6px;
-          background: #ffebee;
-          border-radius: 2px;
-          margin-top: 4px;
-        }
-        .tool-error a {
-          color: #C62828;
-          text-decoration: underline;
-          cursor: pointer;
-        }
-      </style>
+    const c = document.getElementById('tool-status-container');
+    if (!c) return;
+    c.innerHTML = `
+      <div class="tool-status-header"><h3>Tools</h3><button onclick="window.toolStatus.refreshTools()" ${this.state.refreshing ? 'disabled' : ''} class="tool-refresh-btn">${this.state.refreshing ? 'Refreshing...' : 'Refresh'}</button></div>
+      <div class="tool-grid">${this.state.tools.map(t => `<div class="tool-card" style="border-left: 4px solid ${this.getStatusColor(t)}"><div class="tool-name">${t.name || t.id}</div><div class="tool-status">${this.getStatusText(t)}</div>${t.progress !== undefined && ['installing', 'updating'].includes(t.status) ? `<div class="tool-progress"><div class="progress-bar" style="width: ${t.progress}%"></div></div>` : ''}<div class="tool-actions">${!t.installed ? `<button onclick="window.toolStatus.act('install','${t.id}')" class="tool-btn tool-btn-primary">Install</button>` : t.hasUpdate ? `<button onclick="window.toolStatus.act('update','${t.id}')" class="tool-btn tool-btn-primary">Update</button>` : `<button onclick="window.toolStatus.refreshTools()" class="tool-btn tool-btn-secondary">Check Updates</button>`}${t.status === 'failed' ? `<button onclick="window.toolStatus.act('install','${t.id}')" class="tool-btn tool-btn-warning">Retry</button>` : ''}${t.error_message ? `<div class="tool-error" title="${t.error_message}">Error: ${t.error_message.substring(0, 30)}...<a href="#" onclick="alert('${t.error_message.replace(/"/g, '\\"')}'); return false;">Details</a></div>` : ''}</div></div>`).join('')}</div>
     `;
-
-    container.innerHTML = html;
     window.toolStatus = this;
   }
 };
 
-if (document.readyState === 'loading') {
-  document.addEventListener('DOMContentLoaded', () => ToolStatusComponent.init());
-} else {
-  ToolStatusComponent.init();
-}
+if (document.readyState === 'loading') { document.addEventListener('DOMContentLoaded', () => ToolStatusComponent.init()); } else { ToolStatusComponent.init(); }

package/test-acp-endpoints.js

@@ -1,119 +0,0 @@
-#!/usr/bin/env node
-
-const http = require('http');
-
-const BASE_URL = '/gm';
-const PORT = 3000;
-
-function makeRequest(method, path, body = null) {
-  return new Promise((resolve, reject) => {
-    const options = {
-      hostname: 'localhost',
-      port: PORT,
-      path: BASE_URL + path,
-      method: method,
-      headers: body ? {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(JSON.stringify(body))
-      } : {}
-    };
-
-    const req = http.request(options, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        try {
-          resolve({ status: res.statusCode, data: data ? JSON.parse(data) : null, raw: data });
-        } catch {
-          resolve({ status: res.statusCode, data: null, raw: data });
-        }
-      });
-    });
-
-    req.on('error', reject);
-
-    if (body) {
-      req.write(JSON.stringify(body));
-    }
-    req.end();
-  });
-}
-
-async function runTests() {
-  console.log('Testing ACP Agents & Stateless Runs Endpoints\n');
-
-  const tests = [
-    {
-      name: 'POST /api/agents/search - empty search',
-      test: async () => {
-        const res = await makeRequest('POST', '/api/agents/search', {});
-        return res.status === 200 && res.data.agents !== undefined;
-      }
-    },
-    {
-      name: 'POST /api/agents/search - search by name',
-      test: async () => {
-        const res = await makeRequest('POST', '/api/agents/search', { name: 'Claude' });
-        return res.status === 200 && Array.isArray(res.data.agents);
-      }
-    },
-    {
-      name: 'GET /api/agents/claude-code',
-      test: async () => {
-        const res = await makeRequest('GET', '/api/agents/claude-code');
-        return res.status === 200 || res.status === 404;
-      }
-    },
-    {
-      name: 'GET /api/agents/claude-code/descriptor',
-      test: async () => {
-        const res = await makeRequest('GET', '/api/agents/claude-code/descriptor');
-        return (res.status === 200 && res.data.metadata && res.data.specs) || res.status === 404;
-      }
-    },
-    {
-      name: 'POST /api/runs/search',
-      test: async () => {
-        const res = await makeRequest('POST', '/api/runs/search', {});
-        return res.status === 200 && res.data.runs !== undefined;
-      }
-    },
-    {
-      name: 'POST /api/runs - missing agent_id',
-      test: async () => {
-        const res = await makeRequest('POST', '/api/runs', {});
-        return res.status === 422;
-      }
-    }
-  ];
-
-  let passed = 0;
-  let failed = 0;
-
-  for (const t of tests) {
-    try {
-      const success = await t.test();
-      if (success) {
-        console.log(`✓ ${t.name}`);
-        passed++;
-      } else {
-        console.log(`✗ ${t.name}`);
-        failed++;
-      }
-    } catch (err) {
-      console.log(`✗ ${t.name} - ${err.message}`);
-      failed++;
-    }
-  }
-
-  console.log(`\nResults: ${passed} passed, ${failed} failed`);
-  process.exit(failed > 0 ? 1 : 0);
-}
-
-http.get(`http://localhost:${PORT}${BASE_URL}/`, (res) => {
-  console.log('Server is running\n');
-  runTests();
-}).on('error', () => {
-  console.log('Server is not running. Please start with: npm run dev');
-  process.exit(1);
-});

package/test-wave4-ui.mjs

@@ -1,141 +0,0 @@
-#!/usr/bin/env node
-/**
- * Wave 4 UI Consistency Test
- * Tests agent/model persistence and display consolidation
- */
-
-import http from 'http';
-
-const BASE_URL = process.env.BASE_URL || 'http://localhost:3000';
-const API_BASE = `${BASE_URL}/gm/api`;
-
-function request(method, path, body = null) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(path, API_BASE);
-    const options = {
-      method,
-      headers: body ? { 'Content-Type': 'application/json' } : {}
-    };
-
-    const req = http.request(url, options, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          resolve({ status: res.statusCode, data: data ? JSON.parse(data) : null });
-        } catch (e) {
-          resolve({ status: res.statusCode, data });
-        }
-      });
-    });
-
-    req.on('error', reject);
-    if (body) req.write(JSON.stringify(body));
-    req.end();
-  });
-}
-
-async function test() {
-  console.log('=== Wave 4 UI Consistency Tests ===\n');
-
-  try {
-    // Test 1: Create conversation with specific agent and model
-    console.log('Test 1: Create conversation with agent and model');
-    const createRes = await request('POST', '/conversations', {
-      agentId: 'claude-code',
-      title: 'Wave 4 Test Conversation',
-      workingDirectory: '/tmp/test',
-      model: 'claude-sonnet-4-5'
-    });
-
-    if (createRes.status !== 200) {
-      console.error('❌ Failed to create conversation:', createRes.status);
-      return;
-    }
-
-    const conversation = createRes.data.conversation;
-    console.log('✓ Created conversation:', conversation.id);
-    console.log('  - agentId:', conversation.agentId);
-    console.log('  - model:', conversation.model);
-
-    // Test 2: Fetch conversation and verify agent/model are returned
-    console.log('\nTest 2: Fetch conversation via /full endpoint');
-    const fullRes = await request('GET', `/conversations/${conversation.id}/full`);
-
-    if (fullRes.status !== 200) {
-      console.error('❌ Failed to fetch conversation:', fullRes.status);
-      return;
-    }
-
-    const fullConv = fullRes.data.conversation;
-    console.log('✓ Fetched conversation');
-    console.log('  - agentId:', fullConv.agentId);
-    console.log('  - agentType:', fullConv.agentType);
-    console.log('  - model:', fullConv.model);
-
-    if (!fullConv.agentId && !fullConv.agentType) {
-      console.error('❌ agentId/agentType missing from response');
-    } else {
-      console.log('✓ agentId/agentType present');
-    }
-
-    if (!fullConv.model) {
-      console.error('❌ model missing from response');
-    } else {
-      console.log('✓ model present');
-    }
-
-    // Test 3: List conversations and verify agent/model in list
-    console.log('\nTest 3: List conversations');
-    const listRes = await request('GET', '/conversations');
-
-    if (listRes.status !== 200) {
-      console.error('❌ Failed to list conversations:', listRes.status);
-      return;
-    }
-
-    const listedConv = listRes.data.conversations.find(c => c.id === conversation.id);
-    if (!listedConv) {
-      console.error('❌ Conversation not found in list');
-      return;
-    }
-
-    console.log('✓ Conversation in list');
-    console.log('  - agentId:', listedConv.agentId);
-    console.log('  - agentType:', listedConv.agentType);
-    console.log('  - model:', listedConv.model);
-
-    // Test 4: Update conversation model
-    console.log('\nTest 4: Update conversation model');
-    const updateRes = await request('POST', `/conversations/${conversation.id}`, {
-      model: 'claude-opus-4-6'
-    });
-
-    if (updateRes.status !== 200) {
-      console.error('❌ Failed to update conversation:', updateRes.status);
-      return;
-    }
-
-    const updatedConv = updateRes.data.conversation;
-    console.log('✓ Updated conversation');
-    console.log('  - model:', updatedConv.model);
-
-    if (updatedConv.model !== 'claude-opus-4-6') {
-      console.error('❌ Model not updated correctly');
-    } else {
-      console.log('✓ Model updated correctly');
-    }
-
-    // Cleanup
-    console.log('\nCleanup: Deleting test conversation');
-    await request('DELETE', `/conversations/${conversation.id}`);
-    console.log('✓ Deleted test conversation');
-
-    console.log('\n=== All Tests Passed ===');
-  } catch (error) {
-    console.error('❌ Test error:', error.message);
-    process.exit(1);
-  }
-}
-
-test();

package/test-ws-optimization.js

@@ -1,277 +0,0 @@
-#!/usr/bin/env node
-/**
- * WebSocket Optimization Integration Test
- *
- * Verifies all Wave 4 Item 4.2 requirements:
- * - Subscription-based broadcasting
- * - Message batching (streaming_progress)
- * - Compression for large payloads
- * - Priority queue (high/normal/low)
- * - Rate limiting (100 msg/sec)
- * - Message deduplication
- * - Bandwidth monitoring
- */
-
-import fs from 'fs';
-import { WSOptimizer } from './lib/ws-optimizer.js';
-
-console.log('=== WebSocket Optimization Integration Test ===\n');
-
-let testsPassed = 0;
-let testsFailed = 0;
-
-function pass(testName, details = []) {
-  console.log(`✓ ${testName}`);
-  details.forEach(d => console.log(`  ${d}`));
-  console.log();
-  testsPassed++;
-}
-
-function fail(testName, reason) {
-  console.log(`✗ ${testName}`);
-  console.log(`  Reason: ${reason}\n`);
-  testsFailed++;
-}
-
-// Test 1: WSOptimizer class exists and is properly structured
-console.log('Test 1: Verifying WSOptimizer class structure...');
-try {
-  const optimizer = new WSOptimizer();
-  if (typeof optimizer.sendToClient === 'function' &&
-      typeof optimizer.removeClient === 'function' &&
-      typeof optimizer.getStats === 'function') {
-    pass('WSOptimizer class structure', [
-      'sendToClient method: present',
-      'removeClient method: present',
-      'getStats method: present'
-    ]);
-  } else {
-    fail('WSOptimizer class structure', 'Missing required methods');
-  }
-} catch (error) {
-  fail('WSOptimizer class structure', error.message);
-}
-
-// Test 2: Priority queue implementation
-console.log('Test 2: Verifying priority queue implementation...');
-const optimizerCode = fs.readFileSync('./lib/ws-optimizer.js', 'utf8');
-
-const priorityChecks = {
-  highPriority: optimizerCode.includes('this.highPriority'),
-  normalPriority: optimizerCode.includes('this.normalPriority'),
-  lowPriority: optimizerCode.includes('this.lowPriority'),
-  getPriority: optimizerCode.includes('function getPriority'),
-  priorityLevels: optimizerCode.includes('streaming_error') &&
-                  optimizerCode.includes('streaming_progress') &&
-                  optimizerCode.includes('model_download_progress')
-};
-
-if (Object.values(priorityChecks).every(v => v)) {
-  pass('Priority queue implementation', [
-    'High priority queue: present',
-    'Normal priority queue: present',
-    'Low priority queue: present',
-    'Priority classification: present',
-    'Message types classified: errors (high), progress (normal), downloads (low)'
-  ]);
-} else {
-  fail('Priority queue implementation', 'Missing priority queue components');
-}
-
-// Test 3: Batching implementation
-console.log('Test 3: Verifying message batching...');
-const batchingChecks = {
-  scheduleFlush: optimizerCode.includes('scheduleFlush'),
-  batchInterval: optimizerCode.includes('getBatchInterval'),
-  maxBatchSize: optimizerCode.includes('splice(0, 10)'), // max 10 normal messages
-  adaptiveBatching: optimizerCode.includes('BATCH_BY_TIER') &&
-                    optimizerCode.includes('latencyTier')
-};
-
-if (Object.values(batchingChecks).every(v => v)) {
-  pass('Message batching', [
-    'Scheduled batch flushing: present',
-    'Adaptive batch intervals: 16-200ms based on latency',
-    'Max batch size: 10 normal + 5 low priority messages',
-    'Latency-aware batching: present'
-  ]);
-} else {
-  fail('Message batching', 'Missing batching components');
-}
-
-// Test 4: Compression implementation
-console.log('Test 4: Verifying compression...');
-const compressionChecks = {
-  zlibImport: optimizerCode.includes("import zlib from 'zlib'"),
-  gzipSync: optimizerCode.includes('gzipSync'),
-  threshold: optimizerCode.includes('payload.length > 1024'),
-  compressionRatio: optimizerCode.includes('compressed.length < payload.length * 0.9')
-};
-
-if (Object.values(compressionChecks).every(v => v)) {
-  pass('Compression implementation', [
-    'zlib module imported: yes',
-    'Compression method: gzip',
-    'Compression threshold: 1KB',
-    'Compression ratio check: only send if >10% savings'
-  ]);
-} else {
-  fail('Compression implementation', 'Missing compression components');
-}
-
-// Test 5: Rate limiting
-console.log('Test 5: Verifying rate limiting...');
-const rateLimitChecks = {
-  messageCount: optimizerCode.includes('this.messageCount'),
-  windowTracking: optimizerCode.includes('this.windowStart'),
-  limit100: optimizerCode.includes('messagesThisSecond > 100'),
-  rateLimitWarning: optimizerCode.includes('rate limited'),
-  windowReset: optimizerCode.includes('windowDuration >= 1000')
-};
-
-if (Object.values(rateLimitChecks).every(v => v)) {
-  pass('Rate limiting', [
-    'Message count tracking: present',
-    'Time window tracking: 1 second',
-    'Rate limit: 100 messages/sec',
-    'Warning on limit exceeded: yes',
-    'Automatic window reset: yes'
-  ]);
-} else {
-  fail('Rate limiting', 'Missing rate limiting components');
-}
-
-// Test 6: Deduplication
-console.log('Test 6: Verifying message deduplication...');
-const deduplicationChecks = {
-  lastMessage: optimizerCode.includes('this.lastMessage'),
-  deduplicationCheck: optimizerCode.includes('if (this.lastMessage === data) return'),
-  assignment: optimizerCode.includes('this.lastMessage = data')
-};
-
-if (Object.values(deduplicationChecks).every(v => v)) {
-  pass('Message deduplication', [
-    'Last message tracking: present',
-    'Deduplication check: skips identical consecutive messages',
-    'Message tracking update: present'
-  ]);
-} else {
-  fail('Message deduplication', 'Missing deduplication components');
-}
-
-// Test 7: Bandwidth monitoring
-console.log('Test 7: Verifying bandwidth monitoring...');
-const monitoringChecks = {
-  bytesSent: optimizerCode.includes('this.bytesSent'),
-  bandwidthCalc: optimizerCode.includes('/ 1024 / 1024'),
-  highBandwidthWarning: optimizerCode.includes('high bandwidth'),
-  threshold: optimizerCode.includes('3 * 1024 * 1024'), // 3MB over 3 seconds = 1MB/s
-  getStats: optimizerCode.includes('getStats()')
-};
-
-if (Object.values(monitoringChecks).every(v => v)) {
-  pass('Bandwidth monitoring', [
-    'Bytes sent tracking: present',
-    'MB/sec calculation: present',
-    'High bandwidth warning: >1MB/sec sustained',
-    'Statistics API: getStats() method available',
-    'Per-client monitoring: yes'
-  ]);
-} else {
-  fail('Bandwidth monitoring', 'Missing monitoring components');
-}
-
-// Test 8: Subscription filtering in server.js
-console.log('Test 8: Verifying subscription-based broadcasting...');
-const serverCode = fs.readFileSync('./server.js', 'utf8');
-
-const subscriptionChecks = {
-  subscriptionIndex: serverCode.includes('subscriptionIndex'),
-  broadcastTypes: serverCode.includes('BROADCAST_TYPES'),
-  targetedDelivery: serverCode.includes('const targets = new Set()'),
-  sessionIdFiltering: serverCode.includes('event.sessionId') && serverCode.includes('subscriptionIndex.get'),
-  conversationIdFiltering: serverCode.includes('event.conversationId') && serverCode.includes('conv-')
-};
-
-if (Object.values(subscriptionChecks).every(v => v)) {
-  pass('Subscription-based broadcasting', [
-    'Subscription index: tracks client subscriptions',
-    'Broadcast types: global messages (conversation_created, etc.)',
-    'Targeted delivery: session/conversation-specific messages',
-    'Session ID filtering: only send to subscribed clients',
-    'Conversation ID filtering: only send to subscribed clients'
-  ]);
-} else {
-  fail('Subscription-based broadcasting', 'Missing subscription filtering');
-}
-
-// Test 9: Integration verification
-console.log('Test 9: Verifying broadcastSync integration...');
-const integrationChecks = {
-  wsOptimizerUsage: serverCode.includes('wsOptimizer.sendToClient'),
-  wsOptimizerInstance: serverCode.includes('new WSOptimizer()'),
-  broadcastSyncFunction: serverCode.includes('function broadcastSync'),
-  clientRemoval: serverCode.includes('wsOptimizer.removeClient')
-};
-
-if (Object.values(integrationChecks).every(v => v)) {
-  pass('broadcastSync integration', [
-    'WSOptimizer instantiated: yes',
-    'Used in broadcastSync: yes',
-    'Client cleanup on disconnect: yes',
-    'All broadcasts route through optimizer: yes'
-  ]);
-} else {
-  fail('broadcastSync integration', 'WSOptimizer not properly integrated');
-}
-
-// Test 10: Adaptive batching based on latency
-console.log('Test 10: Verifying adaptive batching...');
-const adaptiveChecks = {
-  batchByTier: optimizerCode.includes('BATCH_BY_TIER'),
-  tierLevels: optimizerCode.includes('excellent') &&
-              optimizerCode.includes('good') &&
-              optimizerCode.includes('fair') &&
-              optimizerCode.includes('poor'),
-  trendAdaptation: optimizerCode.includes('latencyTrend') &&
-                   optimizerCode.includes('rising') &&
-                   optimizerCode.includes('falling'),
-  intervalRange: optimizerCode.includes('16') && optimizerCode.includes('200')
-};
-
-if (Object.values(adaptiveChecks).every(v => v)) {
-  pass('Adaptive batching', [
-    'Latency-based intervals: 16ms (excellent) to 200ms (bad)',
-    'Tier levels: excellent, good, fair, poor, bad',
-    'Trend adaptation: adjusts interval based on latency trend',
-    'Dynamic optimization: yes'
-  ]);
-} else {
-  fail('Adaptive batching', 'Missing adaptive batching features');
-}
-
-// Summary
-console.log('=== Test Summary ===');
-console.log(`Total tests: ${testsPassed + testsFailed}`);
-console.log(`Passed: ${testsPassed}`);
-console.log(`Failed: ${testsFailed}`);
-console.log(`Success rate: ${((testsPassed / (testsPassed + testsFailed)) * 100).toFixed(1)}%\n`);
-
-if (testsFailed === 0) {
-  console.log('✓ All WebSocket optimization requirements verified!\n');
-  console.log('Wave 4 Item 4.2 Implementation Summary:');
-  console.log('────────────────────────────────────────');
-  console.log('✓ Subscription filtering: Only broadcasts to subscribed clients');
-  console.log('✓ Message batching: Max 10 normal + 5 low priority per flush');
-  console.log('✓ Adaptive intervals: 16-200ms based on latency tier');
-  console.log('✓ Compression: gzip for payloads >1KB (>10% savings)');
-  console.log('✓ Priority queuing: High (errors) > Normal (progress) > Low (downloads)');
-  console.log('✓ Rate limiting: 100 messages/sec per client');
-  console.log('✓ Deduplication: Skips identical consecutive messages');
-  console.log('✓ Bandwidth monitoring: Warns if >1MB/sec sustained');
-  console.log('\nExpected bandwidth reduction: 60-80% for high-frequency streaming');
-  process.exit(0);
-} else {
-  console.log('✗ Some optimization requirements not met');
-  process.exit(1);
-}