@adhdev/daemon-core 0.9.82-rc.358 → 0.9.82-rc.359

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

@@ -40,6 +40,34 @@ export declare function buildPinnedGlobalInstallCommand(options: {
 export declare function getNpmExecOptions(platform?: NodeJS.Platform): NpmExecOptions;
 export declare function execNpmCommandSync(args: string[], options?: ExecFileSyncOptions, surface?: Pick<CurrentGlobalInstallSurface, 'npmExecutable' | 'npmArgsPrefix' | 'execOptions'>): Buffer | string;
 export declare function stopSessionHostProcesses(appName: string): Promise<void>;
+/**
+ * Enumerate processes that have a locked native addon (conpty.node /
+ * ghostty-vt.dll) of *this* install memory-mapped.
+ *
+ * `stopSessionHostProcesses()` only knows the single managed session-host pid, so
+ * any *foreign* holder — e.g. an orphaned `pty_*probe*.cjs` left in `%TEMP%` — is
+ * invisible to it and keeps the addon locked through every install retry, dooming
+ * the upgrade with EBUSY. This scans by the module's full path so we only ever
+ * target a holder of the exact `packageRoot` being replaced (never an unrelated
+ * install's copy). Windows-only — these locks don't exist on POSIX.
+ */
+export declare function listForeignNativeAddonHolders(packageRoot: string | null | undefined): Array<{
+    pid: number;
+    commandLine: string | null;
+}>;
+/**
+ * Terminate every foreign process holding this install's native addon mapped,
+ * then wait for each to actually exit so the mapping is released before npm
+ * copies the file into its staging dir. Returns what it found/killed so the
+ * caller can surface an actionable recovery message on failure.
+ */
+export declare function stopForeignNativeAddonHolders(packageRoot: string | null | undefined, options?: {
+    parentPid?: number;
+}): Promise<Array<{
+    pid: number;
+    commandLine: string | null;
+    killed: boolean;
+}>>;
 /**
  * Best-effort removal of a leftover npm staging entry.
  *

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "7210e80591d8d9ab378ee786ffb233027437461a" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "7210e805" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.358" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-23T01:40:53.249Z" : void 0);
+  const commit = readInjected(true ? "56a1f2a986ab2c2bb7888189d9b027d6067f2317" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "56a1f2a9" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.359" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-23T05:03:11.133Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -13015,9 +13015,7 @@ function isLocalAutoLaunchNode(node) {
   const machineId = readNonEmptyString2(node?.machineId);
   const appConfig = loadConfig();
   const localMachineId = readNonEmptyString2(appConfig.machineId) || readNonEmptyString2(appConfig.registeredMachineId);
-  const cloudDaemonId = localMachineId ? `daemon_${localMachineId}` : "";
-  const standaloneDaemonId = localMachineId ? `standalone_${localMachineId}` : "";
-  const daemonMatchesLocal = !daemonId || daemonId === cloudDaemonId || daemonId === standaloneDaemonId;
+  const daemonMatchesLocal = !daemonId || daemonIdsEquivalent(daemonId, localMachineId);
   const machineMatchesLocal = !machineId || !!localMachineId && machineId === localMachineId;
   if (node?.isLocalWorktree === true) {
     return daemonMatchesLocal && machineMatchesLocal;
@@ -13953,7 +13951,7 @@ function injectMeshSystemMessage(components, args) {
               targetNodeId: autoNodeId
             });
             LOG.info("MeshRecovery", `Auto-requeued failed task: ${task.id} for node ${autoNodeId}`);
-            const node = mesh?.nodes.find((n) => n.id === autoNodeId);
+            const node = mesh?.nodes.find((n) => meshNodeIdMatches(n, autoNodeId));
             if (node) {
               components.cliManager.handleCliCommand("launch_cli", {
                 cliType: recoveryContext.failedProviderType,
@@ -14683,7 +14681,7 @@ async function pullRemoteNodeQueues(components, mesh, localDaemonId, candidateDa
   for (const node of mesh.nodes) {
     const nodeDaemonId = readNonEmptyString2(node.daemonId);
     if (!nodeDaemonId) continue;
-    if (localDaemonId && nodeDaemonId === localDaemonId) continue;
+    if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) continue;
     if (candidateDaemonIds.includes(nodeDaemonId)) continue;
     for (const pendingEventArgs of pulls) {
       let events;
@@ -14740,7 +14738,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     if (!sessionId || !nodeId || !taskId) continue;
     const node = nodeById.get(nodeId);
     const nodeDaemonId = readNonEmptyString2(node?.daemonId);
-    const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || localDaemonId !== void 0 && nodeDaemonId === localDaemonId || !!components.instanceManager.getInstance(sessionId);
+    const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
     const providerType = readNonEmptyString2(dispatch.providerType);
     const readArgs = {
       sessionId,
@@ -14815,7 +14813,7 @@ async function collectLiveNodesWithSessions(components, mesh, selfIds, localDaem
   const dispatchMeshCommand = components.dispatchMeshCommand;
   return Promise.all(mesh.nodes.map(async (node) => {
     const nodeDaemonId = readNonEmptyString2(node.daemonId);
-    const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || localDaemonId !== void 0 && nodeDaemonId === localDaemonId;
+    const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
     let statusResult;
     try {
       if (isLocalNode) {
@@ -44872,6 +44870,7 @@ function buildInstallEnvWithNodeOnPath(baseEnv = process.env) {
   const pathKey = Object.keys(env).find((k) => k.toLowerCase() === "path") || "PATH";
   const current = env[pathKey] || "";
   env[pathKey] = current ? `${nodeBinDir};${current}` : nodeBinDir;
+  env.ADHDEV_BOOTSTRAP = "1";
   return env;
 }
 function getNpmExecOptions(platform10 = process.platform) {
@@ -44981,6 +44980,94 @@ async function stopSessionHostProcesses(appName) {
     await waitForPidExit(killedPid, 15e3);
   }
 }
+var LOCKED_NATIVE_ADDON_BASENAMES = ["conpty.node", "ghostty-vt.dll"];
+function listForeignNativeAddonHolders(packageRoot) {
+  if (process.platform !== "win32" || !packageRoot) return [];
+  const rootLower = packageRoot.replace(/\//g, "\\").replace(/'/g, "''").toLowerCase();
+  const endsWithChecks = LOCKED_NATIVE_ADDON_BASENAMES.map((name) => `$lf.EndsWith('${name}')`).join(" -or ");
+  const script = [
+    `$root = '${rootLower}'`,
+    `Get-Process node -ErrorAction SilentlyContinue | ForEach-Object {`,
+    `  $p = $_`,
+    `  try {`,
+    `    foreach ($m in $p.Modules) {`,
+    `      $fn = $m.FileName`,
+    `      if ($fn) {`,
+    `        $lf = $fn.ToLower()`,
+    `        if ($lf.StartsWith($root) -and (${endsWithChecks})) { $p.Id; break }`,
+    `      }`,
+    `    }`,
+    `  } catch {}`,
+    `}`
+  ].join("\n");
+  let out = "";
+  try {
+    out = String((0, import_child_process8.execFileSync)("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      script
+    ], { encoding: "utf8", timeout: 8e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true })).trim();
+  } catch {
+    return [];
+  }
+  const selfPid = process.pid;
+  const seen = /* @__PURE__ */ new Set();
+  const holders = [];
+  for (const line of out.split(/\r?\n/)) {
+    const pid = Number.parseInt(line.trim(), 10);
+    if (!Number.isFinite(pid) || pid <= 0 || pid === selfPid || seen.has(pid)) continue;
+    seen.add(pid);
+    holders.push({ pid, commandLine: getProcessCommandLine(pid) });
+  }
+  return holders;
+}
+async function stopForeignNativeAddonHolders(packageRoot, options = {}) {
+  if (process.platform !== "win32" || !packageRoot) return [];
+  const parentPid = Number.isFinite(options.parentPid) ? Number(options.parentPid) : -1;
+  const holders = listForeignNativeAddonHolders(packageRoot);
+  const results = [];
+  for (const holder of holders) {
+    if (holder.pid === parentPid) continue;
+    appendUpgradeLog(
+      `Foreign native-addon holder found: pid ${holder.pid}${holder.commandLine ? ` \u2014 ${holder.commandLine}` : ""}`
+    );
+    const killed = killPid(holder.pid);
+    if (killed) {
+      await waitForPidExit(holder.pid, 15e3);
+      appendUpgradeLog(`Terminated foreign native-addon holder pid ${holder.pid}`);
+    } else {
+      appendUpgradeLog(`Failed to terminate foreign native-addon holder pid ${holder.pid}`);
+    }
+    results.push({ ...holder, killed });
+  }
+  return results;
+}
+function getUpgradeFailureNoticePath() {
+  const home = os27.homedir();
+  const dir = path36.join(home, ".adhdev");
+  try {
+    fs25.mkdirSync(dir, { recursive: true });
+  } catch {
+  }
+  return path36.join(dir, "daemon-upgrade-last-error.txt");
+}
+function buildManualRecoveryCommand(installCommand) {
+  return [installCommand.command, ...installCommand.args].map((part) => /\s/.test(part) ? `"${part}"` : part).join(" ");
+}
+function emitUpgradeFailureNotice(lines) {
+  const body = lines.join("\n");
+  appendUpgradeLog(`Upgrade blocked \u2014 user action required:
+${body}`);
+  try {
+    fs25.writeFileSync(getUpgradeFailureNoticePath(), `[${(/* @__PURE__ */ new Date()).toISOString()}]
+${body}
+`, "utf8");
+  } catch {
+  }
+}
 function isRetriableInstallLockError(error) {
   const code = error?.code;
   if (code === "EBUSY" || code === "EPERM") return true;
@@ -45067,6 +45154,7 @@ async function runDaemonUpgradeHelper(payload) {
   }
   await stopSessionHostProcesses(sessionHostAppName);
   removeDaemonPidFile();
+  await stopForeignNativeAddonHolders(installCommand.surface.packageRoot, { parentPid: payload.parentPid });
   cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
   const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
   appendUpgradeLog(`Installing ${spec}`);
@@ -45088,11 +45176,30 @@ async function runDaemonUpgradeHelper(payload) {
       break;
     } catch (error) {
       if (attempt < maxInstallAttempts && isRetriableInstallLockError(error)) {
-        appendUpgradeLog(`Install attempt ${attempt} hit a file lock (${error?.code || "lock"}); cleaning staging and retrying after backoff`);
+        appendUpgradeLog(`Install attempt ${attempt} hit a file lock (${error?.code || "lock"}); clearing holders + staging and retrying after backoff`);
+        await stopForeignNativeAddonHolders(installCommand.surface.packageRoot, { parentPid: payload.parentPid });
         cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
         await new Promise((resolve24) => setTimeout(resolve24, attempt * 1500));
         continue;
       }
+      if (isRetriableInstallLockError(error)) {
+        const blockers = listForeignNativeAddonHolders(installCommand.surface.packageRoot);
+        const notice = [
+          `adhdev ${spec} could not be installed: a file lock (${error?.code || "EBUSY/EPERM"}) is blocking the native addon.`
+        ];
+        if (blockers.length > 0) {
+          notice.push("Processes still holding the lock:");
+          for (const b of blockers) {
+            notice.push(`  pid ${b.pid}${b.commandLine ? ` \u2014 ${b.commandLine}` : ""}`);
+          }
+          notice.push("To recover, stop them and reinstall:");
+          notice.push(`  Stop-Process -Id ${blockers.map((b) => b.pid).join(",")} -Force`);
+        } else {
+          notice.push("To recover, reinstall manually:");
+        }
+        notice.push(`  ${buildManualRecoveryCommand(installCommand)}`);
+        emitUpgradeFailureNotice(notice);
+      }
       throw error;
     }
   }
@@ -47759,7 +47866,7 @@ var DaemonCommandRouter = class {
     return sanitizedInlineMesh;
   }
   async getMeshForCommand(meshId, inlineMesh, options) {
-    const preferInline = options?.preferInline === true;
+    const preferInline = options?.preferInline !== false;
     if (preferInline) {
       const cached4 = this.getCachedInlineMesh(meshId);
       if (cached4) {
@@ -52118,7 +52225,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync46, readFileSync: readFileSync37, writeFileSync: writeFileSync23, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
+          const { existsSync: existsSync46, readFileSync: readFileSync37, writeFileSync: writeFileSync24, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
           const { dirname: dirname17 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -52191,7 +52298,7 @@ ${ptyResult.output.slice(-2e3)}`);
             }
           };
           try {
-            writeFileSync23(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+            writeFileSync24(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
           } catch (error) {
             const message = `Could not write MCP config for automatic setup: ${error?.message || error}`;
             LOG.error("MeshCoordinator", message);