@zixt/host 0.0.157 → 0.0.158

package/dist/index.js

@@ -28,7 +28,7 @@ import { homedir as homedir6 } from "node:os";
 // package.json
 var package_default = {
   name: "@zixt/host",
-  version: "0.0.157",
+  version: "0.0.158",
   type: "module",
   exports: {
     ".": "./src/client.ts",
@@ -20027,6 +20027,11 @@ var CLOSE_CODES = {
   revoked: 4004
 };
 var UNSUPPORTED_PROTOCOL_CLOSE_REASON = "unsupported protocol version";
+function parseUnsupportedProtocolCloseReason(detail) {
+  if (detail === UNSUPPORTED_PROTOCOL_CLOSE_REASON) return { cloudProtocolVersion: null };
+  const match = /^unsupported protocol version; cloud protocol (\d{1,6})$/.exec(detail);
+  return match ? { cloudProtocolVersion: Number(match[1]) } : null;
+}
 var CLOSE_REASON_MAX_BYTES = 123;
 
 // ../../packages/contracts/src/webhook-automations.ts
@@ -26382,7 +26387,7 @@ var HostClient = class _HostClient {
       await this.unwindAllRuns("host connection was replaced by a newer client", "client_shutdown");
       return;
     }
-    const versionMismatch = code === CLOSE_CODES.protocolError && detail === UNSUPPORTED_PROTOCOL_CLOSE_REASON;
+    const versionMismatch = code === CLOSE_CODES.protocolError && detail !== void 0 && parseUnsupportedProtocolCloseReason(detail) !== null;
     if (versionMismatch) {
       this.opts.onStatus?.("incompatible", detail);
       this.stopped = true;
@@ -30499,6 +30504,29 @@ function installedReleaseVersion(entry, root = versionsRoot()) {
   if (!version2 || !VERSION_DIR.test(version2)) return null;
   return resolve8(entry) === resolve8(installedReleaseEntry(version2, root)) ? version2 : null;
 }
+function compareReleaseVersions(left, right) {
+  const parse4 = (version2) => version2.split(/[-+]/, 1)[0].split(".").map((part) => Number(part));
+  const leftParts = parse4(left);
+  const rightParts = parse4(right);
+  for (let index = 0; index < 3; index += 1) {
+    const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+async function newestInstalledReleaseBelow(version2, excluded, root = versionsRoot()) {
+  let names;
+  try {
+    names = await readdir6(root);
+  } catch {
+    return null;
+  }
+  const candidates = names.filter((name) => VERSION_DIR.test(name)).filter((name) => !excluded.has(name) && compareReleaseVersions(name, version2) < 0).sort(compareReleaseVersions).reverse();
+  for (const candidate of candidates) {
+    if (await validInstalledRelease(candidate, root)) return candidate;
+  }
+  return null;
+}
 function currentReleaseEntry(root = versionsRoot(), platform = process.platform) {
   return join12(root, platform === "win32" ? "current-launcher.cjs" : CURRENT_RELEASE_ENTRY);
 }
@@ -31603,6 +31631,7 @@ async function superviseHost(options = {}) {
   });
   const attempted = /* @__PURE__ */ new Set();
   let unsatisfiableUpdates = 0;
+  const cloudRefusedVersions = /* @__PURE__ */ new Set();
   const waitOrShutdown = async (ms) => {
     if (shuttingDown2) return false;
     if (!customDelay) {
@@ -31683,6 +31712,14 @@ async function superviseHost(options = {}) {
       rollbackCandidate = null;
     }
   };
+  const parkRefusedCandidate = async (version2) => {
+    if (!releaseStore || releaseState?.candidateVersion !== version2) return;
+    await releaseStore.clear();
+    if (releaseState?.candidateVersion === version2) {
+      releaseState = null;
+      rollbackCandidate = null;
+    }
+  };
   const markReleaseValidated = async (version2) => {
     if (releaseState?.phase !== "probation" || releaseState.candidateVersion !== version2 || !releaseStore) {
       return;
@@ -31991,21 +32028,66 @@ async function superviseHost(options = {}) {
       const target = await published();
       let updateLanded = false;
       let rejectedUpdate = null;
+      if (runtimeMs >= FAST_UPDATE_EXIT_MS) cloudRefusedVersions.clear();
       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) {
+        cloudRefusedVersions.add(target);
+        await parkRefusedCandidate(target);
         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`
           );
+        }
+        const compatible = await newestInstalledReleaseBelow(target, cloudRefusedVersions);
+        if (compatible) {
+          log2(
+            `Zixt Host: running installed ${compatible} while the cloud catches up with ${target}; this Machine returns to ${target} by itself once the cloud speaks its protocol`
+          );
+          command = {
+            entry: installedReleaseEntry(compatible),
+            version: compatible,
+            // The parked newest release is not for this worker to re-request:
+            // its own update checks skip it while the cloud stays behind.
+            rejectedVersion: target
+          };
+          updateLanded = true;
+        } else if (unsatisfiableUpdates === 0) {
           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"
+            "Zixt Host: no older installed release remains to serve this cloud; 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 (cloudRefusedVersions.has(target)) {
+        if (command.version && runtimeMs < FAST_UPDATE_EXIT_MS) {
+          cloudRefusedVersions.add(command.version);
+          await parkRefusedCandidate(command.version);
+        }
+        const compatible = command.version ? await newestInstalledReleaseBelow(command.version, cloudRefusedVersions) : null;
+        if (compatible) {
+          log2(
+            `Zixt Host: ${target} is still refused by the paired cloud; running installed ${compatible} until the cloud updates`
+          );
+          command = {
+            entry: installedReleaseEntry(compatible),
+            version: compatible,
+            rejectedVersion: target
+          };
+          updateLanded = true;
+        } else {
+          log2(
+            `Zixt Host: the paired cloud refuses every installed release; waiting for the cloud or a newer published release`
           );
         }
       } else if (attempted.has(target)) {
-        log2(`Zixt Host: already running ${target}; ignoring a repeated update request`);
+        if (command.version !== target && await validInstalledRelease(target)) {
+          log2(`Zixt Host: returning to installed ${target} now that the cloud accepts it`);
+          command = { entry: installedReleaseEntry(target), version: target };
+          updateLanded = true;
+        } else {
+          log2(`Zixt Host: already running ${target}; ignoring a repeated update request`);
+        }
       } else {
         let entry;
         const attempt = { failure: null };
@@ -44831,8 +44913,10 @@ var BrowserManager = class {
       }
       throw new Error("browser cookies changed too many times while synchronizing");
     });
-    const tracked = next.finally(() => {
-      if (this.cookieSyncTails.get(profileKey) === tracked) this.cookieSyncTails.delete(profileKey);
+    const tracked = next.catch(() => {
+    }).finally(() => {
+      if (this.cookieSyncTails.get(profileKey) === tracked)
+        this.cookieSyncTails.delete(profileKey);
     });
     this.cookieSyncTails.set(profileKey, tracked);
     return next;
@@ -48702,14 +48786,21 @@ var client = new HostClient({
         });
         queueMicrotask(() => shutdown(DO_NOT_RESTART_EXIT_CODE));
         break;
-      case "incompatible":
-        log.error("Zixt Cloud refused this Host as too old to connect", {
-          ...connectionContext,
-          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"
-        });
+      case "incompatible": {
+        const refusal = detail ? parseUnsupportedProtocolCloseReason(detail) : null;
+        const cloudBehind = refusal?.cloudProtocolVersion != null && refusal.cloudProtocolVersion < PROTOCOL_VERSION;
+        log.error(
+          cloudBehind ? "Zixt Cloud is behind this Host and refused the connection" : "Zixt Cloud refused this Host as too old to connect",
+          {
+            ...connectionContext,
+            protocol: PROTOCOL_VERSION,
+            ...refusal?.cloudProtocolVersion != null ? { cloudProtocol: refusal.cloudProtocolVersion } : {},
+            next: packagedBuild ? cloudBehind ? "Zixt runs the newest installed release this cloud accepts until the cloud updates" : "Zixt checks the published release now; nothing to do on this Machine" : cloudBehind ? "Deploy the paired cloud, or run this checkout at the revision that cloud runs" : "Update this checkout through Git and restart the Host"
+          }
+        );
         queueMicrotask(() => shutdown(packagedBuild ? UPDATE_EXIT_CODE : DO_NOT_RESTART_EXIT_CODE));
         break;
+      }
       case "rejected":
         log.error("Zixt Cloud refused this Machine", {
           ...connectionContext,

package/package.json

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