agentgui 1.0.510 → 1.0.512

package/lib/tool-manager.js

@@ -6,10 +6,10 @@ import path from 'path';
 
 const isWindows = os.platform() === 'win32';
 const TOOLS = [
-  { 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' },
+  { id: 'gm-oc', name: 'OpenCode', pkg: 'opencode-ai' },
+  { id: 'gm-gc', name: 'Gemini CLI', pkg: '@google/gemini-cli' },
+  { id: 'gm-kilo', name: 'Kilo', pkg: '@kilocode/cli' },
+  { id: 'gm-cc', name: 'Claude Code', pkg: '@anthropic-ai/claude-code' },
 ];
 
 const statusCache = new Map();
@@ -26,12 +26,58 @@ const getNodeModulesPath = () => {
 const getInstalledVersion = (pkg) => {
   try {
     const homeDir = os.homedir();
-    const pluginPath = path.join(homeDir, '.claude', 'plugins', pkg);
-    const pluginJsonPath = path.join(pluginPath, 'plugin.json');
-    if (fs.existsSync(pluginJsonPath)) {
-      const pluginJson = JSON.parse(fs.readFileSync(pluginJsonPath, 'utf-8'));
-      if (pluginJson.version) {
-        return pluginJson.version;
+
+    // Check Claude Code plugins
+    const claudePath = path.join(homeDir, '.claude', 'plugins', pkg, 'plugin.json');
+    if (fs.existsSync(claudePath)) {
+      try {
+        const pluginJson = JSON.parse(fs.readFileSync(claudePath, 'utf-8'));
+        if (pluginJson.version) return pluginJson.version;
+      } catch (e) {
+        console.warn(`[tool-manager] Failed to parse ${claudePath}:`, e.message);
+      }
+    }
+
+    // Check OpenCode agents
+    const opencodePath = path.join(homeDir, '.config', 'opencode', 'agents', pkg, 'plugin.json');
+    if (fs.existsSync(opencodePath)) {
+      try {
+        const pluginJson = JSON.parse(fs.readFileSync(opencodePath, 'utf-8'));
+        if (pluginJson.version) return pluginJson.version;
+      } catch (e) {
+        console.warn(`[tool-manager] Failed to parse ${opencodePath}:`, e.message);
+      }
+    }
+
+    // Check Gemini CLI agents (stored as 'gm' directory)
+    const geminiPath = path.join(homeDir, '.gemini', 'extensions', 'gm', 'plugin.json');
+    if (fs.existsSync(geminiPath)) {
+      try {
+        const pluginJson = JSON.parse(fs.readFileSync(geminiPath, 'utf-8'));
+        if (pluginJson.version) return pluginJson.version;
+      } catch (e) {
+        console.warn(`[tool-manager] Failed to parse ${geminiPath}:`, e.message);
+      }
+    }
+    // Try gemini-extension.json as fallback
+    const geminiExtPath = path.join(homeDir, '.gemini', 'extensions', 'gm', 'gemini-extension.json');
+    if (fs.existsSync(geminiExtPath)) {
+      try {
+        const extJson = JSON.parse(fs.readFileSync(geminiExtPath, 'utf-8'));
+        if (extJson.version) return extJson.version;
+      } catch (e) {
+        console.warn(`[tool-manager] Failed to parse ${geminiExtPath}:`, e.message);
+      }
+    }
+
+    // Check Kilo agents
+    const kiloPath = path.join(homeDir, '.config', 'kilo', 'agents', pkg, 'plugin.json');
+    if (fs.existsSync(kiloPath)) {
+      try {
+        const pluginJson = JSON.parse(fs.readFileSync(kiloPath, 'utf-8'));
+        if (pluginJson.version) return pluginJson.version;
+      } catch (e) {
+        console.warn(`[tool-manager] Failed to parse ${kiloPath}:`, e.message);
       }
     }
   } catch (_) {}
@@ -119,75 +165,69 @@ const getPublishedVersion = async (pkg) => {
 
 const checkToolInstalled = (pkg) => {
   try {
+    const homeDir = os.homedir();
+
+    // Check Claude Code plugins
+    if (fs.existsSync(path.join(homeDir, '.claude', 'plugins', pkg))) {
+      return true;
+    }
+
+    // Check OpenCode agents
+    if (fs.existsSync(path.join(homeDir, '.config', 'opencode', 'agents', pkg))) {
+      return true;
+    }
+
+    // Check Gemini CLI agents (always stored as 'gm' directory)
+    if (fs.existsSync(path.join(homeDir, '.gemini', 'extensions', 'gm'))) {
+      return true;
+    }
+
+    // Check Kilo agents
+    if (fs.existsSync(path.join(homeDir, '.config', 'kilo', 'agents', pkg))) {
+      return true;
+    }
+
+    // Check node_modules as fallback
     const nodeModulesPath = getNodeModulesPath();
-    const nodeModulesPackagePath = path.join(nodeModulesPath, pkg);
-    if (fs.existsSync(nodeModulesPackagePath)) {
+    if (fs.existsSync(path.join(nodeModulesPath, pkg))) {
       return true;
     }
-    const homeDir = os.homedir();
-    const pluginPath = path.join(homeDir, '.claude', 'plugins', pkg);
-    return fs.existsSync(pluginPath);
-  } catch (_) {
-    return false;
+  } catch (_) {}
+  return false;
+};
+
+const compareVersions = (v1, v2) => {
+  if (!v1 || !v2) return false;
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 < p2) return true;
+    if (p1 > p2) return false;
   }
+  return false;
 };
 
 const checkToolViaBunx = async (pkg) => {
   try {
-    const cmd = isWindows ? 'bunx.cmd' : 'bunx';
-    const checkResult = await 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 (_) {}
-        const installed = checkToolInstalled(pkg);
-        const installedVersion = getInstalledVersion(pkg);
-        resolve({ installed, isUpToDate: installed, upgradeNeeded: false, output: 'timeout', installedVersion });
-      }, 10000);
-      proc.on('close', (code) => {
-        clearTimeout(timer);
-        const output = stdout + stderr;
-        const installed = code === 0 || checkToolInstalled(pkg);
-        const upgradeNeeded = output.includes('Upgrading') || output.includes('upgrade');
-        const isUpToDate = installed && !upgradeNeeded;
-        const installedVersion = getInstalledVersion(pkg);
-        resolve({ installed, isUpToDate, upgradeNeeded, output, installedVersion });
-      });
-      proc.on('error', () => {
-        clearTimeout(timer);
-        const installed = checkToolInstalled(pkg);
-        const installedVersion = getInstalledVersion(pkg);
-        resolve({ installed, isUpToDate: false, upgradeNeeded: false, output: '', installedVersion });
-      });
-    });
+    const installed = checkToolInstalled(pkg);
+    const installedVersion = getInstalledVersion(pkg);
+    const publishedVersion = await getPublishedVersion(pkg);
 
-    let finalInstalledVersion = checkResult.installedVersion;
-    if (!finalInstalledVersion && checkResult.installed) {
-      finalInstalledVersion = await getCliToolVersion(pkg);
-    }
+    // Determine if update is needed by comparing versions
+    // Do NOT run bunx --version as it triggers installation/upgrade
+    const needsUpdate = installed && publishedVersion && compareVersions(installedVersion, publishedVersion);
+    const isUpToDate = installed && !needsUpdate;
 
-    const publishedVersion = await getPublishedVersion(pkg);
-    const compareVersions = (v1, v2) => {
-      if (!v1 || !v2) return false;
-      const parts1 = v1.split('.').map(Number);
-      const parts2 = v2.split('.').map(Number);
-      for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-        const p1 = parts1[i] || 0;
-        const p2 = parts2[i] || 0;
-        if (p1 < p2) return true;
-        if (p1 > p2) return false;
-      }
-      return false;
+    return {
+      installed,
+      isUpToDate,
+      upgradeNeeded: needsUpdate,
+      output: 'version-check',
+      installedVersion,
+      publishedVersion
     };
-
-    const needsUpdate = checkResult.installed && publishedVersion && compareVersions(finalInstalledVersion, publishedVersion);
-    return { ...checkResult, installedVersion: finalInstalledVersion, publishedVersion, upgradeNeeded: needsUpdate };
   } catch (_) {
     const installedVersion = getInstalledVersion(pkg);
     return { installed: checkToolInstalled(pkg), isUpToDate: false, upgradeNeeded: false, output: '', installedVersion, publishedVersion: null };
@@ -331,11 +371,23 @@ export async function install(toolId, onProgress) {
   installLocks.set(toolId, true);
   try {
     const result = await spawnBunxProc(tool.pkg, onProgress);
-    statusCache.delete(toolId);
-    versionCache.delete(`published-${tool.pkg}`);
     if (result.success) {
+      // Give the filesystem a moment to settle after bunx install
+      await new Promise(r => setTimeout(r, 500));
+
+      // Aggressively clear all version caches to force fresh detection
+      statusCache.delete(toolId);
+      versionCache.clear();
+
       const version = getInstalledVersion(tool.pkg);
-      return { success: true, error: null, version };
+      if (!version) {
+        console.warn(`[tool-manager] Install succeeded but version detection failed for ${toolId}. Attempting CLI check...`);
+        const cliVersion = await getCliToolVersion(tool.pkg);
+        const freshStatus = await checkToolStatusAsync(toolId);
+        return { success: true, error: null, version: cliVersion || 'unknown', ...freshStatus };
+      }
+      const freshStatus = await checkToolStatusAsync(toolId);
+      return { success: true, error: null, version, ...freshStatus };
     }
     return result;
   } finally {
@@ -353,11 +405,23 @@ export async function update(toolId, onProgress) {
   installLocks.set(toolId, true);
   try {
     const result = await spawnBunxProc(tool.pkg, onProgress);
-    statusCache.delete(toolId);
-    versionCache.delete(`published-${tool.pkg}`);
     if (result.success) {
+      // Give the filesystem a moment to settle after bunx update
+      await new Promise(r => setTimeout(r, 500));
+
+      // Aggressively clear all version caches to force fresh detection
+      statusCache.delete(toolId);
+      versionCache.clear();
+
       const version = getInstalledVersion(tool.pkg);
-      return { success: true, error: null, version };
+      if (!version) {
+        console.warn(`[tool-manager] Update succeeded but version detection failed for ${toolId}. Attempting CLI check...`);
+        const cliVersion = await getCliToolVersion(tool.pkg);
+        const freshStatus = await checkToolStatusAsync(toolId);
+        return { success: true, error: null, version: cliVersion || 'unknown', ...freshStatus };
+      }
+      const freshStatus = await checkToolStatusAsync(toolId);
+      return { success: true, error: null, version, ...freshStatus };
     }
     return result;
   } finally {

package/lib/ws-optimizer.js

@@ -1,8 +1,8 @@
 import zlib from 'zlib';
 
 const MESSAGE_PRIORITY = {
-  high: ['streaming_error', 'streaming_complete', 'rate_limit_hit', 'streaming_cancelled', 'run_cancelled'],
-  normal: ['streaming_progress', 'streaming_start', 'message_created', 'queue_status'],
+  high: ['streaming_error', 'streaming_complete', 'rate_limit_hit', 'streaming_cancelled', 'run_cancelled', 'tool_install_complete', 'tool_update_complete', 'tool_install_failed', 'tool_update_failed'],
+  normal: ['streaming_progress', 'streaming_start', 'message_created', 'queue_status', 'tool_install_progress', 'tool_update_progress'],
   low: ['model_download_progress', 'stt_progress', 'tts_setup_progress', 'voice_list', 'tts_audio']
 };
 

package/package.json

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

package/server.js

@@ -1817,15 +1817,28 @@ const server = http.createServer(async (req, res) => {
 
     if (pathOnly.match(/^\/api\/tools\/([^/]+)\/status$/)) {
       const toolId = pathOnly.match(/^\/api\/tools\/([^/]+)\/status$/)[1];
-      const status = toolManager.checkToolStatus(toolId);
-      if (!status) {
+      const dbStatus = queries.getToolStatus(toolId);
+      const tmStatus = toolManager.checkToolStatus(toolId);
+      if (!tmStatus && !dbStatus) {
         sendJSON(req, res, 404, { error: 'Tool not found' });
         return;
       }
+
+      // Merge database status with tool manager status
+      const status = {
+        toolId,
+        installed: tmStatus?.installed || (dbStatus?.status === 'installed'),
+        isUpToDate: tmStatus?.isUpToDate || false,
+        upgradeNeeded: tmStatus?.upgradeNeeded || false,
+        status: dbStatus?.status || (tmStatus?.installed ? 'installed' : 'not_installed'),
+        installedVersion: dbStatus?.version || tmStatus?.installedVersion || null,
+        timestamp: Date.now(),
+        error_message: dbStatus?.error_message || null
+      };
+
       if (status.installed) {
-        const updates = await toolManager.checkForUpdates(toolId, status.version);
-        status.hasUpdate = updates.hasUpdate;
-        status.latestVersion = updates.latestVersion;
+        const updates = await toolManager.checkForUpdates(toolId);
+        status.hasUpdate = updates.needsUpdate || false;
       }
       sendJSON(req, res, 200, status);
       return;
@@ -1867,12 +1880,16 @@ const server = http.createServer(async (req, res) => {
         installCompleted = true;
         if (result.success) {
           const version = result.version || null;
+          console.log(`[TOOLS-API] Install succeeded for ${toolId}, version: ${version}`);
           queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
+          const freshStatus = await toolManager.checkToolStatusAsync(toolId);
+          console.log(`[TOOLS-API] Fresh status after install for ${toolId}:`, JSON.stringify(freshStatus));
           if (wsOptimizer && wsOptimizer.broadcast) {
-            wsOptimizer.broadcast({ type: 'tool_install_complete', toolId, data: { success: true } });
+            wsOptimizer.broadcast({ type: 'tool_install_complete', toolId, data: { success: true, ...freshStatus } });
           }
           queries.addToolInstallHistory(toolId, 'install', 'success', null);
         } else {
+          console.error(`[TOOLS-API] Install failed for ${toolId}:`, result.error);
           queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
           if (wsOptimizer && wsOptimizer.broadcast) {
             wsOptimizer.broadcast({ type: 'tool_install_failed', toolId, data: result });
@@ -1884,6 +1901,7 @@ const server = http.createServer(async (req, res) => {
         if (installCompleted) return;
         installCompleted = true;
         const error = err?.message || 'Unknown error';
+        console.error(`[TOOLS-API] Install error for ${toolId}:`, error);
         queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
         if (wsOptimizer && wsOptimizer.broadcast) {
           wsOptimizer.broadcast({ type: 'tool_install_failed', toolId, data: { success: false, error } });
@@ -1901,7 +1919,7 @@ const server = http.createServer(async (req, res) => {
         sendJSON(req, res, 404, { error: 'Tool not found' });
         return;
       }
-      const current = toolManager.checkToolStatus(toolId);
+      const current = await toolManager.checkToolStatusAsync(toolId);
       if (!current || !current.installed) {
         sendJSON(req, res, 400, { error: 'Tool not installed' });
         return;
@@ -1931,12 +1949,16 @@ const server = http.createServer(async (req, res) => {
         updateCompleted = true;
         if (result.success) {
           const version = result.version || null;
+          console.log(`[TOOLS-API] Update succeeded for ${toolId}, version: ${version}`);
           queries.updateToolStatus(toolId, { status: 'installed', version, installed_at: Date.now() });
+          const freshStatus = await toolManager.checkToolStatusAsync(toolId);
+          console.log(`[TOOLS-API] Fresh status after update for ${toolId}:`, JSON.stringify(freshStatus));
           if (wsOptimizer && wsOptimizer.broadcast) {
-            wsOptimizer.broadcast({ type: 'tool_update_complete', toolId, data: { success: true } });
+            wsOptimizer.broadcast({ type: 'tool_update_complete', toolId, data: { success: true, ...freshStatus } });
           }
           queries.addToolInstallHistory(toolId, 'update', 'success', null);
         } else {
+          console.error(`[TOOLS-API] Update failed for ${toolId}:`, result.error);
           queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
           if (wsOptimizer && wsOptimizer.broadcast) {
             wsOptimizer.broadcast({ type: 'tool_update_failed', toolId, data: result });
@@ -1948,6 +1970,7 @@ const server = http.createServer(async (req, res) => {
         if (updateCompleted) return;
         updateCompleted = true;
         const error = err?.message || 'Unknown error';
+        console.error(`[TOOLS-API] Update error for ${toolId}:`, error);
         queries.updateToolStatus(toolId, { status: 'failed', error_message: error });
         if (wsOptimizer && wsOptimizer.broadcast) {
           wsOptimizer.broadcast({ type: 'tool_update_failed', toolId, data: { success: false, error } });
@@ -1967,6 +1990,81 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+
+    // Handle POST /api/tools/{toolId}/install - individual tool install
+    const installMatch = pathOnly.match(/^\/api\/tools\/([^\/]+)\/install$/);
+    if (installMatch && req.method === 'POST') {
+      const toolId = installMatch[1];
+      sendJSON(req, res, 200, { installing: true, toolId });
+      setImmediate(async () => {
+        try {
+          const result = await toolManager.install(toolId, (msg) => {
+            if (wsOptimizer && wsOptimizer.broadcast) {
+              wsOptimizer.broadcast({ type: 'tool_install_progress', toolId, data: msg });
+            }
+          });
+          if (result.success) {
+            queries.updateToolStatus(toolId, { status: 'installed', installed_at: Date.now() });
+            queries.addToolInstallHistory(toolId, 'install', 'success', null);
+            const freshStatus = await toolManager.checkToolStatusAsync(toolId);
+            if (wsOptimizer && wsOptimizer.broadcast) {
+              wsOptimizer.broadcast({ type: 'tool_install_complete', toolId, data: { ...result, ...freshStatus } });
+            }
+          } else {
+            queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
+            queries.addToolInstallHistory(toolId, 'install', 'failed', result.error);
+            if (wsOptimizer && wsOptimizer.broadcast) {
+              wsOptimizer.broadcast({ type: 'tool_install_failed', toolId, data: result });
+            }
+          }
+        } catch (err) {
+          queries.updateToolStatus(toolId, { status: 'failed', error_message: err.message });
+          queries.addToolInstallHistory(toolId, 'install', 'failed', err.message);
+          if (wsOptimizer && wsOptimizer.broadcast) {
+            wsOptimizer.broadcast({ type: 'tool_install_failed', toolId, data: { success: false, error: err.message } });
+          }
+        }
+      });
+      return;
+    }
+
+    // Handle POST /api/tools/{toolId}/update - individual tool update
+    const updateMatch = pathOnly.match(/^\/api\/tools\/([^\/]+)\/update$/);
+    if (updateMatch && req.method === 'POST') {
+      const toolId = updateMatch[1];
+      sendJSON(req, res, 200, { updating: true, toolId });
+      setImmediate(async () => {
+        try {
+          const result = await toolManager.update(toolId, (msg) => {
+            if (wsOptimizer && wsOptimizer.broadcast) {
+              wsOptimizer.broadcast({ type: 'tool_update_progress', toolId, data: msg });
+            }
+          });
+          if (result.success) {
+            queries.updateToolStatus(toolId, { status: 'installed', installed_at: Date.now() });
+            queries.addToolInstallHistory(toolId, 'update', 'success', null);
+            const freshStatus = await toolManager.checkToolStatusAsync(toolId);
+            if (wsOptimizer && wsOptimizer.broadcast) {
+              wsOptimizer.broadcast({ type: 'tool_update_complete', toolId, data: { ...result, ...freshStatus } });
+            }
+          } else {
+            queries.updateToolStatus(toolId, { status: 'failed', error_message: result.error });
+            queries.addToolInstallHistory(toolId, 'update', 'failed', result.error);
+            if (wsOptimizer && wsOptimizer.broadcast) {
+              wsOptimizer.broadcast({ type: 'tool_update_failed', toolId, data: result });
+            }
+          }
+        } catch (err) {
+          queries.updateToolStatus(toolId, { status: 'failed', error_message: err.message });
+          queries.addToolInstallHistory(toolId, 'update', 'failed', err.message);
+          if (wsOptimizer && wsOptimizer.broadcast) {
+            wsOptimizer.broadcast({ type: 'tool_update_failed', toolId, data: { success: false, error: err.message } });
+          }
+        }
+      });
+      return;
+    }
+
     if (pathOnly === '/api/tools/update' && req.method === 'POST') {
       sendJSON(req, res, 200, { updating: true, toolCount: 4 });
       if (wsOptimizer && wsOptimizer.broadcast) {
@@ -4087,7 +4185,10 @@ const BROADCAST_TYPES = new Set([
   'rate_limit_hit', 'rate_limit_clear',
   'script_started', 'script_stopped', 'script_output',
   'model_download_progress', 'stt_progress', 'tts_setup_progress', 'voice_list',
-  'streaming_start', 'streaming_progress', 'streaming_complete', 'streaming_error'
+  'streaming_start', 'streaming_progress', 'streaming_complete', 'streaming_error',
+  'tool_install_started', 'tool_install_progress', 'tool_install_complete', 'tool_install_failed',
+  'tool_update_progress', 'tool_update_complete', 'tool_update_failed',
+  'tools_update_started', 'tools_update_complete', 'tools_refresh_complete'
 ]);
 
 const wsOptimizer = new WSOptimizer();

package/static/js/tools-manager.js

@@ -175,6 +175,7 @@
         tool.hasUpdate = (data.data?.upgradeNeeded && data.data?.installed) ?? false;
         tool.progress = 100;
         operationInProgress.delete(data.toolId);
+        render();
         setTimeout(fetchTools, 1000);
       }
     } else if (data.type === 'tool_install_failed' || data.type === 'tool_update_failed') {

package/test-http-tools.js

@@ -0,0 +1,101 @@
+import http from 'http';
+
+const BASE_URL = 'http://localhost:3000/gm';
+
+async function httpGet(path) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, BASE_URL);
+    http.get(url, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, data });
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+async function httpPost(path, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, BASE_URL);
+    const bodyStr = JSON.stringify(body);
+    const options = {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': bodyStr.length }
+    };
+    const req = http.request(url, options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, data });
+        }
+      });
+    }).on('error', reject);
+    req.write(bodyStr);
+    req.end();
+  });
+}
+
+async function runTests() {
+  console.log('=== HTTP API TESTS ===\n');
+
+  try {
+    console.log('TEST 1: GET /api/tools');
+    const tools = await httpGet('/api/tools');
+    console.log('Status:', tools.status);
+    console.log('Tools:', tools.data?.tools?.length || 0);
+    if (tools.data?.tools) {
+      tools.data.tools.forEach(t => {
+        console.log(`  ${t.id}: status=${t.status}, installed=${t.installed}, hasUpdate=${t.hasUpdate}`);
+        console.log(`    versions: installed=${t.installedVersion}, published=${t.publishedVersion}`);
+      });
+    }
+    console.log('');
+
+    if (tools.data?.tools?.length > 0) {
+      const firstTool = tools.data.tools[0];
+
+      console.log(`TEST 2: GET /api/tools/${firstTool.id}/status`);
+      const status = await httpGet(`/api/tools/${firstTool.id}/status`);
+      console.log('Status code:', status.status);
+      console.log('Status data:', JSON.stringify(status.data, null, 2));
+      console.log('');
+
+      if (firstTool.installed && firstTool.hasUpdate) {
+        console.log(`TEST 3: POST /api/tools/${firstTool.id}/update (DRY RUN - not actually posting)`);
+        console.log(`Would update: ${firstTool.id}`);
+        console.log(`Current version: ${firstTool.installedVersion}`);
+        console.log(`Available version: ${firstTool.publishedVersion}`);
+        console.log('');
+
+        console.log('FLOW WOULD BE:');
+        console.log('  1. Frontend sends POST /api/tools/{id}/update');
+        console.log('  2. Backend sets status to "updating" in DB');
+        console.log('  3. Backend sends immediate 200 response');
+        console.log('  4. Backend spawns bunx process async');
+        console.log('  5. Backend broadcasts WebSocket "tool_update_progress" events');
+        console.log('  6. When bunx completes:');
+        console.log('     - Clears caches');
+        console.log('     - Calls checkToolStatusAsync() for fresh status');
+        console.log('     - Broadcasts "tool_update_complete" with new status');
+        console.log('     - Updates DB with new version');
+        console.log('  7. Frontend receives event and updates UI');
+      }
+    }
+
+    console.log('\n=== TESTS COMPLETED ===');
+    process.exit(0);
+  } catch (err) {
+    console.error('ERROR:', err.message);
+    process.exit(1);
+  }
+}
+
+runTests();