@adhdev/daemon-core 1.0.17 → 1.0.18-rc.10

package/src/commands/upgrade-helper.ts

@@ -3,6 +3,19 @@ import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import {
+  ADHDEV_OWNED_MARKERS,
+  createDefaultWindowsAtomicHooks,
+  findPortableNode22,
+  performWindowsAtomicUpgrade,
+  resolveWindowsInstallerLayout,
+} from './windows-atomic-upgrade.js';
+import {
+  getProcessCommandLine,
+  killProcess,
+  stopOwnedProcessesForPrefixes,
+  waitForPidExit,
+} from './process-lifecycle.js';
 
 const UPGRADE_HELPER_ENV = 'ADHDEV_DAEMON_UPGRADE_HELPER';
 
@@ -32,17 +45,16 @@ export interface PinnedGlobalInstallCommand {
 
 export type NpmExecOptions = { shell: boolean; windowsHide?: boolean };
 
-function getUpgradeLogPath(): string {
-  const home = os.homedir();
+function getUpgradeLogPath(home: string = os.homedir()): string {
   const dir = path.join(home, '.adhdev');
   fs.mkdirSync(dir, { recursive: true });
   return path.join(dir, 'daemon-upgrade.log');
 }
 
-function appendUpgradeLog(message: string): void {
+function appendUpgradeLog(message: string, homeDir: string = os.homedir()): void {
   const line = `[${new Date().toISOString()}] ${message}\n`;
   try {
-    fs.appendFileSync(getUpgradeLogPath(), line, 'utf8');
+    fs.appendFileSync(getUpgradeLogPath(homeDir), line, 'utf8');
   } catch {
     // noop
   }
@@ -132,19 +144,68 @@ function resolveInstallPrefixFromPackageRoot(packageRoot: string, packageName: s
   return maybeLibDir;
 }
 
+// True when `prefix` is the bin dir of a portable Node 22 the installer manages
+// under ~/.adhdev/tools/node22/<node-vX>/. A `npm i -g adhdev` run while that
+// portable node is the active `node` installs adhdev into node's own default
+// global prefix (= that dir) — a "legacy node22-prefix" install that lives at
+// the FRONT of PATH (Enable-NodePath prepends node22) and shadows the canonical
+// dispatcher shims in ~/.adhdev/npm-global. Because self-upgrade reuses the
+// running prefix, that install then re-installs into the same node22 dir forever
+// and never converts to the dispatcher. Detecting it lets us force convergence.
+function isPortableNode22Prefix(prefix: string | null, homeDir: string): boolean {
+  if (!prefix) return false;
+  const portableRoot = path.join(homeDir, '.adhdev', 'tools', 'node22');
+  const normalizedPrefix = path.resolve(prefix).replace(/[\\/]+$/, '').toLowerCase();
+  const normalizedRoot = path.resolve(portableRoot).replace(/[\\/]+$/, '').toLowerCase();
+  return normalizedPrefix === normalizedRoot || normalizedPrefix.startsWith(`${normalizedRoot}${path.sep.toLowerCase()}`);
+}
+
+// Redirect a legacy node22-prefix install to the canonical dispatcher install
+// root so resolveWindowsInstallerLayout accepts it and the atomic-upgrade
+// publishes the ~/.adhdev/npm-global pointer + shims. Prefer the version the
+// dispatcher pointer already names (so we sit on the real active dispatcher
+// prefix); otherwise synthesize a stable migration sentinel under npm-installs.
+// resolveWindowsInstallerLayout only requires a `npm-installs/version-*` path —
+// performWindowsAtomicUpgrade stages a fresh version- prefix of its own and uses
+// this only as the "old prefix" to stop/clean, so a non-existent path is a no-op.
+function canonicalDispatcherInstallPrefix(homeDir: string): string {
+  const installRoot = path.join(homeDir, '.adhdev', 'npm-installs');
+  const pointerPath = path.join(homeDir, '.adhdev', 'npm-global', '.adhdev-current');
+  try {
+    const activeVersion = fs.readFileSync(pointerPath, 'utf8').trim();
+    if (activeVersion.startsWith('version-')) return path.join(installRoot, activeVersion);
+  } catch {
+    // No dispatcher pointer yet (first migration off the legacy layout).
+  }
+  return path.join(installRoot, 'version-legacy-migrate');
+}
+
 export function resolveCurrentGlobalInstallSurface(options: {
   packageName: string;
   currentCliPath?: string;
   nodeExecutable?: string;
   platform?: NodeJS.Platform;
+  homeDir?: string;
 }): CurrentGlobalInstallSurface {
   const packageRoot = findCurrentPackageRoot(options.currentCliPath || process.argv[1], options.packageName);
   const npmInvocation = resolveSiblingNpmInvocation(options.nodeExecutable || process.execPath, options.platform);
+  const platform = options.platform || process.platform;
+  const homeDir = options.homeDir || os.homedir();
+  let installPrefix = packageRoot ? resolveInstallPrefixFromPackageRoot(packageRoot, options.packageName) : null;
+  // FIX C: on Windows, never let a self-upgrade perpetuate the legacy
+  // node22-prefix install. If the running adhdev lives under ~/.adhdev/tools/
+  // node22, force the install onto the canonical dispatcher prefix so the update
+  // converges to the ~/.adhdev/npm-global pointer + shims. Scoped to win32 AND a
+  // tools/node22 prefix so npm-linked dev / standalone / real dispatcher installs
+  // are untouched.
+  if (platform === 'win32' && isPortableNode22Prefix(installPrefix, homeDir)) {
+    installPrefix = canonicalDispatcherInstallPrefix(homeDir);
+  }
   return {
     npmExecutable: npmInvocation.executable,
     npmArgsPrefix: npmInvocation.argsPrefix,
     packageRoot,
-    installPrefix: packageRoot ? resolveInstallPrefixFromPackageRoot(packageRoot, options.packageName) : null,
+    installPrefix,
     execOptions: npmInvocation.execOptions,
   };
 }
@@ -230,77 +291,11 @@ export function execNpmCommandSync(
   );
 }
 
-function killPid(pid: number): boolean {
-  try {
-    if (process.platform === 'win32') {
-      execFileSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
-    } else {
-      process.kill(pid, 'SIGTERM');
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function getWindowsProcessCommandLine(pid: number): string | null {
-  const pidFilter = `ProcessId=${pid}`;
-  try {
-    const psOut = execFileSync('powershell.exe', [
-      '-NoProfile',
-      '-NonInteractive',
-      '-ExecutionPolicy', 'Bypass',
-      '-Command',
-      `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`,
-    ], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }).trim();
-    if (psOut) return psOut;
-  } catch {
-    // fall through to wmic fallback
-  }
-
-  try {
-    const wmicOut = execFileSync('wmic', [
-      'process', 'where', pidFilter, 'get', 'CommandLine',
-    ], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }).trim();
-    if (wmicOut) return wmicOut;
-  } catch {
-    // noop
-  }
-  return null;
-}
-
-function getProcessCommandLine(pid: number): string | null {
-  if (!Number.isFinite(pid) || pid <= 0) return null;
-  if (process.platform === 'win32') return getWindowsProcessCommandLine(pid);
-  try {
-    const text = execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
-      encoding: 'utf8',
-      timeout: 3000,
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim();
-    return text || null;
-  } catch {
-    return null;
-  }
-}
-
 function isManagedSessionHostPid(pid: number): boolean {
   const commandLine = getProcessCommandLine(pid);
   return !!commandLine && /session-host-daemon/i.test(commandLine);
 }
 
-async function waitForPidExit(pid: number, timeoutMs: number): Promise<void> {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    try {
-      process.kill(pid, 0);
-      await new Promise((resolve) => setTimeout(resolve, 250));
-    } catch {
-      return;
-    }
-  }
-}
-
 export async function stopSessionHostProcesses(appName: string): Promise<void> {
   const pidFile = path.join(os.homedir(), '.adhdev', `${appName}-session-host.pid`);
   let killedPid: number | null = null;
@@ -308,7 +303,7 @@ export async function stopSessionHostProcesses(appName: string): Promise<void> {
     if (fs.existsSync(pidFile)) {
       const pid = Number.parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
       if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
-        if (killPid(pid)) killedPid = pid;
+        if (killProcess(pid)) killedPid = pid;
       }
     }
   } catch {
@@ -425,7 +420,7 @@ export async function stopForeignNativeAddonHolders(
     appendUpgradeLog(
       `Foreign native-addon holder found: pid ${holder.pid}${holder.commandLine ? ` — ${holder.commandLine}` : ''}`,
     );
-    const killed = killPid(holder.pid);
+    const killed = killProcess(holder.pid);
     if (killed) {
       await waitForPidExit(holder.pid, 15000);
       appendUpgradeLog(`Terminated foreign native-addon holder pid ${holder.pid}`);
@@ -437,8 +432,7 @@ export async function stopForeignNativeAddonHolders(
   return results;
 }
 
-function getUpgradeFailureNoticePath(): string {
-  const home = os.homedir();
+function getUpgradeFailureNoticePath(home: string = os.homedir()): string {
   const dir = path.join(home, '.adhdev');
   try {
     fs.mkdirSync(dir, { recursive: true });
@@ -459,11 +453,11 @@ function buildManualRecoveryCommand(installCommand: PinnedGlobalInstallCommand):
  * log line: the pids/commandlines still holding the lock and a paste-ready
  * recovery command. Written to a stable path the CLI can surface on next boot.
  */
-function emitUpgradeFailureNotice(lines: string[]): void {
+export function emitUpgradeFailureNotice(lines: string[], homeDir: string = os.homedir()): void {
   const body = lines.join('\n');
-  appendUpgradeLog(`Upgrade blocked — user action required:\n${body}`);
+  appendUpgradeLog(`Upgrade blocked — user action required:\n${body}`, homeDir);
   try {
-    fs.writeFileSync(getUpgradeFailureNoticePath(), `[${new Date().toISOString()}]\n${body}\n`, 'utf8');
+    fs.writeFileSync(getUpgradeFailureNoticePath(homeDir), `[${new Date().toISOString()}]\n${body}\n`, 'utf8');
   } catch {
     // noop
   }
@@ -582,6 +576,73 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
 
   await stopSessionHostProcesses(sessionHostAppName);
   removeDaemonPidFile();
+  const windowsInstallerLayout = resolveWindowsInstallerLayout({
+    homeDir: os.homedir(),
+    installPrefix: installCommand.surface.installPrefix,
+  });
+  if (windowsInstallerLayout) {
+    const portableNode = findPortableNode22(os.homedir());
+    if (!portableNode) {
+      throw new Error('installer-managed Windows update requires the portable Node.js 22 runtime');
+    }
+    const npmCliPath = path.join(path.dirname(portableNode), 'node_modules', 'npm', 'bin', 'npm-cli.js');
+    if (!fs.existsSync(npmCliPath)) {
+      throw new Error(`portable Node.js 22 npm CLI is missing: ${npmCliPath}`);
+    }
+    appendUpgradeLog(`Installer-managed pointer layout detected; active prefix will remain untouched: ${windowsInstallerLayout.activePrefix}`);
+
+    // Terminate any ADHDev-owned process still executing from the current active
+    // prefix or the legacy stable shim tree before activation. The parent daemon
+    // and this helper itself are excluded: the parent is already exiting, and the
+    // helper must survive to complete the upgrade.
+    const upgradePids = [process.pid, payload.parentPid].filter((n): n is number => Number.isFinite(n) && n > 0);
+    const preStop = await stopOwnedProcessesForPrefixes({
+      prefixes: [windowsInstallerLayout.activePrefix, windowsInstallerLayout.stablePrefix],
+      excludePids: upgradePids,
+      markers: Array.from(ADHDEV_OWNED_MARKERS),
+      waitMs: 15_000,
+      log: appendUpgradeLog,
+    });
+    if (preStop.survivors.length > 0) {
+      throw new Error(
+        `Cannot upgrade: owned processes still running under current prefix: ${preStop.survivors.map((s) => s.pid).join(', ')}`
+      );
+    }
+
+    try {
+      await performWindowsAtomicUpgrade({
+        layout: windowsInstallerLayout,
+        packageName: payload.packageName,
+        targetVersion: payload.targetVersion,
+        portableNode,
+        excludePids: upgradePids,
+        hooks: createDefaultWindowsAtomicHooks({
+          packageName: payload.packageName,
+          targetVersion: payload.targetVersion,
+          npmCliPath,
+          restartArgv,
+          cwd: payload.cwd || process.cwd(),
+          env: Object.fromEntries(Object.entries(process.env).filter(([key]) => key !== UPGRADE_HELPER_ENV)),
+          log: appendUpgradeLog,
+        }),
+      });
+    } catch (error: any) {
+      // performWindowsAtomicUpgrade already rolled the pointer/shims back to the
+      // prior version before rethrowing. Without a durable notice that rollback
+      // was silent — the daemon simply kept running the old version (the rc.6
+      // stuck-upgrade defect). Leave an actionable last-error file naming the
+      // target that failed its health/version gate.
+      emitUpgradeFailureNotice([
+        `adhdev ${payload.packageName}@${payload.targetVersion} upgrade failed and was rolled back: ${error?.message || String(error)}`,
+        `Previous version preserved (active prefix: ${windowsInstallerLayout.activePrefix}).`,
+        'See daemon-upgrade.log for the full install/health trace. The next daemon start will retry.',
+      ]);
+      throw error;
+    }
+    try { fs.unlinkSync(getUpgradeFailureNoticePath()); } catch { /* no previous failure notice */ }
+    appendUpgradeLog('Installer-managed Windows atomic upgrade completed');
+    return;
+  }
   // Kill any *foreign* process still holding this install's conpty.node mapped
   // (the session-host stop above only covers the single managed pid). Do this
   // BEFORE the staging GC so the just-released file can also be cleaned up now
@@ -671,6 +732,7 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
   } else {
     appendUpgradeLog('No restart argv provided; upgrade completed without restart');
   }
+  try { fs.unlinkSync(getUpgradeFailureNoticePath()); } catch { /* no previous failure notice */ }
 }
 
 export async function maybeRunDaemonUpgradeHelperFromEnv(): Promise<boolean> {
@@ -683,7 +745,12 @@ export async function maybeRunDaemonUpgradeHelperFromEnv(): Promise<boolean> {
     await runDaemonUpgradeHelper(payload);
     process.exit(0);
   } catch (error: any) {
-    appendUpgradeLog(`Upgrade helper failed: ${error?.stack || error?.message || String(error)}`);
+    const detail = error?.stack || error?.message || String(error);
+    appendUpgradeLog(`Upgrade helper failed: ${detail}`);
+    emitUpgradeFailureNotice([
+      `adhdev upgrade failed: ${error?.message || String(error)}`,
+      `See ${getUpgradeLogPath()} for details. The previous installer-managed version was preserved or restored when available.`,
+    ]);
     process.exit(1);
   }
 }