@zixt/host 0.0.85 → 0.0.87

package/dist/index.js

@@ -7,9 +7,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/index.ts
-import { fstatSync as fstatSync2 } from "node:fs";
-
 // src/supervisor.ts
 import { spawn as spawn5 } from "node:child_process";
 import { fstatSync } from "node:fs";
@@ -31,7 +28,7 @@ import { homedir as homedir3 } from "node:os";
 // package.json
 var package_default = {
   name: "@zixt/host",
-  version: "0.0.85",
+  version: "0.0.87",
   type: "module",
   exports: {
     ".": "./src/client.ts",
@@ -25828,14 +25825,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 +25879,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 +25906,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 +25962,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 +25996,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 +26029,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 +26064,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);
@@ -26407,15 +26463,15 @@ async function launchHostSupervisor(options = {}) {
   const onTerm = () => stop("SIGTERM");
   process.on("SIGINT", onInt);
   process.on("SIGTERM", onTerm);
-  let stdinIsPipe2 = options.parentStdinIsPipe ?? false;
+  let stdinIsPipe = options.parentStdinIsPipe ?? false;
   if (options.parentStdinIsPipe === void 0) {
     try {
       const stat3 = fstatSync(0);
-      stdinIsPipe2 = !stat3.isCharacterDevice() && !stat3.isFile() && !process.stdin.isTTY;
+      stdinIsPipe = !stat3.isCharacterDevice() && !stat3.isFile() && !process.stdin.isTTY;
     } catch {
     }
   }
-  const observesParentStdin = managedLifecycle && stdinIsPipe2;
+  const observesParentStdin = managedLifecycle && stdinIsPipe;
   const onStdinEnd = () => stop("SIGTERM");
   const onStdinError = () => stop("SIGTERM");
   const onStdinData = (chunk) => {
@@ -26601,7 +26657,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 +27082,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,25 +27092,40 @@ 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"
         );
       } else if (target === command.version) {
-        log2(
-          `Zixt Host: this Machine already runs the newest published release (${target}), so an update cannot satisfy the cloud; waiting for a newer one`
-        );
+        if (unsatisfiableUpdates === 0) {
+          log2(
+            `Zixt Host: ${target} is the newest published Zixt Host, so no update can satisfy this cloud; the cloud this Machine is paired to speaks a newer Host protocol than any published release`
+          );
+          log2(
+            "Zixt Host: pair this Machine with a cloud running a published release, or start the Host from the same source checkout that cloud runs; this Machine connects by itself once a matching release is published"
+          );
+        }
       } else if (attempted.has(target)) {
         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 +27213,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;
@@ -27191,6 +27273,38 @@ function beginWorkerShutdown(options) {
   });
 }
 
+// src/parent-pipe.ts
+import { fstatSync as fstatSync2 } from "node:fs";
+var END_OF_TEXT = 3;
+function stdinIsParentPipe(stat3 = (fd) => fstatSync2(fd), isTTY = process.stdin.isTTY === true) {
+  try {
+    const stdin = stat3(0);
+    return !stdin.isCharacterDevice() && !stdin.isFile() && !isTTY;
+  } catch {
+    return false;
+  }
+}
+function watchParentPipe(pipe2, onStop) {
+  const stop = () => onStop();
+  const onData = (chunk) => {
+    if (chunk.includes(END_OF_TEXT)) onStop();
+  };
+  pipe2.on("end", stop);
+  pipe2.on("error", stop);
+  pipe2.on("data", onData);
+  pipe2.resume();
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    pipe2.off("end", stop);
+    pipe2.off("error", stop);
+    pipe2.off("data", onData);
+    pipe2.pause();
+    pipe2.unref?.();
+  };
+}
+
 // src/index.ts
 import { homedir as homedir14, hostname as hostname3 } from "node:os";
 
@@ -40712,6 +40826,8 @@ var connectionContext = connectionLogContext({
 });
 var stopUpdateWatch = () => {
 };
+var releaseParentPipeWatch = () => {
+};
 var updateRestartGate = createIdleUpdateRestartGate({
   activeTasks: () => activeSessions,
   deferred: (version2, activeTasks) => {
@@ -40860,9 +40976,10 @@ var client = new HostClient({
         queueMicrotask(() => shutdown(DO_NOT_RESTART_EXIT_CODE));
         break;
       case "incompatible":
-        log.error("Host update required", {
+        log.error("Zixt Cloud refused this Host as too old to connect", {
           ...connectionContext,
-          next: "Pull the latest Zixt version and restart the Host"
+          protocol: PROTOCOL_VERSION,
+          next: packagedBuild ? "Zixt checks the published release now; nothing to do on this Machine" : "Update this checkout through Git and restart the Host"
         });
         queueMicrotask(() => shutdown(packagedBuild ? UPDATE_EXIT_CODE : DO_NOT_RESTART_EXIT_CODE));
         break;
@@ -40884,7 +41001,7 @@ var diagnosticsRoot = configuredWorkerDiagnosticsRoot();
 var reportedWorkerExits = diagnosticsRoot ? await readWorkerExits(diagnosticsRoot) : [];
 for (const { record: record2 } of reportedWorkerExits) {
   const { summary, context } = describeWorkerExit(record2);
-  log.error(`The previous Zixt Host worker ${summary}`, {
+  replayConsoleLine("error", `The previous Zixt Host worker ${summary}`, {
     machine,
     at: record2.at,
     ...context,
@@ -40899,11 +41016,20 @@ 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,
-    teardown: () => client.stop(),
+    teardown: async () => {
+      await client.stop();
+      releaseParentPipeWatch();
+      stopUpdateWatch();
+    },
     stopHeartbeat: () => workerWatchdog.stop(),
     onForcedExit: ({ deadlineMs, code, teardownCompleted }) => {
       log.warn(
@@ -40912,6 +41038,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 +41048,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) => {
@@ -40928,17 +41066,6 @@ stopUpdateWatch = !packagedBuild ? () => {
 });
 process.on("SIGINT", () => shutdown());
 process.on("SIGTERM", () => shutdown());
-var stdinIsPipe = false;
-try {
-  const stat3 = fstatSync2(0);
-  stdinIsPipe = !stat3.isCharacterDevice() && !stat3.isFile() && !process.stdin.isTTY;
-} catch {
-}
-if (stdinIsPipe) {
-  process.stdin.on("end", () => shutdown());
-  process.stdin.on("error", () => shutdown());
-  process.stdin.on("data", (chunk) => {
-    if (chunk.includes(3)) shutdown();
-  });
-  process.stdin.resume();
+if (stdinIsParentPipe()) {
+  releaseParentPipeWatch = watchParentPipe(process.stdin, () => shutdown());
 }

package/package.json

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