agentgui 1.0.453 → 1.0.454

package/lib/tool-manager.js

@@ -0,0 +1,285 @@
+import { spawn } from 'child_process';
+import { execSync } from 'child_process';
+import os from 'os';
+import path from 'path';
+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') },
+  { id: 'gm-kilo', name: 'Kilo', pkg: '@kilocode/cli', binary: 'kilo', marker: path.join(os.homedir(), '.config', 'kilo', 'agents') },
+  { id: 'gm-cc', name: 'Claude Code', pkg: '@anthropic-sdk/claude-code', binary: 'claude', marker: path.join(os.homedir(), '.config', 'claude', 'agents') },
+];
+
+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);
+}
+
+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;
+  }
+}
+
+export async function checkForUpdates(toolId, currentVersion) {
+  const tool = getTool(toolId);
+  if (!tool || !currentVersion) 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 (latestVersion) {
+      versionCache.set(toolId, { version: latestVersion, timestamp: Date.now() });
+      return { hasUpdate: compareVersions(currentVersion, latestVersion), latestVersion };
+    }
+
+    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;
+}
+
+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' };
+  }
+
+  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);
+  }
+}
+
+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 (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' };
+  }
+
+  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);
+  }
+}
+
+export function getAllTools() {
+  return TOOLS.map(tool => {
+    const status = checkToolStatus(tool.id);
+    return { ...tool, ...status };
+  });
+}
+
+export function getToolConfig(toolId) {
+  return getTool(toolId) || null;
+}

package/package.json

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

package/server.js

@@ -24,6 +24,7 @@ import { register as registerRunHandlers } from './lib/ws-handlers-run.js';
 import { register as registerUtilHandlers } from './lib/ws-handlers-util.js';
 import { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, queryModels as queryACPModels, touch as touchACP } from './lib/acp-manager.js';
 import { installGMAgentConfigs } from './lib/gm-agent-configs.js';
+import * as toolManager from './lib/tool-manager.js';
 
 
 process.on('uncaughtException', (err, origin) => {
@@ -1780,6 +1781,141 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (pathOnly === '/api/tools' && req.method === 'GET') {
+      console.log('[TOOLS-API] Handling GET /api/tools');
+      const tools = toolManager.getAllTools();
+      const toolsWithUpdates = await Promise.all(tools.map(async (t) => {
+        if (t.installed) {
+          const updates = await toolManager.checkForUpdates(t.id, t.version);
+          return { ...t, hasUpdate: updates.hasUpdate, latestVersion: updates.latestVersion };
+        }
+        return { ...t, hasUpdate: false, latestVersion: null };
+      }));
+      sendJSON(req, res, 200, { tools: toolsWithUpdates });
+      return;
+    }
+
+    if (pathOnly.match(/^\/api\/tools\/([^/]+)\/status$/)) {
+      const toolId = pathOnly.match(/^\/api\/tools\/([^/]+)\/status$/)[1];
+      const status = toolManager.checkToolStatus(toolId);
+      if (!status) {
+        sendJSON(req, res, 404, { error: 'Tool not found' });
+        return;
+      }
+      if (status.installed) {
+        const updates = await toolManager.checkForUpdates(toolId, status.version);
+        status.hasUpdate = updates.hasUpdate;
+        status.latestVersion = updates.latestVersion;
+      }
+      sendJSON(req, res, 200, status);
+      return;
+    }
+
+    if (pathOnly.match(/^\/api\/tools\/([^/]+)\/install$/) && req.method === 'POST') {
+      const toolId = pathOnly.match(/^\/api\/tools\/([^/]+)\/install$/)[1];
+      const tool = toolManager.getToolConfig(toolId);
+      if (!tool) {
+        sendJSON(req, res, 404, { error: 'Tool not found' });
+        return;
+      }
+      queries.updateToolStatus(toolId, { status: 'installing' });
+      sendJSON(req, res, 200, { success: true, installing: true, estimatedTime: 60000 });
+      toolManager.install(toolId, (msg) => {
+        if (wsOptimizer && wsOptimizer.broadcast) {
+          wsOptimizer.broadcast({ type: 'tool_install_progress', toolId, data: msg });
+        }
+      }).then((result) => {
+        if (result.success) {
+          queries.updateToolStatus(toolId, { status: 'installed', version: result.version, installed_at: Date.now() });
+          if (wsOptimizer && wsOptimizer.broadcast) {
+            wsOptimizer.broadcast({ type: 'tool_install_complete', toolId, data: result });
+          }
+          queries.addToolInstallHistory(toolId, 'install', 'success', null);
+        } else {
+          queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
+          if (wsOptimizer && wsOptimizer.broadcast) {
+            wsOptimizer.broadcast({ type: 'tool_install_failed', toolId, data: result });
+          }
+          queries.addToolInstallHistory(toolId, 'install', 'failed', result.error);
+        }
+      });
+      return;
+    }
+
+    if (pathOnly.match(/^\/api\/tools\/([^/]+)\/update$/) && req.method === 'POST') {
+      const toolId = pathOnly.match(/^\/api\/tools\/([^/]+)\/update$/)[1];
+      const body = await parseBody(req);
+      const tool = toolManager.getToolConfig(toolId);
+      if (!tool) {
+        sendJSON(req, res, 404, { error: 'Tool not found' });
+        return;
+      }
+      const current = toolManager.checkToolStatus(toolId);
+      if (!current || !current.installed) {
+        sendJSON(req, res, 400, { error: 'Tool not installed' });
+        return;
+      }
+      queries.updateToolStatus(toolId, { status: 'updating' });
+      sendJSON(req, res, 200, { success: true, updating: true });
+      toolManager.update(toolId, body.targetVersion, (msg) => {
+        if (wsOptimizer && wsOptimizer.broadcast) {
+          wsOptimizer.broadcast({ type: 'tool_update_progress', toolId, data: msg });
+        }
+      }).then((result) => {
+        if (result.success) {
+          queries.updateToolStatus(toolId, { status: 'installed', version: result.version, installed_at: Date.now() });
+          if (wsOptimizer && wsOptimizer.broadcast) {
+            wsOptimizer.broadcast({ type: 'tool_update_complete', toolId, data: result });
+          }
+          queries.addToolInstallHistory(toolId, 'update', 'success', null);
+        } else {
+          queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
+          if (wsOptimizer && wsOptimizer.broadcast) {
+            wsOptimizer.broadcast({ type: 'tool_update_failed', toolId, data: result });
+          }
+          queries.addToolInstallHistory(toolId, 'update', 'failed', result.error);
+        }
+      });
+      return;
+    }
+
+    if (pathOnly.match(/^\/api\/tools\/([^/]+)\/history$/) && req.method === 'GET') {
+      const toolId = pathOnly.match(/^\/api\/tools\/([^/]+)\/history$/)[1];
+      const url = new URL(req.url, 'http://localhost');
+      const limit = Math.min(parseInt(url.searchParams.get('limit')) || 20, 100);
+      const offset = parseInt(url.searchParams.get('offset')) || 0;
+      const history = queries.getToolInstallHistory(toolId, limit, offset);
+      sendJSON(req, res, 200, { history });
+      return;
+    }
+
+    if (pathOnly === '/api/tools/refresh-all' && req.method === 'POST') {
+      sendJSON(req, res, 200, { refreshing: true, toolCount: 4 });
+      if (wsOptimizer && wsOptimizer.broadcast) {
+        wsOptimizer.broadcast({ type: 'tools_refresh_started' });
+      }
+      setImmediate(async () => {
+        const tools = toolManager.getAllTools();
+        for (const tool of tools) {
+          queries.updateToolStatus(tool.id, {
+            status: tool.installed ? 'installed' : 'not_installed',
+            version: tool.version,
+            last_check_at: Date.now()
+          });
+          if (tool.installed) {
+            const updates = await toolManager.checkForUpdates(tool.id, tool.version);
+            if (updates.hasUpdate) {
+              queries.updateToolStatus(tool.id, { update_available: 1, latest_version: updates.latestVersion });
+            }
+          }
+        }
+        if (wsOptimizer && wsOptimizer.broadcast) {
+          wsOptimizer.broadcast({ type: 'tools_refresh_complete', data: tools });
+        }
+      });
+      return;
+    }
+
     if (pathOnly === '/api/ws-stats' && req.method === 'GET') {
       const stats = wsOptimizer.getStats();
       sendJSON(req, res, 200, stats);
@@ -4213,6 +4349,7 @@ function onServerReady() {
   installGMAgentConfigs().catch(err => console.error('[GM-CONFIG] Startup error:', err.message));
 
   startACPTools().then(() => {
+    console.log('[ACP] On-demand startup enabled (ACP tools start when first used)');
     setTimeout(() => {
       const acpStatus = getACPStatus();
       for (const s of acpStatus) {
@@ -4227,6 +4364,20 @@ function onServerReady() {
     }, 6000);
   }).catch(err => console.error('[ACP] Startup error:', err.message));
 
+  const toolIds = ['gm-oc', 'gm-gc', 'gm-kilo', 'gm-cc'];
+  queries.initializeToolInstallations(toolIds.map(id => ({ id })));
+  for (const toolId of toolIds) {
+    const status = toolManager.checkToolStatus(toolId);
+    if (status) {
+      queries.updateToolStatus(toolId, {
+        status: status.installed ? 'installed' : 'not_installed',
+        version: status.version,
+        last_check_at: Date.now()
+      });
+    }
+  }
+  console.log('[TOOLS] Initialization complete');
+
   ensureModelsDownloaded().then(async ok => {
     if (ok) console.log('[MODELS] Speech models ready');
     else console.log('[MODELS] Speech model download failed');

package/static/index.html

@@ -1238,6 +1238,16 @@
       100% { border-color: var(--color-border); }
     }
 
+    /* ===== TOOLS VIEW ===== */
+    .tools-container {
+      flex: 1;
+      min-height: 0;
+      overflow-y: auto;
+      overflow-x: hidden;
+      padding: 1.5rem 2rem;
+      -webkit-overflow-scrolling: touch;
+    }
+
     .voice-mic-btn.recording {
       background: var(--color-error);
       border-color: var(--color-error);
@@ -3111,6 +3121,7 @@
         <button class="view-toggle-btn" data-view="files">Files</button>
         <button class="view-toggle-btn" data-view="voice" id="voiceTabBtn" style="display:none;">Voice</button>
         <button class="view-toggle-btn" data-view="terminal" id="terminalTabBtn">Terminal</button>
+        <button class="view-toggle-btn" data-view="tools">Tools</button>
       </div>
 
       <!-- Messages scroll area -->
@@ -3174,6 +3185,11 @@
         </div>
       </div>
 
+      <!-- Tools management view -->
+      <div id="toolsContainer" class="tools-container" style="display:none;">
+        <div id="tool-status-container"></div>
+      </div>
+
       <!-- Input area: fixed at bottom -->
       <div class="input-section">
         <div class="input-wrapper">
@@ -3243,6 +3259,7 @@
   <script defer src="/gm/js/conversations.js"></script>
   <script defer src="/gm/js/terminal.js"></script>
   <script defer src="/gm/js/script-runner.js"></script>
+  <script defer src="/gm/js/tool-status.js"></script>
   <script defer src="/gm/js/client.js"></script>
   <script type="module" src="/gm/js/voice.js"></script>
   <script defer src="/gm/js/features.js"></script>

package/static/js/features.js

@@ -149,6 +149,7 @@
     var fileIframe = document.getElementById('fileBrowserIframe');
     var voiceContainer = document.getElementById('voiceContainer');
     var terminalContainer = document.getElementById('terminalContainer');
+    var toolsContainer = document.getElementById('toolsContainer');
     if (!bar) return;
     bar.querySelectorAll('.view-toggle-btn').forEach(function(btn) {
       btn.classList.toggle('active', btn.dataset.view === view);
@@ -158,6 +159,7 @@
     if (fileBrowser) fileBrowser.style.display = view === 'files' ? 'flex' : 'none';
     if (voiceContainer) voiceContainer.style.display = view === 'voice' ? 'flex' : 'none';
     if (terminalContainer) terminalContainer.style.display = view === 'terminal' ? 'flex' : 'none';
+    if (toolsContainer) toolsContainer.style.display = view === 'tools' ? 'flex' : 'none';
     if (view === 'files' && fileIframe && currentConversation) {
       var src = BASE + '/files/' + currentConversation + '/';
       if (fileIframe.src !== location.origin + src) fileIframe.src = src;