@adhdev/daemon-core 0.9.1 → 0.9.3

package/dist/commands/upgrade-helper.d.ts

@@ -6,5 +6,26 @@ export interface DaemonUpgradeHelperPayload {
     cwd?: string;
     sessionHostAppName?: string;
 }
+export interface CurrentGlobalInstallSurface {
+    npmExecutable: string;
+    packageRoot: string | null;
+    installPrefix: string | null;
+}
+export interface PinnedGlobalInstallCommand {
+    command: string;
+    args: string[];
+    surface: CurrentGlobalInstallSurface;
+}
+export declare function resolveCurrentGlobalInstallSurface(options: {
+    packageName: string;
+    currentCliPath?: string;
+    nodeExecutable?: string;
+}): CurrentGlobalInstallSurface;
+export declare function buildPinnedGlobalInstallCommand(options: {
+    packageName: string;
+    targetVersion: string;
+    currentCliPath?: string;
+    nodeExecutable?: string;
+}): PinnedGlobalInstallCommand;
 export declare function spawnDetachedDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): void;
 export declare function maybeRunDaemonUpgradeHelperFromEnv(): Promise<boolean>;

package/dist/index.d.ts

@@ -42,8 +42,8 @@ export { DaemonCommandHandler } from './commands/handler.js';
 export type { CommandResult, CommandContext } from './commands/handler.js';
 export { DaemonCommandRouter } from './commands/router.js';
 export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
-export { maybeRunDaemonUpgradeHelperFromEnv, spawnDetachedDaemonUpgradeHelper } from './commands/upgrade-helper.js';
-export type { DaemonUpgradeHelperPayload } from './commands/upgrade-helper.js';
+export { maybeRunDaemonUpgradeHelperFromEnv, spawnDetachedDaemonUpgradeHelper, resolveCurrentGlobalInstallSurface, buildPinnedGlobalInstallCommand, } from './commands/upgrade-helper.js';
+export type { DaemonUpgradeHelperPayload, CurrentGlobalInstallSurface, PinnedGlobalInstallCommand, } from './commands/upgrade-helper.js';
 export { DaemonStatusReporter } from './status/reporter.js';
 export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
 export { buildStatusSnapshot, buildMachineInfo } from './status/snapshot.js';

package/dist/index.js

@@ -3457,10 +3457,6 @@ ${data.message || ""}`.trim();
             throw new Error(`${this.cliName} is still processing the previous prompt`);
           }
         }
-        const blockingModal = this.activeModal || this.getStartupConfirmationModal(this.terminalScreen.getText() || "");
-        if (blockingModal || this.currentStatus === "waiting_approval") {
-          throw new Error(`${this.cliName} is awaiting confirmation before it can accept a prompt`);
-        }
         this.isWaitingForResponse = true;
         this.responseBuffer = "";
         this.finishRetryCount = 0;
@@ -4043,6 +4039,7 @@ __export(index_exports, {
   buildChatMessageSignature: () => buildChatMessageSignature,
   buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
   buildMachineInfo: () => buildMachineInfo,
+  buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
   buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
   buildSessionEntries: () => buildSessionEntries,
   buildSessionModalDeliverySignature: () => buildSessionModalDeliverySignature,
@@ -4125,6 +4122,7 @@ __export(index_exports, {
   resetDebugRuntimeConfig: () => resetDebugRuntimeConfig,
   resetState: () => resetState,
   resolveChatMessageKind: () => resolveChatMessageKind,
+  resolveCurrentGlobalInstallSurface: () => resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
   resolveSessionHostAppName: () => resolveSessionHostAppName,
   resolveSessionHostAppNameResolution: () => resolveSessionHostAppNameResolution,
@@ -4781,8 +4779,8 @@ async function detectIDEs(providerLoader) {
       if ((0, import_fs3.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os20 === "win32") {
-      const { dirname: dirname6 } = await import("path");
-      const appDir = dirname6(appPath);
+      const { dirname: dirname7 } = await import("path");
+      const appDir = dirname7(appPath);
       const candidates = [
         `${appDir}\\\\bin\\\\${def.cli}.cmd`,
         `${appDir}\\\\bin\\\\${def.cli}`,
@@ -17923,9 +17921,82 @@ function appendUpgradeLog(message) {
   } catch {
   }
 }
-function getNpmExecutable() {
+function resolveSiblingNpmExecutable(nodeExecutable) {
+  const binDir = path16.dirname(nodeExecutable);
+  const candidates = process.platform === "win32" ? ["npm.cmd", "npm.exe", "npm"] : ["npm"];
+  for (const candidate of candidates) {
+    const candidatePath = path16.join(binDir, candidate);
+    if (fs8.existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
   return "npm";
 }
+function findCurrentPackageRoot(currentCliPath, packageName) {
+  if (!currentCliPath) return null;
+  let resolvedPath = currentCliPath;
+  try {
+    resolvedPath = fs8.realpathSync.native(currentCliPath);
+  } catch {
+  }
+  let currentDir = resolvedPath;
+  try {
+    if (fs8.statSync(resolvedPath).isFile()) {
+      currentDir = path16.dirname(resolvedPath);
+    }
+  } catch {
+    currentDir = path16.dirname(resolvedPath);
+  }
+  while (true) {
+    const packageJsonPath = path16.join(currentDir, "package.json");
+    try {
+      if (fs8.existsSync(packageJsonPath)) {
+        const parsed = JSON.parse(fs8.readFileSync(packageJsonPath, "utf8"));
+        if (parsed?.name === packageName) {
+          const normalized = currentDir.replace(/\\/g, "/");
+          return normalized.includes("/node_modules/") ? currentDir : null;
+        }
+      }
+    } catch {
+    }
+    const parentDir = path16.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveInstallPrefixFromPackageRoot(packageRoot, packageName) {
+  const nodeModulesDir = packageName.startsWith("@") ? path16.dirname(path16.dirname(packageRoot)) : path16.dirname(packageRoot);
+  if (path16.basename(nodeModulesDir) !== "node_modules") {
+    return null;
+  }
+  const maybeLibDir = path16.dirname(nodeModulesDir);
+  if (path16.basename(maybeLibDir) === "lib") {
+    return path16.dirname(maybeLibDir);
+  }
+  return maybeLibDir;
+}
+function resolveCurrentGlobalInstallSurface(options) {
+  const packageRoot = findCurrentPackageRoot(options.currentCliPath || process.argv[1], options.packageName);
+  return {
+    npmExecutable: resolveSiblingNpmExecutable(options.nodeExecutable || process.execPath),
+    packageRoot,
+    installPrefix: packageRoot ? resolveInstallPrefixFromPackageRoot(packageRoot, options.packageName) : null
+  };
+}
+function buildPinnedGlobalInstallCommand(options) {
+  const surface = resolveCurrentGlobalInstallSurface(options);
+  const args = ["install", "-g", `${options.packageName}@${options.targetVersion || "latest"}`, "--force"];
+  if (surface.installPrefix) {
+    args.push("--prefix", surface.installPrefix);
+  }
+  return {
+    command: surface.npmExecutable,
+    args,
+    surface
+  };
+}
 function getNpmExecOptions() {
   return { shell: process.platform === "win32" };
 }
@@ -17988,11 +18059,12 @@ function removeDaemonPidFile() {
   } catch {
   }
 }
-function cleanupStaleGlobalInstallDirs(pkgName) {
+function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   const npmExecOpts = getNpmExecOptions();
-  const npmRoot = (0, import_child_process7.execFileSync)(getNpmExecutable(), ["root", "-g"], { encoding: "utf8", ...npmExecOpts }).trim();
+  const prefixArgs = surface.installPrefix ? ["--prefix", surface.installPrefix] : [];
+  const npmRoot = (0, import_child_process7.execFileSync)(surface.npmExecutable, ["root", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
   if (!npmRoot) return;
-  const npmPrefix = (0, import_child_process7.execFileSync)(getNpmExecutable(), ["prefix", "-g"], { encoding: "utf8", ...npmExecOpts }).trim();
+  const npmPrefix = surface.installPrefix || (0, import_child_process7.execFileSync)(surface.npmExecutable, ["prefix", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
   const binDir = process.platform === "win32" ? npmPrefix : path16.join(npmPrefix, "bin");
   const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
   const binNames = /* @__PURE__ */ new Set([packageBaseName]);
@@ -18017,7 +18089,7 @@ function cleanupStaleGlobalInstallDirs(pkgName) {
   }
   if (fs8.existsSync(binDir)) {
     for (const entry of fs8.readdirSync(binDir)) {
-      if (![...binNames].some((name) => entry.startsWith(`.${name}-`))) continue;
+      if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
       fs8.rmSync(path16.join(binDir, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale bin staging entry: ${path16.join(binDir, entry)}`);
     }
@@ -18037,19 +18109,27 @@ function spawnDetachedDaemonUpgradeHelper(payload) {
 async function runDaemonUpgradeHelper(payload) {
   const restartArgv = Array.isArray(payload.restartArgv) ? payload.restartArgv : [];
   const sessionHostAppName = payload.sessionHostAppName || process.env.ADHDEV_SESSION_HOST_NAME || "adhdev";
+  const installCommand = buildPinnedGlobalInstallCommand({
+    packageName: payload.packageName,
+    targetVersion: payload.targetVersion
+  });
   appendUpgradeLog(`Upgrade helper started for ${payload.packageName}@${payload.targetVersion}`);
+  appendUpgradeLog(`Using npm executable: ${installCommand.command}`);
+  if (installCommand.surface.installPrefix) {
+    appendUpgradeLog(`Pinned install prefix: ${installCommand.surface.installPrefix}`);
+  }
   if (Number.isFinite(payload.parentPid) && payload.parentPid > 0) {
     appendUpgradeLog(`Waiting for parent pid ${payload.parentPid} to exit`);
     await waitForPidExit(payload.parentPid, 15e3);
   }
   stopSessionHostProcesses(sessionHostAppName);
   removeDaemonPidFile();
-  cleanupStaleGlobalInstallDirs(payload.packageName);
+  cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
   const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
   appendUpgradeLog(`Installing ${spec}`);
   const installOutput = (0, import_child_process7.execFileSync)(
-    getNpmExecutable(),
-    ["install", "-g", spec, "--force"],
+    installCommand.command,
+    installCommand.args,
     {
       encoding: "utf8",
       stdio: "pipe",
@@ -18062,7 +18142,7 @@ async function runDaemonUpgradeHelper(payload) {
   }
   if (process.platform === "win32") {
     await new Promise((resolve12) => setTimeout(resolve12, 500));
-    cleanupStaleGlobalInstallDirs(payload.packageName);
+    cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
     appendUpgradeLog("Post-install staging cleanup complete");
   }
   if (restartArgv.length > 0) {
@@ -26744,6 +26824,7 @@ async function shutdownDaemonComponents(components) {
   buildChatMessageSignature,
   buildChatTailDeliverySignature,
   buildMachineInfo,
+  buildPinnedGlobalInstallCommand,
   buildRuntimeSystemChatMessage,
   buildSessionEntries,
   buildSessionModalDeliverySignature,
@@ -26826,6 +26907,7 @@ async function shutdownDaemonComponents(components) {
   resetDebugRuntimeConfig,
   resetState,
   resolveChatMessageKind,
+  resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,