@adhdev/daemon-standalone 1.0.39-rc.1 → 1.0.39-rc.3

package/dist/index.js

@@ -36528,10 +36528,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "a1082159590bba25809d2f8a65c10055b8d3bc97" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "a1082159" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.39-rc.1" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-07T02:52:22.815Z" : void 0);
+      const commit = readInjected(true ? "454a3fb1673f9dd4b935c6081ae41ac24abf778f" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "454a3fb1" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.39-rc.3" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-07T11:02:28.517Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -77537,6 +77537,7 @@ ${lastSnapshot}`;
       resolveMuted: () => resolveMuted,
       resolveNodeSchedulingPriority: () => resolveNodeSchedulingPriority,
       resolveNotBefore: () => resolveNotBefore,
+      resolveNpmPublishedVersion: () => resolveNpmPublishedVersion,
       resolveProviderChannel: () => resolveProviderChannel,
       resolveProviderMaxParallel: () => resolveProviderMaxParallel,
       resolveScopedMeshId: () => resolveScopedMeshId,
@@ -90707,6 +90708,27 @@ exec "${portableNode}" "${cliEntry}" "$@"
         }
       );
     }
+    function resolveNpmPublishedVersion(packageName, tagOrVersion, surface, options = {}) {
+      const args = ["view", `${packageName}@${tagOrVersion}`, "version"];
+      const execOptions = {
+        encoding: "utf-8",
+        ..."timeout" in options ? options.timeout === void 0 ? {} : { timeout: options.timeout } : { timeout: 1e4 },
+        ...options.stdio ? { stdio: options.stdio } : {}
+      };
+      if (options.execFileSync) {
+        const runnerOptions = surface?.execOptions || getNpmExecOptions();
+        return String(options.execFileSync(
+          surface?.npmExecutable || "npm",
+          [...surface?.npmArgsPrefix || [], ...args],
+          {
+            ...execOptions,
+            ...runnerOptions,
+            ...process.platform === "win32" ? { windowsHide: true } : {}
+          }
+        )).trim();
+      }
+      return String(execNpmCommandSync(args, execOptions, surface)).trim();
+    }
     function isManagedSessionHostPid(pid) {
       const commandLine = getProcessCommandLine(pid);
       return !!commandLine && /session-host-daemon/i.test(commandLine);
@@ -90807,24 +90829,75 @@ exec "${portableNode}" "${cliEntry}" "$@"
     function buildManualRecoveryCommand(installCommand) {
       return [installCommand.command, ...installCommand.args].map((part) => /\s/.test(part) ? `"${part}"` : part).join(" ");
     }
-    function emitUpgradeFailureNotice(lines, configDir = getConfigDir2()) {
+    var UPGRADE_FAILURE_TARGET_MARKER = "adhdev-upgrade-target:";
+    function emitUpgradeFailureNotice(lines, configDir = getConfigDir2(), options = {}) {
       const body = lines.join("\n");
       appendUpgradeLog(`Upgrade blocked \u2014 user action required:
 ${body}`, configDir);
+      const target = typeof options.targetVersion === "string" ? options.targetVersion.trim() : "";
+      const marker = target ? `${UPGRADE_FAILURE_TARGET_MARKER} ${target}
+` : "";
       try {
-        fs20.writeFileSync(getUpgradeFailureNoticePath(configDir), `[${(/* @__PURE__ */ new Date()).toISOString()}]
+        fs20.writeFileSync(
+          getUpgradeFailureNoticePath(configDir),
+          `[${(/* @__PURE__ */ new Date()).toISOString()}]
 ${body}
-`, "utf8");
+${marker}`,
+          "utf8"
+        );
       } catch {
       }
     }
+    function clearUpgradeFailureNotice(configDir = getConfigDir2()) {
+      const noticePath = getUpgradeFailureNoticePath(configDir);
+      try {
+        fs20.unlinkSync(noticePath);
+      } catch (error48) {
+        if (error48?.code === "ENOENT") return;
+        appendUpgradeLog(
+          `Failed to clear stale upgrade-failure notice (${error48?.code || "error"}): ${noticePath} \u2014 ${error48?.message || String(error48)}. Investigate a file lock or permissions: until it is removed, every daemon boot will keep warning about this ALREADY-RESOLVED failure.`,
+          configDir
+        );
+      }
+    }
+    function formatUpgradeNoticeAge(ageMs2) {
+      if (ageMs2 < 0) return "in the future (clock skew?)";
+      const minutes = Math.floor(ageMs2 / 6e4);
+      if (minutes < 1) return "just now";
+      if (minutes < 60) return `${minutes}m ago`;
+      const hours = Math.floor(minutes / 60);
+      if (hours < 24) return `${hours}h ago`;
+      return `${Math.floor(hours / 24)}d ago`;
+    }
+    function parseUpgradeNoticeTimestamp(notice) {
+      const match = /^\[([^\]\n]+)\]/.exec(notice);
+      if (!match) return null;
+      const parsed = Date.parse(match[1]);
+      return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+    }
+    function parseUpgradeNoticeTargetVersion(notice) {
+      const pattern = new RegExp(`^${UPGRADE_FAILURE_TARGET_MARKER}\\s*(.+)$`, "m");
+      const match = pattern.exec(notice);
+      const value = match?.[1]?.trim();
+      return value ? value : null;
+    }
     function readUpgradeFailureNotice(configDir = getConfigDir2()) {
       try {
         const noticePath = getUpgradeFailureNoticePath(configDir);
         if (!fs20.existsSync(noticePath)) return null;
         const notice = fs20.readFileSync(noticePath, "utf8").trim();
         if (!notice) return null;
-        return { noticePath, logPath: getUpgradeLogPath(configDir), notice };
+        const recordedAt = parseUpgradeNoticeTimestamp(notice);
+        const ageMs2 = recordedAt ? Date.now() - Date.parse(recordedAt) : null;
+        return {
+          noticePath,
+          logPath: getUpgradeLogPath(configDir),
+          notice,
+          recordedAt,
+          ageMs: ageMs2,
+          ageLabel: ageMs2 === null ? null : formatUpgradeNoticeAge(ageMs2),
+          targetVersion: parseUpgradeNoticeTargetVersion(notice)
+        };
       } catch {
         return null;
       }
@@ -90930,10 +91003,7 @@ ${body}
       if (payload.skipInstall) {
         appendUpgradeLog("Restart-only mode \u2014 package install skipped, re-spawning daemon");
         spawnDetachedDaemonRestart(restartArgv, payload.cwd);
-        try {
-          fs20.unlinkSync(getUpgradeFailureNoticePath());
-        } catch {
-        }
+        clearUpgradeFailureNotice();
         return;
       }
       const instanceDir = resolveInstanceDir();
@@ -90987,13 +91057,10 @@ ${body}
             `adhdev ${payload.packageName}@${payload.targetVersion} upgrade failed and was rolled back: ${error48?.message || String(error48)}`,
             `Previous version preserved (active prefix: ${windowsInstallerLayout.activePrefix}).`,
             "See daemon-upgrade.log for the full install/health trace. The next daemon start will retry."
-          ]);
+          ], getConfigDir2(), { targetVersion: payload.targetVersion });
           throw error48;
         }
-        try {
-          fs20.unlinkSync(getUpgradeFailureNoticePath());
-        } catch {
-        }
+        clearUpgradeFailureNotice();
         appendUpgradeLog("Installer-managed Windows atomic upgrade completed");
         return;
       }
@@ -91041,7 +91108,7 @@ ${body}
               notice.push("To recover, reinstall manually:");
             }
             notice.push(`  ${buildManualRecoveryCommand(installCommand)}`);
-            emitUpgradeFailureNotice(notice);
+            emitUpgradeFailureNotice(notice, getConfigDir2(), { targetVersion: payload.targetVersion });
           }
           throw error48;
         }
@@ -91060,7 +91127,7 @@ ${body}
             "so the running daemon was left on its previous version and was NOT restarted.",
             "To recover, reinstall (this forces the shipped prebuild instead of a source rebuild):",
             `  ${buildManualRecoveryCommand(installCommand)}`
-          ]);
+          ], getConfigDir2(), { targetVersion: payload.targetVersion });
           throw error48;
         }
       }
@@ -91070,10 +91137,7 @@ ${body}
         appendUpgradeLog("Post-install staging cleanup complete");
       }
       spawnDetachedDaemonRestart(restartArgv, payload.cwd);
-      try {
-        fs20.unlinkSync(getUpgradeFailureNoticePath());
-      } catch {
-      }
+      clearUpgradeFailureNotice();
     }
     function spawnDetachedDaemonRestart(restartArgv, cwd) {
       if (restartArgv.length > 0) {
@@ -91435,7 +91499,7 @@ ${body}
             LOG2.info("Upgrade", "Ignoring deprecated channel hint \u2014 upgrade target is the build track");
           }
           const npmTag = IDENTITY.npmTag;
-          const latest = String(execNpmCommandSync(["view", `${pkgName}@${npmTag}`, "version"], { encoding: "utf-8", timeout: 1e4 }, npmSurface)).trim();
+          const latest = resolveNpmPublishedVersion(pkgName, npmTag, npmSurface);
           LOG2.info("Upgrade", `Latest ${pkgName}@${npmTag}: v${latest}`);
           let currentInstalled = null;
           try {
@@ -124469,8 +124533,12 @@ data: ${JSON.stringify(msg.data)}
       loadMeshCoordinatorRegistry();
       const upgradeFailureNotice = readUpgradeFailureNotice();
       if (upgradeFailureNotice) {
-        LOG2.warn("Upgrade", `Previous daemon upgrade FAILED and was rolled back \u2014 this daemon is running the previous version. Notice (${upgradeFailureNotice.noticePath}):
-${upgradeFailureNotice.notice}`);
+        const age = upgradeFailureNotice.ageLabel ? `${upgradeFailureNotice.ageLabel}, recorded ${upgradeFailureNotice.recordedAt}` : "recorded at an unknown time";
+        const target = upgradeFailureNotice.targetVersion ? `, attempted target v${upgradeFailureNotice.targetVersion}` : "";
+        const running = (config2.statusVersion || "").trim().replace(/^v/, "");
+        const supersededHint = upgradeFailureNotice.targetVersion && running && upgradeFailureNotice.targetVersion.replace(/^v/, "") !== running ? ` This notice targets a DIFFERENT version than the one now running (v${running}) \u2014 it is most likely a stale record of an earlier attempt, not a report about this boot.` : "";
+        LOG2.warn("Upgrade", `Previous daemon upgrade FAILED and was rolled back \u2014 this daemon is running the previous version. Notice (${age}${target}) at ${upgradeFailureNotice.noticePath}:
+${upgradeFailureNotice.notice}${supersededHint}`);
       }
       const appConfig = loadConfig2();
       const providerSourceMode = appConfig.providerSourceMode || "normal";