agentgui 1.0.463 → 1.0.465

package/.prd

@@ -0,0 +1,61 @@
+{
+  "project": "agentgui-tools-detection",
+  "created": "2026-03-01",
+  "objective": "Fix tools view to correctly detect, install, and upgrade CLI tools (OpenCode, Gemini CLI, Kilo, Claude Code)",
+  "problem": "Tools show 'Not installed' even after installation via npm/npx. Detection logic fails to recognize installed tools.",
+  "root_causes": [
+    "isInstalled() checks PATH but npm-installed binaries may not be in PATH immediately",
+    "Version detection uses --version flag which may not work for all tools",
+    "Marker directories are not created during installation, only checked",
+    "Race condition: binary checked before npm finishes fully writing files",
+    "No fallback detection method if which/where command fails"
+  ],
+  "items": [],
+  "completed": [
+    {
+      "id": "1",
+      "subject": "Understand current tool detection and installation flow",
+      "status": "completed"
+    },
+    {
+      "id": "2",
+      "subject": "Implement reliable tool installation detection with multiple fallbacks",
+      "status": "completed"
+    },
+    {
+      "id": "3",
+      "subject": "Improve version detection with multiple fallback strategies",
+      "status": "completed"
+    },
+    {
+      "id": "4",
+      "subject": "Add installation verification and marker directory creation",
+      "status": "completed"
+    },
+    {
+      "id": "5",
+      "subject": "Test tool installation and detection for all 4 tools",
+      "status": "completed"
+    },
+    {
+      "id": "6",
+      "subject": "Fix tools UI to show correct installation status",
+      "status": "completed"
+    },
+    {
+      "id": "7",
+      "subject": "Implement upgrade mechanism for installed tools",
+      "status": "completed"
+    },
+    {
+      "id": "8",
+      "subject": "Test upgrade path for each tool",
+      "status": "completed"
+    },
+    {
+      "id": "9",
+      "subject": "Verify git commit and all work is pushed",
+      "status": "completed"
+    }
+  ]
+}

package/database.js

@@ -1607,6 +1607,28 @@ export const queries = {
     return stmt.all();
   },
 
+  insertToolInstallation(toolId, data) {
+    const now = Date.now();
+    const stmt = prep(`
+      INSERT OR IGNORE INTO tool_installations
+      (id, tool_id, version, installed_at, status, last_check_at, error_message, update_available, latest_version, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      generateId('ti'),
+      toolId,
+      data.version || null,
+      data.installed_at || null,
+      data.status || 'not_installed',
+      now,
+      data.error_message || null,
+      0,
+      null,
+      now,
+      now
+    );
+  },
+
   updateToolStatus(toolId, data) {
     const now = Date.now();
     const stmt = prep(`

package/lib/tool-manager.js

@@ -22,7 +22,33 @@ const isInstalled = (tool) => {
   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 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 (_) {}
+  }
+  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 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) {
@@ -52,13 +78,39 @@ export async function checkForUpdates(toolId, currentVersion) {
   } catch (_) { return { hasUpdate: false, latestVersion: null }; }
 }
 
+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 (_) {}
+};
+
 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('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' });
+    } 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 }); }});
 });
 

package/package.json

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

package/server.js

@@ -1784,12 +1784,28 @@ 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 toolsWithUpdates = await Promise.all(tools.map(async (t) => {
-        if (t.installed) {
+      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, hasUpdate: false, latestVersion: null };
+        return t;
       }));
       sendJSON(req, res, 200, { tools: toolsWithUpdates });
       return;
@@ -1818,6 +1834,10 @@ const server = http.createServer(async (req, res) => {
         sendJSON(req, res, 404, { error: 'Tool not found' });
         return;
       }
+      const existing = queries.getToolStatus(toolId);
+      if (!existing) {
+        queries.insertToolInstallation(toolId, { status: 'not_installed' });
+      }
       queries.updateToolStatus(toolId, { status: 'installing' });
       sendJSON(req, res, 200, { success: true, installing: true, estimatedTime: 60000 });
       toolManager.install(toolId, (msg) => {