@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.490

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 = [
@@ -181,3 +200,69 @@ export async function detectCLI(
     const all = await detectCLIs(providerLoader, options);
     return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
+
+/**
+ * Fold a detected CLIInfo[] into the `{ providerId: version }` map surfaced as a
+ * node's providerVersions (see RepoMeshNodeCapabilities.providerVersions). Only
+ * installed providers that produced a parseable version string are included, so a
+ * missing entry means "not installed or version unknown" — never a fabricated value.
+ * Pure/deterministic: the same detection input always yields the same map, which is
+ * what the git_status envelope carries and the mesh_status skew check compares.
+ */
+export function buildProviderVersions(detected: CLIInfo[]): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const cli of detected) {
+        if (!cli.installed) continue;
+        const version = typeof cli.version === 'string' ? cli.version.trim() : '';
+        if (!version) continue;
+        out[cli.id] = version;
+    }
+    return out;
+}
+
+// ─── Cached provider-versions snapshot (mesh visibility, T7) ────────────────
+//
+// A node's providerVersions rides the git_status envelope, which a coordinator
+// probes on every graph refresh. Running the full `--version` exec fan-out on
+// each probe would be far too costly (one spawn per provider per probe), so the
+// snapshot is memoized with a TTL and refreshed lazily in the background: a probe
+// reads the current cache immediately (empty until the first refresh completes)
+// and kicks off a refresh only when the cache is stale, never blocking the git
+// response on version detection. Best-effort observability — a cold/empty map
+// simply omits providerVersions from that probe, and the next probe carries it.
+const PROVIDER_VERSIONS_TTL_MS = 5 * 60 * 1000; // 5 min — provider installs change rarely
+let cachedProviderVersions: Record<string, string> = {};
+let cachedProviderVersionsAt = 0;
+let providerVersionsRefreshInFlight: Promise<void> | null = null;
+
+function refreshProviderVersionsSnapshot(providerLoader?: ProviderLoader): Promise<void> {
+    if (providerVersionsRefreshInFlight) return providerVersionsRefreshInFlight;
+    providerVersionsRefreshInFlight = (async () => {
+        try {
+            const detected = await detectCLIs(providerLoader, { includeVersion: true });
+            cachedProviderVersions = buildProviderVersions(detected);
+            cachedProviderVersionsAt = Date.now();
+        } catch {
+            // Best-effort: keep the last good snapshot on failure.
+        } finally {
+            providerVersionsRefreshInFlight = null;
+        }
+    })();
+    return providerVersionsRefreshInFlight;
+}
+
+/**
+ * Return the current cached provider-versions map for this daemon, triggering a
+ * lazy background refresh when the snapshot is stale/cold. Never blocks: returns
+ * whatever is currently cached (an empty object before the first refresh lands).
+ * This is the source the git_status envelope reads to self-report a node's
+ * provider versions to the mesh coordinator.
+ */
+export function getCachedProviderVersions(providerLoader?: ProviderLoader): Record<string, string> {
+    const stale = Date.now() - cachedProviderVersionsAt > PROVIDER_VERSIONS_TTL_MS;
+    if (stale) {
+        // Fire-and-forget; the current (possibly empty) snapshot is returned now.
+        void refreshProviderVersionsSnapshot(providerLoader);
+    }
+    return { ...cachedProviderVersions };
+}

package/src/detection/ide-detector.ts

@@ -7,11 +7,14 @@
  * Migrated from @adhdev/core — this is now the single source of truth.
  */
 
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+import { existsSync, statSync } from 'fs';
 import { platform, homedir } from 'os';
 import * as path from 'path';
 import type { ProviderLoader } from '../providers/provider-loader.js';
+import { isKnownWin32GuiExe, readWin32IdeVersionFromDisk } from './win32-ide-version.js';
 
 // ─── Types ──────────────────────────────────────
 
@@ -73,25 +76,54 @@ function findCliCommand(command: string): string | null {
         const resolved = path.isAbsolute(candidate) ? candidate : path.resolve(candidate);
         return existsSync(resolved) ? resolved : null;
     }
-    try {
-        const result = execSync(
-            platform() === 'win32' ? `where ${trimmed}` : `which ${trimmed}`,
-            { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
-        ).trim();
-        return result.split('\n')[0] || null;
-    } catch {
-        return null;
+    const isWin = platform() === 'win32';
+    const paths = (process.env.PATH || '').split(isWin ? ';' : ':');
+    const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+    for (const p of paths) {
+        if (!p) continue;
+        for (const ext of exes) {
+            const fullPath = path.join(p, trimmed + ext);
+            try {
+                if (existsSync(fullPath)) {
+                    const stat = statSync(fullPath);
+                    if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+                        return fullPath;
+                    }
+                }
+            } catch { }
+        }
     }
+    return null;
 }
 
-function getIdeVersion(cliCommand: string): string | null {
+/**
+ * Resolve an IDE version on demand (NOT at boot).
+ *
+ * Order of preference, all spawn-free where possible:
+ *  1. win32: read the bundled product.json/package.json next to the exe.
+ *  2. Otherwise spawn `<cli> --version` — but ONLY when the binary is not a
+ *     known GUI executable (the #4 guard), so we never boot an IDE window.
+ *
+ * `win32ProcessNames` is provider.json `processNames.win32` (type → exe names),
+ * used to recognise GUI executables. Callers that have a ProviderLoader can
+ * pass `providerLoader.getWinProcessNames()`.
+ */
+export async function getIdeVersion(
+    cliCommand: string,
+    win32ProcessNames: Record<string, string[]> = {},
+): Promise<string | null> {
+    if (platform() === 'win32') {
+        const fromDisk = readWin32IdeVersionFromDisk(cliCommand);
+        if (fromDisk) return fromDisk;
+        // Refuse to spawn a known GUI exe — it would launch the IDE window.
+        if (isKnownWin32GuiExe(cliCommand, win32ProcessNames)) return null;
+    }
     try {
-        const result = execSync(`"${cliCommand}" --version`, {
+        const { stdout } = await execAsync(`"${cliCommand}" --version`, {
             encoding: 'utf-8',
             timeout: 10000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-        return result.split('\n')[0] || null;
+        });
+        return stdout.trim().split('\n')[0] || null;
     } catch {
         return null;
     }
@@ -152,7 +184,14 @@ export async function detectIDEs(providerLoader?: ProviderLoader): Promise<IDEIn
         const installed = os === 'darwin'
             ? !!(resolvedCli || appPath)
             : !!resolvedCli;
-        const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
+        // Boot-time IDE detection must NOT spawn `<cli> --version`. On Windows
+        // the resolved "CLI" is frequently the GUI Electron exe (case-insensitive
+        // FS matches `...\cursor\cursor.exe` against `Cursor.exe`), and running it
+        // with `--version` boots the IDE window. `installed` is decided purely by
+        // existsSync above, and the dashboard drops `version` anyway — the only
+        // real version consumer is provider-loader.resolve() at CDP attach time,
+        // which fetches the version lazily. So leave it null here.
+        const version: string | null = null;
 
         results.push({
             id: def.id,

package/src/detection/win32-ide-version.ts

@@ -0,0 +1,106 @@
+/**
+ * ADHDev — Windows IDE version detection (execution-free)
+ *
+ * On Windows the resolved "CLI" for a VS Code fork (Cursor, Antigravity, …)
+ * frequently resolves to the GUI Electron executable itself, because the
+ * case-insensitive filesystem matches `...\cursor\cursor.exe` against the
+ * real `Cursor.exe`. Running `<that exe> --version` boots the GUI instead of
+ * printing a version (Electron ignores the unknown flag and opens a window).
+ *
+ * To learn the version WITHOUT spawning anything, we read the bundled
+ * `product.json` / `package.json` that ship next to the executable. VS Code
+ * forks embed their version there. This is a pure filesystem read.
+ *
+ * It also exposes a guard so any remaining `--version` exec path can refuse to
+ * spawn a binary that is a known GUI executable for an IDE provider.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Candidate locations for the version manifest relative to the GUI exe dir.
+ * VS Code forks place `resources/app/{product,package}.json` next to the exe.
+ */
+function manifestCandidates(exeDir: string): string[] {
+  return [
+    path.join(exeDir, 'resources', 'app', 'product.json'),
+    path.join(exeDir, 'resources', 'app', 'package.json'),
+    // Some packagings keep product.json one level up.
+    path.join(exeDir, 'product.json'),
+  ];
+}
+
+function parseVersionFromManifest(raw: string): string | null {
+  try {
+    const json = JSON.parse(raw) as Record<string, unknown>;
+    // product.json forks expose the IDE's own version here; package.json
+    // exposes the upstream VS Code engine version. Prefer the former.
+    const candidate = json.version;
+    if (typeof candidate === 'string' && candidate.trim()) {
+      return candidate.trim();
+    }
+  } catch {
+    /* not valid JSON — ignore */
+  }
+  return null;
+}
+
+/**
+ * Read an IDE version from disk (no process spawn).
+ *
+ * @param exePath Absolute path to the GUI executable (or any path inside the
+ *   IDE install dir — we read the manifest relative to its directory).
+ * @returns The version string, or null if it could not be determined.
+ */
+export function readWin32IdeVersionFromDisk(exePath: string): string | null {
+  if (!exePath) return null;
+  let exeDir: string;
+  try {
+    exeDir = fs.statSync(exePath).isDirectory() ? exePath : path.dirname(exePath);
+  } catch {
+    exeDir = path.dirname(exePath);
+  }
+  for (const candidate of manifestCandidates(exeDir)) {
+    try {
+      if (!fs.existsSync(candidate)) continue;
+      const version = parseVersionFromManifest(fs.readFileSync(candidate, 'utf-8'));
+      if (version) return version;
+    } catch {
+      /* ignore unreadable manifest */
+    }
+  }
+  return null;
+}
+
+/**
+ * True when `binPath` resolves to a known GUI executable for some IDE.
+ *
+ * Used as a safety net: any code path about to run `<bin> --version` must skip
+ * the spawn when the binary is actually the GUI Electron exe, since that would
+ * launch the IDE window. Comparison is case-insensitive on the basename
+ * (Windows filesystem semantics) against every provider's `processNames.win32`.
+ *
+ * @param binPath Resolved binary path that would be exec'd.
+ * @param win32ProcessNames Map of provider type → list of GUI exe names
+ *   (from provider.json `processNames.win32`, e.g. `["Cursor.exe"]`).
+ */
+export function isKnownWin32GuiExe(
+  binPath: string | null | undefined,
+  win32ProcessNames: Record<string, string[]>,
+): boolean {
+  if (!binPath) return false;
+  // Use win32 basename semantics regardless of host OS: this matches Windows
+  // paths even when the daemon-core test/CI host is POSIX (where `/` is the
+  // only separator). On the real win32 target this is identical to basename().
+  const base = path.win32.basename(binPath).toLowerCase();
+  if (!base.endsWith('.exe')) return false;
+  for (const names of Object.values(win32ProcessNames)) {
+    for (const name of names) {
+      if (typeof name === 'string' && name.toLowerCase() === base) {
+        return true;
+      }
+    }
+  }
+  return false;
+}