@adhdev/daemon-core 1.0.18-rc.19 → 1.0.18-rc.2

package/src/commands/upgrade-helper.ts

@@ -4,18 +4,11 @@ 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';
 
@@ -144,68 +137,19 @@ 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,
+    installPrefix: packageRoot ? resolveInstallPrefixFromPackageRoot(packageRoot, options.packageName) : null,
     execOptions: npmInvocation.execOptions,
   };
 }
@@ -291,11 +235,77 @@ 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;
@@ -303,7 +313,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 (killProcess(pid)) killedPid = pid;
+        if (killPid(pid)) killedPid = pid;
       }
     }
   } catch {
@@ -420,7 +430,7 @@ export async function stopForeignNativeAddonHolders(
     appendUpgradeLog(
       `Foreign native-addon holder found: pid ${holder.pid}${holder.commandLine ? ` — ${holder.commandLine}` : ''}`,
     );
-    const killed = killProcess(holder.pid);
+    const killed = killPid(holder.pid);
     if (killed) {
       await waitForPidExit(holder.pid, 15000);
       appendUpgradeLog(`Terminated foreign native-addon holder pid ${holder.pid}`);
@@ -590,55 +600,21 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
       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,
+    await performWindowsAtomicUpgrade({
+      layout: windowsInstallerLayout,
+      packageName: payload.packageName,
+      targetVersion: payload.targetVersion,
+      portableNode,
+      hooks: createDefaultWindowsAtomicHooks({
         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;
-    }
+        npmCliPath,
+        restartArgv,
+        cwd: payload.cwd || process.cwd(),
+        env: Object.fromEntries(Object.entries(process.env).filter(([key]) => key !== UPGRADE_HELPER_ENV)),
+        log: appendUpgradeLog,
+      }),
+    });
     try { fs.unlinkSync(getUpgradeFailureNoticePath()); } catch { /* no previous failure notice */ }
     appendUpgradeLog('Installer-managed Windows atomic upgrade completed');
     return;