@adhdev/daemon-core 0.9.82-rc.301 → 0.9.82-rc.302

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.301",
+  "version": "0.9.82-rc.302",
   "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.301",
+    "@adhdev/mesh-shared": "0.9.82-rc.302",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapters/pty-transport.ts

@@ -1,5 +1,6 @@
 import * as os from 'os';
 import { ensureNodePtySpawnHelperPermissions } from './spawn-env.js';
+import { resolveWin32Executable } from './resolve-executable.js';
 
 let cachedPty: any | null | undefined;
 
@@ -119,7 +120,7 @@ export class NodePtyTransportFactory implements PtyTransportFactory {
         cwd = os.homedir();
       }
     }
-    const handle = pty.spawn(command, args, {
+    const handle = pty.spawn(resolveWin32Executable(command), args, {
       name: 'xterm-256color',
       cols: options.cols,
       rows: options.rows,

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

@@ -0,0 +1,45 @@
+import { execFileSync } from 'child_process';
+import { existsSync } from 'fs';
+import * as path from 'path';
+
+// Extensions ConPTY/CreateProcess can launch directly (not .cmd/.bat, which
+// need a cmd.exe wrapper).
+const DIRECT_EXEC_EXT = new Set(['.exe', '.com']);
+
+/**
+ * Resolve a launch command to an absolute executable path on Windows.
+ *
+ * node-pty's ConPTY backend resolves a bare/relative command against the
+ * *calling process's* `Path` env var and — critically — does NOT apply PATHEXT.
+ * So a provider command like `claude` never matches `claude.exe` and the native
+ * layer throws `File not found:` (empty), which crashes the daemon. We resolve
+ * it to an absolute `.exe` here (in the daemon process, which has the full PATH)
+ * before the command ever reaches node-pty.
+ *
+ * No-op on non-Windows and when the command is already an existing absolute path
+ * or cannot be resolved (caller keeps the original behaviour).
+ */
+export function resolveWin32Executable(command: string): string {
+  if (process.platform !== 'win32') return command;
+  const trimmed = (command || '').trim();
+  if (!trimmed) return command;
+
+  // Already an absolute path that exists — keep it.
+  if (path.isAbsolute(trimmed) && existsSync(trimmed)) return trimmed;
+
+  try {
+    const out = execFileSync('where', [trimmed], {
+      encoding: 'utf8',
+      windowsHide: true,
+    }).trim();
+    if (out) {
+      const matches = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+      // Prefer a directly-launchable executable (.exe/.com) over .cmd/.bat shims.
+      const direct = matches.find((m) => DIRECT_EXEC_EXT.has(path.extname(m).toLowerCase()));
+      return direct || matches[0] || command;
+    }
+  } catch {
+    // `where` not found / non-zero exit — fall through to original command.
+  }
+  return command;
+}

package/src/cli-adapters/session-host-transport.ts

@@ -6,6 +6,7 @@ import {
     type SessionHostRecord,
 } from '@adhdev/session-host-core';
 import { LOG } from '../logging/logger.js';
+import { resolveWin32Executable } from './resolve-executable.js';
 import type { PtyRuntimeMetadata, PtyRuntimeTransport, PtySpawnOptions, PtyTransportFactory } from './pty-transport.js';
 
 interface SessionHostPtyTransportFactoryOptions {
@@ -435,7 +436,7 @@ export class SessionHostPtyTransportFactory implements PtyTransportFactory {
     spawn(command: string, args: string[], spawnOptions: PtySpawnOptions): PtyRuntimeTransport {
         return new SessionHostRuntimeTransport({
             ...this.options,
-            command,
+            command: resolveWin32Executable(command),
             args,
             spawnOptions,
         });

package/src/commands/upgrade-helper.ts

@@ -169,6 +169,34 @@ export function buildPinnedGlobalInstallCommand(options: {
   };
 }
 
+/**
+ * Build an env for the `npm install` child whose PATH is prefixed with the
+ * directory of the node binary currently running this helper.
+ *
+ * npm runs lifecycle scripts (e.g. adhdev's `preinstall` Node-version guard) by
+ * spawning a bare `node`, which resolves from PATH — NOT from the node that runs
+ * npm. On Windows a machine can have several node installs (e.g. a standalone
+ * `C:\Program Files\nodejs` ahead of an nvm-managed node on PATH). Without this,
+ * the guard sees the wrong (unsupported) node version and aborts the upgrade,
+ * even though npm/adhdev actually run under a supported node. Pinning the
+ * running node's dir to the front of PATH makes lifecycle scripts use the same
+ * node as the install itself.
+ */
+function buildInstallEnvWithNodeOnPath(baseEnv: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  // The Node-version guard this works around only fires on Windows, so scope the
+  // PATH rewrite to win32 — POSIX keeps its env untouched.
+  if (process.platform !== 'win32') return { ...baseEnv };
+  const nodeBinDir = path.dirname(process.execPath);
+  if (!nodeBinDir) return { ...baseEnv };
+  const env: NodeJS.ProcessEnv = { ...baseEnv };
+  // Windows env keys are case-insensitive and conventionally spelled `Path`;
+  // prepend to the existing key (whatever its case) to avoid creating a dupe.
+  const pathKey = Object.keys(env).find((k) => k.toLowerCase() === 'path') || 'PATH';
+  const current = env[pathKey] || '';
+  env[pathKey] = current ? `${nodeBinDir};${current}` : nodeBinDir;
+  return env;
+}
+
 export function getNpmExecOptions(platform: NodeJS.Platform = process.platform): NpmExecOptions {
   if (platform === 'win32') {
     return { shell: false, windowsHide: true };
@@ -375,6 +403,7 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
       encoding: 'utf8',
       stdio: 'pipe',
       maxBuffer: 20 * 1024 * 1024,
+      env: buildInstallEnvWithNodeOnPath(),
       ...installCommand.execOptions,
     },
   );