@adhdev/daemon-core 0.9.82-rc.34 → 0.9.82-rc.340

package/src/commands/stream-commands.ts

@@ -245,6 +245,14 @@ export function normalizeProviderScriptArgs(args: any, scriptName?: string): Rec
 function buildControlScriptResult(scriptName: string, payload: any): Record<string, unknown> {
     if (!payload || typeof payload !== 'object') return {};
 
+    // The spec-driven control adapter (open_picker LIST/SELECT) already
+    // produced a structured controlResult by parsing the live screen. Honour
+    // it verbatim instead of re-deriving one from legacy payload shapes —
+    // otherwise the screen-parsed options/currentValue get clobbered.
+    if (payload.controlResult && typeof payload.controlResult === 'object') {
+        return { controlResult: payload.controlResult };
+    }
+
     const legacyListPayload = (() => {
         if (Array.isArray(payload.options)) return payload;
         if (/^listmodels$/i.test(scriptName) && Array.isArray(payload.models)) {

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 };
@@ -293,42 +321,64 @@ function removeDaemonPidFile(): void {
   }
 }
 
-function cleanupStaleGlobalInstallDirs(pkgName: string, surface: CurrentGlobalInstallSurface): void {
-  const prefixArgs = surface.installPrefix ? ['--prefix', surface.installPrefix] : [];
-  const npmRoot = String(execNpmCommandSync(['root', '-g', ...prefixArgs], { encoding: 'utf8' }, surface)).trim();
-  if (!npmRoot) return;
-  const npmPrefix = surface.installPrefix
-    || String(execNpmCommandSync(['prefix', '-g', ...prefixArgs], { encoding: 'utf8' }, surface)).trim();
-  const binDir = process.platform === 'win32' ? npmPrefix : path.join(npmPrefix, 'bin');
-  const packageBaseName = pkgName.startsWith('@') ? pkgName.split('/')[1] : pkgName;
-  const binNames = new Set<string>([packageBaseName]);
-  if (pkgName === '@adhdev/daemon-standalone') {
-    binNames.add('adhdev-standalone');
+/**
+ * Best-effort removal of a leftover npm staging entry.
+ *
+ * A stale staging dir can hold a locked native binary — e.g. `ghostty-vt.dll`
+ * from `@adhdev/ghostty-vt-node` still mapped by a lingering session-host
+ * process — which makes `rmSync` throw `EPERM` on Windows. Staging cleanup is
+ * only housekeeping: the leftover is inert and npm creates its own fresh
+ * staging dir for the real install, so a lock on an old leftover must NOT abort
+ * the upgrade. Log and continue instead of letting the error propagate.
+ */
+export function safeRemoveStaleEntry(target: string, label: string): void {
+  try {
+    fs.rmSync(target, { recursive: true, force: true });
+    appendUpgradeLog(`${label}: ${target}`);
+  } catch (error: any) {
+    appendUpgradeLog(`Skipped locked stale entry (${error?.code || 'error'}): ${target} — ${error?.message || String(error)}`);
   }
+}
 
-  if (pkgName.startsWith('@')) {
-    const [scope, name] = pkgName.split('/');
-    const scopeDir = path.join(npmRoot, scope);
-    if (!fs.existsSync(scopeDir)) return;
-    for (const entry of fs.readdirSync(scopeDir)) {
-      if (!entry.startsWith(`.${name}-`)) continue;
-      fs.rmSync(path.join(scopeDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale scoped staging dir: ${path.join(scopeDir, entry)}`);
+export function cleanupStaleGlobalInstallDirs(pkgName: string, surface: CurrentGlobalInstallSurface): void {
+  // The whole routine is housekeeping — never let it throw out and abort the
+  // upgrade (npm root/prefix probing or readdir can fail for unrelated reasons).
+  try {
+    const prefixArgs = surface.installPrefix ? ['--prefix', surface.installPrefix] : [];
+    const npmRoot = String(execNpmCommandSync(['root', '-g', ...prefixArgs], { encoding: 'utf8' }, surface)).trim();
+    if (!npmRoot) return;
+    const npmPrefix = surface.installPrefix
+      || String(execNpmCommandSync(['prefix', '-g', ...prefixArgs], { encoding: 'utf8' }, surface)).trim();
+    const binDir = process.platform === 'win32' ? npmPrefix : path.join(npmPrefix, 'bin');
+    const packageBaseName = pkgName.startsWith('@') ? pkgName.split('/')[1] : pkgName;
+    const binNames = new Set<string>([packageBaseName]);
+    if (pkgName === '@adhdev/daemon-standalone') {
+      binNames.add('adhdev-standalone');
     }
-  } else {
-    for (const entry of fs.readdirSync(npmRoot)) {
-      if (!entry.startsWith(`.${pkgName}-`)) continue;
-      fs.rmSync(path.join(npmRoot, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale staging dir: ${path.join(npmRoot, entry)}`);
+
+    if (pkgName.startsWith('@')) {
+      const [scope, name] = pkgName.split('/');
+      const scopeDir = path.join(npmRoot, scope);
+      if (!fs.existsSync(scopeDir)) return;
+      for (const entry of fs.readdirSync(scopeDir)) {
+        if (!entry.startsWith(`.${name}-`)) continue;
+        safeRemoveStaleEntry(path.join(scopeDir, entry), 'Removed stale scoped staging dir');
+      }
+    } else {
+      for (const entry of fs.readdirSync(npmRoot)) {
+        if (!entry.startsWith(`.${pkgName}-`)) continue;
+        safeRemoveStaleEntry(path.join(npmRoot, entry), 'Removed stale staging dir');
+      }
     }
-  }
 
-  if (fs.existsSync(binDir)) {
-    for (const entry of fs.readdirSync(binDir)) {
-      if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
-      fs.rmSync(path.join(binDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale bin staging entry: ${path.join(binDir, entry)}`);
+    if (fs.existsSync(binDir)) {
+      for (const entry of fs.readdirSync(binDir)) {
+        if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
+        safeRemoveStaleEntry(path.join(binDir, entry), 'Removed stale bin staging entry');
+      }
     }
+  } catch (error: any) {
+    appendUpgradeLog(`Stale staging cleanup skipped (${error?.code || 'error'}): ${error?.message || String(error)}`);
   }
 }
 
@@ -375,6 +425,7 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
       encoding: 'utf8',
       stdio: 'pipe',
       maxBuffer: 20 * 1024 * 1024,
+      env: buildInstallEnvWithNodeOnPath(),
       ...installCommand.execOptions,
     },
   );