@openagents-org/agent-launcher 0.2.142 → 0.2.145

package/src/paths.js

@@ -50,6 +50,12 @@ function getExtraBinDirs() {
   // Common: ~/.local/bin (pipx, user installs)
   _push(dirs, path.join(HOME, '.local', 'bin'));
 
+  // Aider (uv tool install) — its executable honors XDG_BIN_HOME /
+  // XDG_DATA_HOME/../bin / ~/.local/bin and also always lands in the uv tools
+  // venv. A GUI/daemon process won't see the installer's PATH edit, so add the
+  // real install dirs explicitly (filtered to existing dirs by the caller).
+  for (const d of aiderBinDirs()) _push(dirs, d);
+
   // Also add the directory containing the current node binary
   try {
     const nodeDir = path.dirname(process.execPath);
@@ -142,6 +148,14 @@ function whichBinary(name) {
     return cached.value;
   }
 
+  // On a non-English Windows the console OUTPUT codepage is OEM (e.g. 936/GBK on
+  // zh-CN), so `where` prints a path whose non-ASCII bytes don't match the utf-8
+  // decoding execSync does — a Chinese username comes back mangled (e.g.
+  // `C:\Users\??.?[\…`) and yields ENOENT downstream. We can't reliably re-encode
+  // it (and forcing `chcp` is unsafe under windowsHide's console-less cmd), so we
+  // existence-check every hit and only return one that's real; a mangled path
+  // fails and the caller falls through to its Node-derived tiers (built from
+  // process.env / os.homedir, which the OS hands us as correct UTF-16).
   const cmd = IS_WINDOWS ? `where ${name}` : `which ${name}`;
   try {
     const result = execSync(cmd, {
@@ -150,8 +164,12 @@ function whichBinary(name) {
       env: { ...process.env, PATH: getEnhancedPATH() },
       timeout: 5000,
       windowsHide: true,
-    }).trim();
-    const value = result.split(/\r?\n/)[0] || null;
+    });
+    let value = null;
+    for (const line of result.split(/\r?\n/)) {
+      const hit = line.trim();
+      if (hit && fs.existsSync(hit)) { value = hit; break; }
+    }
     whichBinaryCache.set(cacheKey, { value, at: Date.now() });
     return value;
   } catch {
@@ -160,6 +178,64 @@ function whichBinary(name) {
   }
 }
 
+/**
+ * Codepage-safe `where`/`which` lookup, shared by every CLI adapter.
+ *
+ * Hazard: on a non-English Windows the console output codepage is OEM (e.g.
+ * 936/GBK on zh-CN), so execSync decodes `where` stdout with the wrong codepage
+ * and mangles a non-ASCII (e.g. Chinese) username in the path — yielding ENOENT
+ * downstream (the `C:\Users\??.?[\…\claude.cmd` failure). Two safe defenses,
+ * no `chcp` (which is unreliable under windowsHide's console-less cmd):
+ *   1. (Windows) check the npm-global default `%APPDATA%\npm\<name>.cmd` FIRST.
+ *      APPDATA comes from the OS as UTF-16 via Node, so this path is always
+ *      correctly encoded — and it's where the npm-installed CLIs actually live.
+ *   2. Fall back to `where`/`which`, but existence-check every hit so a mangled
+ *      path is skipped and the caller drops to its own Node-derived tiers.
+ *
+ * @param {string|string[]} names  base name(s), e.g. 'claude' or ['cursor-agent','agent'].
+ *                                  On Windows each is tried as <name>.cmd, <name>.exe, <name>.
+ * @param {object} [env]           env for the lookup (defaults to getEnhancedEnv()).
+ * @returns {string|null}          an existing absolute path, or null.
+ */
+function whereBinary(names, env) {
+  const bases = Array.isArray(names) ? names : [names];
+
+  // 1. npm-global default, derived from Node's env (correct encoding even when
+  //    the username is non-ASCII). This is where `npm i -g <cli>` drops the shim.
+  if (IS_WINDOWS && process.env.APPDATA) {
+    for (const b of bases) {
+      const c = path.join(process.env.APPDATA, 'npm', `${b}.cmd`);
+      try { if (fs.existsSync(c)) return c; } catch {}
+    }
+  }
+
+  // 2. PATH lookup, existence-guarded.
+  let cmd;
+  if (IS_WINDOWS) {
+    const parts = [];
+    for (const b of bases) {
+      parts.push(`where ${b}.cmd 2>nul`, `where ${b}.exe 2>nul`, `where ${b} 2>nul`);
+    }
+    cmd = parts.join(' || ');
+  } else {
+    cmd = bases.map((b) => `which ${b}`).join(' || ');
+  }
+  try {
+    const out = execSync(cmd, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+      windowsHide: true,
+      env: env || getEnhancedEnv(),
+    });
+    for (const line of out.split(/\r?\n/)) {
+      const hit = line.trim();
+      if (hit && fs.existsSync(hit)) return hit;
+    }
+  } catch {}
+  return null;
+}
+
 // ---- Windows paths ----
 
 function _addWindowsPaths(dirs) {
@@ -197,6 +273,12 @@ function _addWindowsPaths(dirs) {
   if (localAppData) _push(dirs, path.join(localAppData, 'cursor-agent'));
   _push(dirs, path.join(HOME, '.local', 'bin'));
 
+  // Amp CLI (irm https://ampcode.com/install.ps1 | iex) — same registry-PATH
+  // staleness as Cursor; add the canonical install dir(s) so an already-running
+  // daemon resolves amp without a reboot.
+  _push(dirs, path.join(HOME, '.amp', 'bin'));
+  if (localAppData) _push(dirs, path.join(localAppData, 'amp'));
+
   // Hermes CLI native (no-WSL) installer drops hermes.exe in the portable
   // venv's Scripts dir and the uv shim in %LOCALAPPDATA%\hermes\bin. Same
   // registry-PATH staleness as Cursor — add explicitly so an already-running
@@ -291,6 +373,12 @@ function _addUnixPaths(dirs) {
 
   // Cursor CLI native installer (curl https://cursor.com/install | bash)
   _push(dirs, path.join(HOME, '.cursor', 'bin'));
+
+  // Amp CLI native installer (curl https://ampcode.com/install.sh | bash)
+  // drops the binary in ~/.amp/bin and only symlinks into ~/.local/bin when
+  // that dir is already on PATH — so a GUI- or daemon-spawned process never
+  // sees it unless the canonical dir is listed here explicitly.
+  _push(dirs, path.join(HOME, '.amp', 'bin'));
 }
 
 // ---- macOS-specific ----
@@ -396,15 +484,50 @@ function clearBinaryLookupCache() {
   whichBinaryCache.clear();
 }
 
+/**
+ * Directories where the Aider CLI executable can land, in the SAME priority the
+ * official installer (aider.chat/install.{sh,ps1} → `uv tool install`) uses, so
+ * detection matches reality on every platform:
+ *   1. $XDG_BIN_HOME
+ *   2. $XDG_DATA_HOME/../bin
+ *   3. ~/.local/bin              (the default uv-tool / pipx / pip --user bin)
+ *   4. the uv tools venv for aider-chat (Scripts on Windows, bin on Unix) — the
+ *      executable always lands here on a successful `uv tool install`, even if
+ *      the bin-dir copy/PATH edit didn't happen.
+ * Uses os.homedir()/live env so it reflects the current process (test-friendly).
+ * Returns directories only; callers join the platform binary names.
+ */
+function aiderBinDirs() {
+  const home = os.homedir();
+  const dirs = [];
+  if (process.env.XDG_BIN_HOME) dirs.push(process.env.XDG_BIN_HOME);
+  if (process.env.XDG_DATA_HOME) dirs.push(path.join(process.env.XDG_DATA_HOME, '..', 'bin'));
+  dirs.push(path.join(home, '.local', 'bin'));
+  if (IS_WINDOWS) {
+    const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    const uvTools = process.env.UV_TOOL_DIR || path.join(appData, 'uv', 'tools');
+    dirs.push(path.join(uvTools, 'aider-chat', 'Scripts'));
+    dirs.push(path.join(home, 'bin'));
+  } else {
+    const uvTools = process.env.UV_TOOL_DIR
+      || path.join(home, '.local', 'share', 'uv', 'tools');
+    dirs.push(path.join(uvTools, 'aider-chat', 'bin'));
+    dirs.push(path.join(home, 'bin'), '/usr/local/bin', '/opt/homebrew/bin');
+  }
+  return dirs;
+}
+
 module.exports = {
   getExtraBinDirs,
   getEnhancedPATH,
   getEnhancedEnv,
   whichBinary,
+  whereBinary,
   clearBinaryLookupCache,
   getRuntimePrefix,
   getCorePrefix,
   defaultAgentWorkdir,
+  aiderBinDirs,
   IS_WINDOWS,
   IS_MACOS,
   SEP,

package/src/tui.js

@@ -13,6 +13,7 @@ const path = require('path');
 const fs = require('fs');
 const { spawn } = require('child_process');
 const { getExtraBinDirs } = require('./paths');
+const { hasCredentialMetadata, formatAuthGuidance } = require('./auth-guidance');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -67,7 +68,14 @@ function getConnector() {
 
 function describeHealth(health) {
   if (!health) return '';
-  if (!health.ready) return health.message || 'Not configured';
+  if (!health.ready) {
+    // "Not installed" is reserved for a genuinely missing executable; an
+    // installed-but-signed-out agent shows its login/config message instead.
+    if (health.reason === 'not_installed' || health.installed === false) {
+      return 'Not installed';
+    }
+    return health.message || 'Not configured';
+  }
   const parts = ['Ready'];
   if (health.auth_mode === 'api_key') parts.push('API key');
   else if (health.auth_mode === 'cli_login') parts.push('CLI login');
@@ -283,11 +291,14 @@ function createTUI() {
         // Local-only agents (no workspace) show a dimmed "(local)" marker.
         const ws = r.workspace || `{gray-fg}${r.workspaceLabel}{/gray-fg}`;
         items.push(`  ${r.name.padEnd(22)} ${r.type.padEnd(14)} ${state.padEnd(30)} ${ws}`);
-        // Detail row: working dir + config warning
+        // Detail row: working dir + config warning + the REAL runtime error
+        // (spawn/join/heartbeat) when the daemon reported one, so a failure shows
+        // its actual cause instead of a swallowed/"Not installed" guess.
         const details = [];
         details.push(r.path || process.env.HOME || '~');
         if (r.health) details.push(`{cyan-fg}${describeHealth(r.health)}{/cyan-fg}`);
         if (r.notReadyMsg) details.push(`{yellow-fg}⚠ ${r.notReadyMsg}{/yellow-fg}`);
+        if (r.lastError) details.push(`{red-fg}✗ ${r.lastError}{/red-fg}`);
         items.push(`  {gray-fg}  ${details.join('  |  ')}{/gray-fg}`);
       }
       agentList.setItems(items);
@@ -754,6 +765,22 @@ function createTUI() {
     currentView = 'configure';
     const envFields = connector.registry.getEnvFields(agent.type);
     if (!envFields || envFields.length === 0) {
+      // Some agents declare no env_config yet still REQUIRE a sign-in/credential
+      // (e.g. Gemini's OAuth login). Detect that via the registry's check_ready
+      // and show readiness + login guidance instead of a misleading "no
+      // configuration required". Agents without any credential metadata keep the
+      // original message — this is gated, so other agents are untouched.
+      const entry = connector.registry.getEntry(agent.type);
+      const checkReady = entry && entry.check_ready;
+      if (hasCredentialMetadata(checkReady)) {
+        let health = null;
+        try { health = connector.healthCheck(agent.type); } catch {}
+        const g = formatAuthGuidance(entry, health);
+        const tag = g.ready ? 'green-fg' : 'yellow-fg';
+        log(`{bold}{${tag}}${entry.label || agent.type} authentication: ${g.ready ? 'Ready' : 'Not ready'}{/}{/bold}`);
+        for (const line of g.lines) log(`{gray-fg}${line}{/gray-fg}`);
+        return;
+      }
       log('{gray-fg}No configuration required for this agent type.{/gray-fg}');
       return;
     }