@adhdev/daemon-core 0.9.82-rc.317 → 0.9.82-rc.318

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.317",
+  "version": "0.9.82-rc.318",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.317",
+    "@adhdev/mesh-shared": "0.9.82-rc.318",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapters/resolve-executable.ts

@@ -6,6 +6,42 @@ import * as path from 'path';
 // need a cmd.exe wrapper).
 const DIRECT_EXEC_EXT = new Set(['.exe', '.com']);
 
+// Executable extensions to probe when scanning a directory ourselves, ordered
+// most-directly-launchable first. node-pty's ConPTY backend launches an
+// absolute `.cmd`/`.bat` shim fine (verified) — it only fails to *resolve* a
+// bare command against an incomplete PATH — so once we hand it an absolute
+// path, a `.cmd` shim works just as well as a real `.exe`.
+const WIN_EXEC_EXT = ['.exe', '.com', '.cmd', '.bat'];
+
+/**
+ * Resolve a bare command against well-known global-bin directories that are
+ * frequently NOT on the daemon's inherited PATH, so `where` (which only
+ * searches PATH) misses them. A daemon running under one Node install (e.g.
+ * nvm) never sees another npm prefix's bin dir — notably npm's Windows default
+ * prefix at %APPDATA%\npm, where `npm i -g @openai/codex` lands. Returns an
+ * absolute path on the first hit, or null. Mirrors findBinary()'s extraDirs in
+ * provider-cli-shared.ts; kept inline here so this lightweight module (loaded
+ * by pty-transport) need not pull in the heavier shared module.
+ */
+function resolveWin32GlobalBin(trimmed: string): string | null {
+  // Only resolve a bare command name — anything with a path separator is the
+  // caller's explicit location and must not be re-pointed at a global bin dir.
+  if (path.isAbsolute(trimmed) || trimmed.includes('/') || trimmed.includes('\\')) {
+    return null;
+  }
+  const extraDirs: string[] = [];
+  if (process.env.APPDATA) extraDirs.push(path.join(process.env.APPDATA, 'npm'));
+  try { extraDirs.push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+  for (const dir of extraDirs) {
+    if (!dir) continue;
+    for (const ext of WIN_EXEC_EXT) {
+      const full = path.join(dir, trimmed + ext);
+      if (existsSync(full)) return full;
+    }
+  }
+  return null;
+}
+
 /**
  * Resolve a launch command to an absolute executable path on Windows.
  *
@@ -39,7 +75,16 @@ export function resolveWin32Executable(command: string): string {
       return direct || matches[0] || command;
     }
   } catch {
-    // `where` not found / non-zero exit — fall through to original command.
+    // `where` not found / non-zero exit — fall through to the global-bin scan.
   }
+
+  // `where` found nothing on PATH. Before giving up (and letting node-pty crash
+  // with "File not found:" on the bare command), search npm's off-PATH global
+  // bin dir(s). This is the codex case: `npm i -g @openai/codex` installs to
+  // %APPDATA%\npm, which is absent from a nvm-launched daemon's PATH, so a spec
+  // binary of "codex" never resolved and the spawn ENOENT'd.
+  const globalBin = resolveWin32GlobalBin(trimmed);
+  if (globalBin) return globalBin;
+
   return command;
 }

package/src/detection/cli-detector.ts

@@ -12,6 +12,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { existsSync } from 'fs';
 import type { ProviderLoader } from '../providers/provider-loader.js';
+import { findBinary } from '../cli-adapters/provider-cli-shared.js';
 
 export interface CLIInfo {
     id: string;
@@ -57,6 +58,29 @@ function resolveCommandPath(command: string): string | null {
     return null;
 }
 
+/**
+ * Resolve a CLI command to an absolute path for install detection.
+ * Order: explicit path → PATH (`where`/`which`) → well-known global-bin dirs
+ * (e.g. %APPDATA%\npm) via the shared spawn-layer findBinary.
+ *
+ * The final step keeps detection consistent with the spawn layer: findBinary
+ * already searches npm's default Windows prefix at %APPDATA%\npm (where
+ * `npm i -g @openai/codex` lands), so a CLI installed under an npm prefix that
+ * is NOT on the daemon's inherited PATH is detected as installed instead of
+ * being blocked at the launch gate. findBinary returns a bare "<name>.cmd"
+ * (non-absolute) when nothing is found, so we only accept an absolute path
+ * that actually exists.
+ */
+async function resolveDetectionPath(command: string, whichCmd: string): Promise<string | null> {
+    const explicitPath = resolveCommandPath(command);
+    if (explicitPath) return explicitPath;
+    const whichResult = await execAsync(`${whichCmd} ${shellQuote(command)}`);
+    if (whichResult) return whichResult.split('\n')[0];
+    const resolved = findBinary(command);
+    if (path.isAbsolute(resolved) && existsSync(resolved)) return resolved;
+    return null;
+}
+
 /** Run a shell command with timeout, returning stdout or null on failure */
 function execAsync(cmd: string, timeoutMs = 5000): Promise<string | null> {
     return new Promise((resolve) => {
@@ -97,11 +121,8 @@ export async function detectCLIs(
     const results = await Promise.all(
         cliList.map(async (cli): Promise<CLIInfo> => {
             try {
-                const explicitPath = resolveCommandPath(cli.command);
-                const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(cli.command)}`);
-                if (!pathResult) return { ...cli, installed: false };
-
-                const firstPath = explicitPath || pathResult.split('\n')[0];
+                const firstPath = await resolveDetectionPath(cli.command, whichCmd);
+                if (!firstPath) return { ...cli, installed: false };
 
                 // Get version (parallel with other checks)
                 let version: string | undefined;
@@ -148,10 +169,8 @@ export async function detectCLI(
             const platform = os.platform();
             const whichCmd = platform === 'win32' ? 'where' : 'which';
             try {
-                const explicitPath = resolveCommandPath(target.command);
-                const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(target.command)}`);
-                if (!pathResult) return null;
-                const firstPath = explicitPath || pathResult.split('\n')[0];
+                const firstPath = await resolveDetectionPath(target.command, whichCmd);
+                if (!firstPath) return null;
                 let version: string | undefined;
                 if (options?.includeVersion !== false) {
                     const versionCommands = [