@zixt/host 0.0.85 → 0.0.86

package/dist/index.js

@@ -31,7 +31,7 @@ import { homedir as homedir3 } from "node:os";
 // package.json
 var package_default = {
   name: "@zixt/host",
-  version: "0.0.85",
+  version: "0.0.86",
   type: "module",
   exports: {
     ".": "./src/client.ts",
@@ -25828,14 +25828,26 @@ setTimeout(() => { if (!launched) fail(); }, 130000).unref();
 var InstallerContainmentError = class extends Error {
   name = "InstallerContainmentError";
 };
+function describeInstallerExit(code, signal) {
+  if (signal !== null) return `was killed by ${signal}`;
+  if (code === null) return "ended without reporting an exit code";
+  return `exited with code ${code}`;
+}
 async function installRelease(version2, options = {}) {
-  if (!VERSION_DIR.test(version2)) return null;
+  const fail = (reason, detail) => {
+    options.onFailure?.({ version: version2, reason, detail });
+    return null;
+  };
+  if (!VERSION_DIR.test(version2)) {
+    return fail("unsupported_version", "that is not a release name this Host can install");
+  }
   const platform = options.platform ?? process.platform;
   const root = options.root ?? versionsRoot();
   const prefix = join8(root, version2);
   const entry = installedReleaseEntry(version2, root);
   if (await validReleaseAtPrefix(prefix, version2)) return entry;
-  if (options.signal?.aborted) return null;
+  if (options.signal?.aborted)
+    return fail("cancelled", "this Host was stopping before npm started");
   const installerCommand = options.installerCommand ?? await resolveInstallerCommand({ platform });
   await mkdir5(root, { recursive: true, mode: 448 });
   const staging = join8(root, `.install-${version2}-${process.pid}-${crypto.randomUUID()}`);
@@ -25870,9 +25882,12 @@ async function installRelease(version2, options = {}) {
   let child;
   try {
     child = spawnInstaller(staging, version2);
-  } catch {
+  } catch (error52) {
     await rm5(staging, { recursive: true, force: true }).catch(() => void 0);
-    return null;
+    return fail(
+      "installer_unavailable",
+      `${installerCommand} could not be started (${error52 instanceof Error ? error52.message : "unknown error"})`
+    );
   }
   let resolveChildExited;
   const childExited = new Promise((resolveExit) => {
@@ -25894,6 +25909,8 @@ async function installRelease(version2, options = {}) {
     installerContainmentSetupError = error52;
     return null;
   }) : Promise.resolve(null);
+  const timeoutMs = options.timeoutMs ?? INSTALL_TIMEOUT_MS;
+  const outcome = { code: null, signal: null, timedOut: false, spawnError: null };
   const installed = await new Promise((resolve18, reject3) => {
     let finished = false;
     let cleanupStarted = false;
@@ -25948,13 +25965,21 @@ async function installRelease(version2, options = {}) {
         }
       })();
     };
-    const timer = setTimeout(requestCleanup, options.timeoutMs ?? INSTALL_TIMEOUT_MS);
+    const timer = setTimeout(() => {
+      outcome.timedOut = true;
+      requestCleanup();
+    }, timeoutMs);
     timer.unref?.();
-    child.once("error", () => {
+    child.once("error", (error52) => {
+      outcome.spawnError = error52.message;
       observeExit();
       requestCleanup();
     });
-    child.once("exit", (code) => {
+    child.once("exit", (code, signal) => {
+      if (!usesWindowsInstallerGuardian) {
+        outcome.code = code;
+        outcome.signal = signal;
+      }
       observeExit();
       if (usesWindowsInstallerGuardian) {
         requestCleanup();
@@ -25974,6 +25999,9 @@ async function installRelease(version2, options = {}) {
         }
         const code = message.code;
         if (code !== null && (typeof code !== "number" || !Number.isInteger(code))) return;
+        outcome.code = code;
+        const signal = message.signal;
+        outcome.signal = typeof signal === "string" ? signal : null;
         successfulCleanupResult = code === 0;
         requestCleanup();
       });
@@ -26004,8 +26032,32 @@ async function installRelease(version2, options = {}) {
     if (options.signal?.aborted) requestCleanup();
   });
   try {
-    if (options.signal?.aborted || !installed || !await validReleaseAtPrefix(staging, version2)) {
-      return null;
+    if (options.signal?.aborted) {
+      return fail("cancelled", "this Host was stopping before the install finished");
+    }
+    if (!installed) {
+      if (outcome.timedOut) {
+        return fail(
+          "installer_timed_out",
+          `${installerCommand} was still running after ${Math.round(timeoutMs / 1e3)}s and was stopped`
+        );
+      }
+      if (outcome.spawnError !== null) {
+        return fail(
+          "installer_unavailable",
+          `${installerCommand} failed to run (${outcome.spawnError})`
+        );
+      }
+      return fail(
+        "installer_failed",
+        `${installerCommand} install ${PACKAGE_NAME}@${version2} ${describeInstallerExit(outcome.code, outcome.signal)}`
+      );
+    }
+    if (!await validReleaseAtPrefix(staging, version2)) {
+      return fail(
+        "incomplete_release",
+        `${installerCommand} reported success but left no runnable ${PACKAGE_NAME}@${version2} in ${staging}`
+      );
     }
     if (await validReleaseAtPrefix(prefix, version2)) return entry;
     const existing = await lstat5(prefix).catch((error52) => {
@@ -26015,11 +26067,18 @@ async function installRelease(version2, options = {}) {
     if (existing) await rename3(prefix, quarantine);
     try {
       await rename3(staging, prefix);
-    } catch {
-      return await validReleaseAtPrefix(prefix, version2) ? entry : null;
+    } catch (error52) {
+      if (await validReleaseAtPrefix(prefix, version2)) return entry;
+      return fail(
+        "commit_failed",
+        `the validated tree could not be moved into ${prefix} (${error52 instanceof Error ? error52.message : "unknown error"})`
+      );
     }
     await syncDirectory3(root);
-    return await validReleaseAtPrefix(prefix, version2) ? entry : null;
+    return await validReleaseAtPrefix(prefix, version2) ? entry : fail(
+      "commit_failed",
+      `${prefix} is not a runnable ${PACKAGE_NAME}@${version2} after installing`
+    );
   } finally {
     await rm5(staging, { recursive: true, force: true }).catch(() => void 0);
     await rm5(quarantine, { recursive: true, force: true }).catch(() => void 0);
@@ -26601,7 +26660,10 @@ async function superviseHost(options = {}) {
     platform,
     workerDiagnosticsRoot
   ));
-  const install = options.installVersion ?? ((version2, signal) => installRelease(version2, signal ? { signal } : {}));
+  const install = options.installVersion ?? ((version2, signal, onFailure) => installRelease(version2, {
+    ...signal ? { signal } : {},
+    ...onFailure ? { onFailure } : {}
+  }));
   const cleanupWorker = options.cleanupWorker ?? (options.spawnWorker ? async () => {
   } : null);
   const createWorkerContainment = options.createWorkerContainment ?? (platform === "win32" && !options.spawnWorker ? async (target, identityNonce, signal) => {
@@ -27023,6 +27085,9 @@ async function superviseHost(options = {}) {
         if (!await waitAfterCrash(runtimeMs)) return 0;
         continue;
       }
+      log2(
+        `Zixt Host: worker on ${command.version ?? "the launched copy"} asked to update (exit ${effectiveCode}${watchdogTriggered ? `, announced ${announcedExitCode} before its teardown was contained` : ""}); checking the published release`
+      );
       if (watchdogTriggered) {
         await reportWorkerExit(workerExit, "installing the update it asked for anyway");
       }
@@ -27030,6 +27095,7 @@ async function superviseHost(options = {}) {
       if (orderlyValidatedBoundary) rollbackCandidate = null;
       const target = await published();
       let updateLanded = false;
+      let rejectedUpdate = null;
       if (target === null) {
         log2(
           "Zixt Host: a newer release was reported but the registry is unreachable; staying on the current version"
@@ -27042,13 +27108,22 @@ async function superviseHost(options = {}) {
         log2(`Zixt Host: already running ${target}; ignoring a repeated update request`);
       } else {
         let entry;
+        const attempt = { failure: null };
+        log2(`Zixt Host: installing ${target} over ${command.version ?? "the launched copy"}`);
         try {
-          entry = await install(target, shutdownController.signal);
+          entry = await install(target, shutdownController.signal, (failure2) => {
+            attempt.failure = failure2;
+          });
         } catch (error52) {
           if (error52 instanceof InstallerContainmentError) {
             log2(`Zixt Host: ${error52.message}; handing recovery to the stable launcher`);
             return 1;
           }
+          attempt.failure = {
+            version: target,
+            reason: "commit_failed",
+            detail: error52 instanceof Error ? error52.message : "unknown error"
+          };
           entry = null;
         }
         if (shuttingDown2) return 0;
@@ -27136,9 +27211,14 @@ async function superviseHost(options = {}) {
             }
           }
         } else {
-          log2(`Zixt Host: could not install ${target}; staying on the current version`);
+          const failure2 = attempt.failure;
+          log2(
+            `Zixt Host: could not install ${target} (${failure2 ? `${failure2.reason}: ${failure2.detail}` : "no reason reported"}); staying on ${command.version ?? "the launched copy"}`
+          );
+          if (failure2?.reason !== "cancelled") rejectedUpdate = target;
         }
       }
+      if (rejectedUpdate) command = { ...command, rejectedVersion: rejectedUpdate };
       unsatisfiableUpdates = updateLanded ? 0 : unsatisfiableUpdates + 1;
       if (unsatisfiableUpdates > 0) {
         if (!await waitOrShutdown(streakBackoffMs(unsatisfiableUpdates))) return 0;
@@ -40899,7 +40979,12 @@ function shutdown(exitCode = 0) {
   if (shuttingDown) process.exit(exitCode);
   shuttingDown = true;
   retainRunAssignments();
-  log.info("Stopping Zixt Host", { machine, activeTasks: activeSessions });
+  log.info("Stopping Zixt Host", {
+    machine,
+    activeTasks: activeSessions,
+    exit: exitCode,
+    reason: exitCode === UPDATE_EXIT_CODE ? "installing a Zixt Host update" : exitCode === DO_NOT_RESTART_EXIT_CODE ? "this Machine needs attention before it restarts" : "stop requested"
+  });
   beginWorkerShutdown({
     activeTasks: activeSessions,
     exitCode,
@@ -40912,6 +40997,9 @@ function shutdown(exitCode = 0) {
           machine,
           deadline: formatDuration(deadlineMs),
           exit: code,
+          // A stop that had to unwind live runs exits as a crash instead, so
+          // the honoured code can differ from the verdict this stop was for.
+          ...code === exitCode ? {} : { requested: exitCode },
           activeTasks: activeSessions,
           next: "The Host restarts automatically; report this if it repeats"
         }
@@ -40919,6 +41007,15 @@ function shutdown(exitCode = 0) {
     }
   });
 }
+var skippedRelease = process.env.ZIXT_HOST_REJECT_VERSION;
+if (packagedBuild && skippedRelease) {
+  log.warn("Skipping a Zixt Host release this Machine could not install", {
+    machine,
+    version: skippedRelease,
+    running: HOST_VERSION,
+    next: "This Machine keeps working and takes the next release; report it if it stays behind"
+  });
+}
 stopUpdateWatch = !packagedBuild ? () => {
 } : watchForUpdates({
   onUpdateAvailable: (version2) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zixt/host",
-  "version": "0.0.85",
+  "version": "0.0.86",
   "type": "module",
   "exports": {
     ".": "./src/client.ts",