agentgui 1.0.466 → 1.0.468

package/lib/tool-manager.js

@@ -1,114 +1,124 @@
 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 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: 'gm-kilo', binary: 'kilo', marker: path.join(os.homedir(), '.config', 'kilo', 'agents') },
-  { id: 'gm-cc', name: 'Claude Code', pkg: 'gm-cc', binary: 'claude', marker: path.join(os.homedir(), '.config', 'claude', 'agents') },
+  { id: 'gm-oc', name: 'OpenCode', pkg: 'gm-oc' },
+  { id: 'gm-gc', name: 'Gemini CLI', pkg: 'gm-gc' },
+  { id: 'gm-kilo', name: 'Kilo', pkg: 'gm-kilo' },
+  { id: 'gm-cc', name: 'Claude Code', pkg: 'gm-cc' },
 ];
 
-const versionCache = new Map();
+const statusCache = new Map();
 const installLocks = new Map();
 
 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) => {
-  const versionPatterns = ['--version', '-v', '-V', '--help'];
-  for (const flag of versionPatterns) {
-    try {
-      const o = execSync(`${binary} ${flag} 2>&1`, { timeout: 2000, encoding: 'utf8', stdio: 'pipe' });
-      const match = o.match(/(\d+\.\d+\.\d+)/);
-      if (match?.[1]) return match[1];
-    } catch (_) {}
-  }
+
+const checkToolViaBunx = async (pkg) => {
   try {
-    const binPath = execSync(`${isWindows ? 'where' : 'which'} ${binary}`, { timeout: 2000, encoding: 'utf8', stdio: 'pipe' }).trim();
-    let pkgDir = path.dirname(binPath);
-    for (let i = 0; i < 5; i++) {
-      const pkgPath = path.join(pkgDir, 'package.json');
-      if (fs.existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-          if (pkg.version && pkg.version.match(/\d+\.\d+\.\d+/)) {
-            return pkg.version.match(/(\d+\.\d+\.\d+)/)[1];
-          }
-        } catch (_) {}
-      }
-      pkgDir = path.dirname(pkgDir);
-    }
-  } catch (_) {}
-  return null;
+    const cmd = isWindows ? 'bunx.cmd' : 'bunx';
+    return new Promise((resolve) => {
+      const proc = spawn(cmd, [pkg, '--version'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10000,
+        shell: isWindows
+      });
+      let stdout = '', stderr = '';
+      proc.stdout.on('data', (d) => { stdout += d.toString(); });
+      proc.stderr.on('data', (d) => { stderr += d.toString(); });
+      const timer = setTimeout(() => {
+        try { proc.kill('SIGKILL'); } catch (_) {}
+        resolve({ installed: false, isUpToDate: false, upgradeNeeded: true, output: 'timeout' });
+      }, 10000);
+      proc.on('close', (code) => {
+        clearTimeout(timer);
+        const output = stdout + stderr;
+        const installed = output.length > 0;
+        const upgradeNeeded = output.includes('Upgrading') || output.includes('upgrade');
+        const isUpToDate = installed && !upgradeNeeded;
+        resolve({ installed, isUpToDate, upgradeNeeded, output });
+      });
+      proc.on('error', () => {
+        clearTimeout(timer);
+        resolve({ installed: false, isUpToDate: false, upgradeNeeded: false, output: '' });
+      });
+    });
+  } catch (_) {
+    return { installed: false, isUpToDate: false, upgradeNeeded: false, output: '' };
+  }
 };
-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 installed = isInstalled(tool) || fs.existsSync(tool.marker);
-  const version = installed ? detectVersion(tool.binary) : null;
-  return { toolId, installed, version, timestamp: Date.now() };
+
+  const cached = statusCache.get(toolId);
+  if (cached && Date.now() - cached.timestamp < 1800000) {
+    return {
+      toolId,
+      installed: cached.installed,
+      isUpToDate: cached.isUpToDate,
+      upgradeNeeded: cached.upgradeNeeded,
+      timestamp: cached.timestamp
+    };
+  }
+
+  return { toolId, installed: false, isUpToDate: false, upgradeNeeded: false, timestamp: Date.now() };
 }
 
-export async function checkForUpdates(toolId, currentVersion) {
-  if (!currentVersion) return { hasUpdate: false, latestVersion: null };
+export async function checkToolStatusAsync(toolId) {
   const tool = getTool(toolId);
-  if (!tool) return { hasUpdate: false, latestVersion: null };
+  if (!tool) return null;
 
-  try {
-    const cached = versionCache.get(toolId);
-    if (cached && Date.now() - cached.timestamp < 3600000) return { hasUpdate: cmpVer(currentVersion, cached.version), latestVersion: cached.version };
+  const cached = statusCache.get(toolId);
+  if (cached && Date.now() - cached.timestamp < 1800000) {
+    return {
+      toolId,
+      installed: cached.installed,
+      isUpToDate: cached.isUpToDate,
+      upgradeNeeded: cached.upgradeNeeded,
+      timestamp: cached.timestamp
+    };
+  }
 
-    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 result = await checkToolViaBunx(tool.pkg);
+  const status = {
+    toolId,
+    installed: result.installed,
+    isUpToDate: result.isUpToDate,
+    upgradeNeeded: result.upgradeNeeded,
+    timestamp: Date.now()
+  };
 
-    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 }; }
+  statusCache.set(toolId, status);
+  return status;
 }
 
-const createMarkerDir = (tool) => {
-  try {
-    const markerDir = path.dirname(tool.marker);
-    if (!fs.existsSync(markerDir)) {
-      fs.mkdirSync(markerDir, { recursive: true });
-    }
-    if (!fs.existsSync(tool.marker)) {
-      fs.mkdirSync(tool.marker, { recursive: true });
-    }
-  } catch (_) {}
-};
+export async function checkForUpdates(toolId) {
+  const tool = getTool(toolId);
+  if (!tool) return { needsUpdate: false };
+
+  const status = await checkToolStatusAsync(toolId);
+  return { needsUpdate: status.upgradeNeeded && status.installed };
+}
 
-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 spawnBunxProc = (pkg, onProgress) => new Promise((resolve) => {
+  const cmd = isWindows ? 'bunx.cmd' : 'bunx';
+  const proc = spawn(cmd, [pkg], { stdio: ['pipe', 'pipe', 'pipe'], timeout: 300000, shell: isWindows });
+  let completed = false, stderr = '', stdout = '';
   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.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) {
-      createMarkerDir(tool);
-      let s = checkToolStatus(toolId);
-      if (!s?.installed) {
-        setTimeout(() => { s = checkToolStatus(toolId); }, 500);
-      }
-      resolve(s?.installed ? { success: true, error: null, version: s.version } : { success: false, error: 'Tool not detected' });
+    const output = stdout + stderr;
+    if (code === 0 || output.includes('upgraded') || output.includes('registered') || output.includes('Hooks registered')) {
+      resolve({ success: true, error: null });
     } else {
-      resolve({ success: false, error: stderr.substring(0, 1000) || 'Failed' });
+      resolve({ success: false, error: output.substring(0, 1000) || 'Failed' });
     }
   });
   proc.on('error', (err) => { clearTimeout(timer); if (!completed) { completed = true; resolve({ success: false, error: err.message }); }});
@@ -119,22 +129,54 @@ export async function install(toolId, onProgress) {
   if (!tool) return { success: false, error: 'Tool not found' };
   if (installLocks.get(toolId)) return { success: false, error: 'Install in progress' };
   installLocks.set(toolId, true);
-  try { return await spawnProc(toolId, tool, tool.pkg, onProgress); } finally { installLocks.delete(toolId); }
+  try {
+    const result = await spawnBunxProc(tool.pkg, onProgress);
+    statusCache.delete(toolId);
+    return result;
+  } finally {
+    installLocks.delete(toolId);
+  }
 }
 
-export async function update(toolId, targetVersion, onProgress) {
+export async function update(toolId, onProgress) {
   const tool = getTool(toolId);
   if (!tool) return { success: false, error: 'Tool not found' };
-  const current = checkToolStatus(toolId);
+  const current = await checkToolStatusAsync(toolId);
   if (!current?.installed) return { success: false, error: 'Tool not installed' };
   if (installLocks.get(toolId)) return { success: false, error: 'Install in progress' };
 
-  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 await spawnProc(toolId, tool, `${tool.pkg}@${target}`, onProgress); } finally { installLocks.delete(toolId); }
+  try {
+    const result = await spawnBunxProc(tool.pkg, onProgress);
+    statusCache.delete(toolId);
+    return result;
+  } finally {
+    installLocks.delete(toolId);
+  }
+}
+
+export function getAllTools() {
+  return TOOLS.map(tool => {
+    const cached = statusCache.get(tool.id);
+    return {
+      ...tool,
+      toolId: tool.id,
+      installed: cached?.installed ?? false,
+      isUpToDate: cached?.isUpToDate ?? false,
+      upgradeNeeded: cached?.upgradeNeeded ?? false,
+      timestamp: cached?.timestamp ?? 0
+    };
+  });
 }
 
-export function getAllTools() { return TOOLS.map(tool => ({ ...tool, ...checkToolStatus(tool.id) })); }
-export function getToolConfig(toolId) { return getTool(toolId) || null; }
+export async function getAllToolsAsync() {
+  const results = await Promise.all(TOOLS.map(tool => checkToolStatusAsync(tool.id)));
+  return results.map((status, idx) => ({
+    ...TOOLS[idx],
+    ...status
+  }));
+}
+
+export function getToolConfig(toolId) {
+  return getTool(toolId) || null;
+}

package/lib/ws-handlers-util.js

@@ -252,4 +252,23 @@ export function register(router, deps) {
       return { ok: true, byteSize: result.byteSize, cached: true };
     } catch (e) { err(500, e.message); }
   });
+
+  router.handle('tools.list', async () => {
+    try {
+      const tools = await toolManager.getAllToolsAsync();
+      const result = tools.map((t) => ({
+        id: t.id,
+        name: t.name,
+        pkg: t.pkg,
+        installed: t.installed,
+        status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
+        isUpToDate: t.isUpToDate,
+        upgradeNeeded: t.upgradeNeeded,
+        hasUpdate: t.upgradeNeeded && t.installed
+      }));
+      return { tools: result };
+    } catch (e) {
+      err(500, e.message);
+    }
+  });
 }

package/package.json

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

package/server.js

@@ -1783,31 +1783,18 @@ const server = http.createServer(async (req, res) => {
 
     if (pathOnly === '/api/tools' && req.method === 'GET') {
       console.log('[TOOLS-API] Handling GET /api/tools');
-      const tools = toolManager.getAllTools();
-      const toolsWithStatus = tools.map((t) => {
-        const dbStatus = queries.getToolStatus(t.id);
-        const status = dbStatus?.status || (t.installed ? 'installed' : 'not_installed');
-        return {
-          id: t.id,
-          name: t.name,
-          pkg: t.pkg,
-          binary: t.binary,
-          installed: t.installed,
-          version: dbStatus?.version || t.version,
-          status: status,
-          error_message: dbStatus?.error_message,
-          hasUpdate: false,
-          latestVersion: null
-        };
-      });
-      const toolsWithUpdates = await Promise.all(toolsWithStatus.map(async (t) => {
-        if (t.installed && t.version) {
-          const updates = await toolManager.checkForUpdates(t.id, t.version);
-          return { ...t, hasUpdate: updates.hasUpdate, latestVersion: updates.latestVersion };
-        }
-        return t;
+      const tools = await toolManager.getAllToolsAsync();
+      const result = tools.map((t) => ({
+        id: t.id,
+        name: t.name,
+        pkg: t.pkg,
+        installed: t.installed,
+        status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
+        isUpToDate: t.isUpToDate,
+        upgradeNeeded: t.upgradeNeeded,
+        hasUpdate: t.upgradeNeeded && t.installed
       }));
-      sendJSON(req, res, 200, { tools: toolsWithUpdates });
+      sendJSON(req, res, 200, { tools: result });
       return;
     }
 
@@ -4032,7 +4019,7 @@ registerUtilHandlers(wsRouter, {
   broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig,
   startGeminiOAuth, exchangeGeminiOAuthCode,
   geminiOAuthState: () => geminiOAuthState,
-  STARTUP_CWD, activeScripts, voiceCacheManager
+  STARTUP_CWD, activeScripts, voiceCacheManager, toolManager
 });
 
 wsRouter.onLegacy((data, ws) => {

package/static/js/tools-manager.js

@@ -41,7 +41,7 @@
 
   function getStatusColor(tool) {
     if (tool.status === 'installing' || tool.status === 'updating') return '#3b82f6';
-    if (tool.status === 'installed' && tool.hasUpdate) return '#f59e0b';
+    if (tool.status === 'needs_update' || (tool.status === 'installed' && tool.hasUpdate)) return '#f59e0b';
     if (tool.status === 'installed') return '#10b981';
     if (tool.status === 'failed') return '#ef4444';
     return '#6b7280';
@@ -50,8 +50,9 @@
   function getStatusText(tool) {
     if (tool.status === 'installing') return 'Installing...';
     if (tool.status === 'updating') return 'Updating...';
+    if (tool.status === 'needs_update') return 'Update available';
     if (tool.status === 'installed') {
-      return tool.hasUpdate ? `v${tool.version || '?'} (update available)` : `v${tool.version || '?'}`;
+      return tool.hasUpdate ? 'Update available' : 'Up-to-date';
     }
     if (tool.status === 'failed') return 'Installation failed';
     return 'Not installed';
@@ -59,7 +60,7 @@
 
   function getStatusClass(tool) {
     if (tool.status === 'installing' || tool.status === 'updating') return 'installing';
-    if (tool.status === 'installed' && tool.hasUpdate) return 'updating';
+    if (tool.status === 'needs_update' || (tool.status === 'installed' && tool.hasUpdate)) return 'updating';
     if (tool.status === 'installed') return 'installed';
     if (tool.status === 'failed') return 'failed';
     return 'not-installed';
@@ -180,11 +181,11 @@
         '<div class="tool-actions">' +
         (tool.status === 'not_installed' ?
           '<button class="tool-btn tool-btn-primary" onclick="window.toolsManager.install(\'' + tool.id + '\')" ' + (operationInProgress.has(tool.id) ? 'disabled' : '') + '>Install</button>' :
-          tool.hasUpdate ?
-          '<button class="tool-btn tool-btn-primary" onclick="window.toolsManager.update(\'' + tool.id + '\')" ' + (operationInProgress.has(tool.id) ? 'disabled' : '') + '>Update to v' + esc(tool.latestVersion || '?') + '</button>' :
+          (tool.hasUpdate || tool.status === 'needs_update') ?
+          '<button class="tool-btn tool-btn-primary" onclick="window.toolsManager.update(\'' + tool.id + '\')" ' + (operationInProgress.has(tool.id) ? 'disabled' : '') + '>Update</button>' :
           tool.status === 'failed' ?
           '<button class="tool-btn tool-btn-primary" onclick="window.toolsManager.install(\'' + tool.id + '\')" ' + (operationInProgress.has(tool.id) ? 'disabled' : '') + '>Retry</button>' :
-          '<button class="tool-btn tool-btn-secondary" onclick="window.toolsManager.refresh()" ' + (isRefreshing ? 'disabled' : '') + '>Check for updates</button>'
+          '<button class="tool-btn tool-btn-secondary" onclick="window.toolsManager.refresh()" ' + (isRefreshing ? 'disabled' : '') + '>Refresh</button>'
         ) +
         '</div>' +
         '</div>';