@openparachute/hub 0.6.2 → 0.6.3-rc.2

package/src/__tests__/upgrade.test.ts

@@ -2,8 +2,13 @@ import { describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import type { LifecycleOpts } from "../commands/lifecycle.ts";
+import { restart as lifecycleRestart } from "../commands/lifecycle.ts";
 import type { UpgradeRunner } from "../commands/upgrade.ts";
 import { compareVersions, defaultRunner, detectChannel, upgrade } from "../commands/upgrade.ts";
+import type { HubUnitDeps, HubUnitManagerOpResult } from "../hub-unit.ts";
+import { defaultHubUnitDeps } from "../hub-unit.ts";
+import type { MigrateOfferResult } from "../migrate-offer.ts";
 import { upsertService } from "../services-manifest.ts";
 
 interface RunCall {
@@ -84,6 +89,16 @@ function seedVault(manifestPath: string, installDir: string, version = "0.4.0"):
   );
 }
 
+/**
+ * Phase 5b: `upgrade hub` always restarts the hub UNIT via the platform manager
+ * (`restartHubUnit`) — the detached restart arm is retired. Hub-upgrade tests
+ * that aren't asserting the restart mechanism itself inject this benign seam so
+ * the manager op succeeds without a real systemd/launchd on the test host.
+ */
+const okHubUnitSupervisor = {
+  restartHubUnit: (): HubUnitManagerOpResult => ({ outcome: "ok" as const, messages: [] }),
+};
+
 describe("parachute upgrade", () => {
   test("errors cleanly when targeting a service that's not installed", async () => {
     const h = makeHarness();
@@ -587,6 +602,7 @@ describe("parachute upgrade", () => {
       let restartedShort: string | undefined;
       const logs: string[] = [];
       const code = await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -599,7 +615,8 @@ describe("parachute upgrade", () => {
         log: (l) => logs.push(l),
       });
       expect(code).toBe(0);
-      expect(restartedShort).toBe("hub");
+      // Phase 5b: the hub restarts via the platform manager (okHubUnitSupervisor),
+      // not the detached restartFn — the unit-restart path has its own test.
       const addCall = seenCmd.find((c) => c[0] === "bun" && c[1] === "add");
       expect(addCall).toEqual(["bun", "add", "-g", "@openparachute/hub@latest"]);
       const joined = logs.join("\n");
@@ -636,6 +653,7 @@ describe("parachute upgrade", () => {
 
       let restartedShort: string | undefined;
       const code = await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath, // file doesn't exist
         configDir: h.configDir,
         runner,
@@ -648,7 +666,8 @@ describe("parachute upgrade", () => {
         log: () => {},
       });
       expect(code).toBe(0);
-      expect(restartedShort).toBe("hub");
+      // Phase 5b: the hub restarts via the platform manager (okHubUnitSupervisor),
+      // not the detached restartFn — the unit-restart path has its own test.
     } finally {
       h.cleanup();
     }
@@ -683,6 +702,7 @@ describe("parachute upgrade", () => {
       let restartedShort: string | undefined;
       const logs: string[] = [];
       const code = await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -695,7 +715,8 @@ describe("parachute upgrade", () => {
         log: (l) => logs.push(l),
       });
       expect(code).toBe(0);
-      expect(restartedShort).toBe("hub");
+      // Phase 5b: the hub restarts via the platform manager (okHubUnitSupervisor),
+      // not the detached restartFn — the unit-restart path has its own test.
       expect(logs.join("\n")).toMatch(/hub: bun-linked checkout/);
     } finally {
       h.cleanup();
@@ -723,6 +744,7 @@ describe("parachute upgrade", () => {
       };
 
       await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -771,6 +793,15 @@ describe("parachute upgrade", () => {
 
       const restartCalls: string[] = [];
       const code = await upgrade(undefined, {
+        // Phase 5b: the hub restarts via the platform manager (restartHubUnit),
+        // modules via restartFn. Record both into one order list so the hub-first
+        // invariant is still asserted.
+        supervisor: {
+          restartHubUnit: (): HubUnitManagerOpResult => {
+            restartCalls.push("hub");
+            return { outcome: "ok", messages: [] };
+          },
+        },
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -786,7 +817,8 @@ describe("parachute upgrade", () => {
         log: () => {},
       });
       expect(code).toBe(0);
-      // Hub goes first so its dispatcher upgrade isn't preempted.
+      // Hub goes first (manager restart) so its dispatcher upgrade isn't
+      // preempted, then the module restarts route through lifecycle.
       expect(restartCalls).toEqual(["hub", "vault"]);
     } finally {
       h.cleanup();
@@ -841,6 +873,7 @@ describe("parachute upgrade", () => {
       const restartCalls: string[] = [];
       const logs: string[] = [];
       const code = await upgrade(undefined, {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -920,6 +953,7 @@ describe("parachute upgrade", () => {
       };
 
       const code = await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -961,6 +995,7 @@ describe("parachute upgrade", () => {
       };
 
       await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -1003,6 +1038,7 @@ describe("parachute upgrade", () => {
       };
 
       await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -1045,6 +1081,7 @@ describe("parachute upgrade", () => {
       const logs: string[] = [];
       let restartCalled = false;
       const code = await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -1096,6 +1133,7 @@ describe("parachute upgrade", () => {
       };
 
       const code = await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -1153,6 +1191,7 @@ describe("parachute upgrade", () => {
       const logs: string[] = [];
       let restartedShort: string | undefined;
       const code = await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -1168,7 +1207,8 @@ describe("parachute upgrade", () => {
         log: (l) => logs.push(l),
       });
       expect(code).toBe(0);
-      expect(restartedShort).toBe("hub");
+      // Phase 5b: the hub restarts via the platform manager (okHubUnitSupervisor),
+      // not the detached restartFn — the unit-restart path has its own test.
       const addCall = seenCmd.find((c) => c[0] === "bun" && c[1] === "add");
       expect(addCall).toEqual(["bun", "add", "-g", "@openparachute/hub@rc"]);
       const joined = logs.join("\n");
@@ -1200,6 +1240,7 @@ describe("parachute upgrade", () => {
       };
 
       await upgrade("hub", {
+        supervisor: okHubUnitSupervisor,
         manifestPath: h.manifestPath,
         configDir: h.configDir,
         runner,
@@ -1218,3 +1259,308 @@ describe("parachute upgrade", () => {
     }
   });
 });
+
+// ---------------------------------------------------------------------------
+// Phase 4 dual-dispatch (design §5): when a hub UNIT is installed, `upgrade hub`
+// rewrites the binary as usual then RESTARTS THE UNIT via the platform manager
+// (`restartHubUnit`), NOT the detached `restartFn` (stopHub/ensureHubRunning).
+// The manager tears down the old hub (children die) and starts the new binary,
+// which re-boots every module. No-unit → the unchanged detached restart.
+// ---------------------------------------------------------------------------
+
+describe("Phase 4 upgrade-hub dual-dispatch", () => {
+  test("upgrade hub unit-managed → binary rewrite + restartHubUnit (manager), NOT detached restartFn", async () => {
+    const h = makeHarness();
+    try {
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.6.3-rc.1" });
+      const seenCmd: string[][] = [];
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          seenCmd.push([...cmd]);
+          if (cmd[0] === "bun" && cmd[1] === "add" && cmd[2] === "-g") {
+            // Channel auto-detected as @rc from the installed -rc version.
+            writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.6.3-rc.2" });
+          }
+          return 0;
+        },
+        async capture(cmd) {
+          // Not a git checkout → npm-install branch.
+          if (cmd[1] === "rev-parse" && cmd[2] === "--is-inside-work-tree") {
+            return { code: 128, stdout: "fatal: not a git repository\n" };
+          }
+          return { code: 0, stdout: "" };
+        },
+      };
+
+      let restartFnCalled = false;
+      let restartHubUnitCalls = 0;
+      const logs: string[] = [];
+      const code = await upgrade("hub", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) =>
+          pkg === "@openparachute/hub" ? join(hubInstallDir, "package.json") : null,
+        // The detached restart path must NOT be taken on the unit arm.
+        restartFn: async () => {
+          restartFnCalled = true;
+          return 0;
+        },
+        // Avoid a real registry round-trip in the downgrade guard.
+        resolveChannelVersion: async () => null,
+        supervisor: {
+          restartHubUnit: (_deps: HubUnitDeps): HubUnitManagerOpResult => {
+            restartHubUnitCalls++;
+            return { outcome: "ok", messages: [] };
+          },
+        },
+        log: (l) => logs.push(l),
+      });
+      expect(code).toBe(0);
+      // The binary was rewritten via bun add -g @rc…
+      const addCall = seenCmd.find((c) => c[0] === "bun" && c[1] === "add");
+      expect(addCall).toEqual(["bun", "add", "-g", "@openparachute/hub@rc"]);
+      // …and the restart went through the platform manager, not the detached PID path.
+      expect(restartHubUnitCalls).toBe(1);
+      expect(restartFnCalled).toBe(false);
+      expect(logs.join("\n")).toMatch(/restarted the hub unit/);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("upgrade hub NO unit → restartHubUnit reports no-unit, surfaced as a failure", async () => {
+    // Phase 5b: the detached restart arm is retired. `upgrade hub` always
+    // restarts the hub UNIT via the platform manager; on a box with no unit the
+    // manager op returns `no-unit` (after the binary rewrite), which the verb
+    // surfaces as a non-zero exit with the manager's message — never a detached
+    // spawn.
+    const h = makeHarness();
+    try {
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.8" });
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          if (cmd[0] === "bun" && cmd[1] === "add" && cmd[2] === "-g") {
+            writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.9" });
+          }
+          return 0;
+        },
+        async capture(cmd) {
+          if (cmd[1] === "rev-parse" && cmd[2] === "--is-inside-work-tree") {
+            return { code: 128, stdout: "" };
+          }
+          return { code: 0, stdout: "" };
+        },
+      };
+
+      const logs: string[] = [];
+      const code = await upgrade("hub", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) =>
+          pkg === "@openparachute/hub" ? join(hubInstallDir, "package.json") : null,
+        resolveChannelVersion: async () => null,
+        supervisor: {
+          restartHubUnit: (_deps: HubUnitDeps): HubUnitManagerOpResult => ({
+            outcome: "no-unit",
+            messages: ["no hub unit installed — run `parachute migrate` to install it"],
+          }),
+        },
+        log: (l) => logs.push(l),
+      });
+      expect(code).toBe(1);
+      expect(logs.join("\n")).toMatch(/no hub unit installed/);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("sweep stays hub-first; hub restart uses the manager, module restarts route through lifecycle", async () => {
+    const h = makeHarness();
+    try {
+      // Hub install dir + a vault module in services.json — sweep upgrades both.
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.6.3-rc.1" });
+      const vaultInstallDir = join(h.installRoot, "vault");
+      writePackageJson(vaultInstallDir, { name: "@openparachute/vault", version: "0.6.3-rc.1" });
+      seedVault(h.manifestPath, vaultInstallDir, "0.6.3-rc.1");
+
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          if (cmd[0] === "bun" && cmd[1] === "add" && cmd[2] === "-g") {
+            const spec = cmd[3] ?? "";
+            if (spec.startsWith("@openparachute/hub")) {
+              writePackageJson(hubInstallDir, {
+                name: "@openparachute/hub",
+                version: "0.6.3-rc.2",
+              });
+            } else if (spec.startsWith("@openparachute/vault")) {
+              writePackageJson(vaultInstallDir, {
+                name: "@openparachute/vault",
+                version: "0.6.3-rc.2",
+              });
+            }
+          }
+          return 0;
+        },
+        async capture(cmd) {
+          if (cmd[1] === "rev-parse" && cmd[2] === "--is-inside-work-tree") {
+            return { code: 128, stdout: "" };
+          }
+          return { code: 0, stdout: "" };
+        },
+      };
+
+      const restartOrder: string[] = [];
+      let restartHubUnitCalls = 0;
+      const code = await upgrade(undefined, {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) => {
+          if (pkg === "@openparachute/hub") return join(hubInstallDir, "package.json");
+          if (pkg === "@openparachute/vault") return join(vaultInstallDir, "package.json");
+          return null;
+        },
+        // Module restarts (vault) go through lifecycle's restart with a
+        // supervisor block; the stub records the order so we can assert hub-first.
+        restartFn: async (svc) => {
+          restartOrder.push(svc);
+          return 0;
+        },
+        resolveChannelVersion: async () => null,
+        supervisor: {
+          restartHubUnit: (_deps: HubUnitDeps): HubUnitManagerOpResult => {
+            restartHubUnitCalls++;
+            restartOrder.push("hub-unit");
+            return { outcome: "ok", messages: [] };
+          },
+        },
+        log: () => {},
+      });
+      expect(code).toBe(0);
+      // Hub-first: the hub unit restart precedes the vault module restart.
+      expect(restartOrder[0]).toBe("hub-unit");
+      expect(restartOrder).toContain("vault");
+      expect(restartOrder.indexOf("hub-unit")).toBeLessThan(restartOrder.indexOf("vault"));
+      expect(restartHubUnitCalls).toBe(1);
+    } finally {
+      h.cleanup();
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Phase 5b nit: the module-target restart leg of `upgrade` must thread the SAME
+// opts a bare `parachute restart <svc>` does — `supervisor: {}` (real
+// `isHubUnitInstalled` probe, NOT a forced `unitInstalled: true`) +
+// `migrateOffer: { enabled: true }`. On a NO-UNIT box that means the module
+// restart surfaces the actionable "run `parachute migrate --to-supervised`"
+// error / fires the auto-offer, NOT a bare connection-refused from
+// `driveModuleOp`. The other upgrade tests stub `restartFn: async () => 0`, so
+// the supervised arm was never exercised here — this closes that gap by driving
+// the REAL `lifecycle.restart`.
+// ---------------------------------------------------------------------------
+
+describe("Phase 5b: upgrade module-restart on a no-unit box", () => {
+  test("module restart threads supervisor:{} + migrateOffer (no forced unitInstalled), surfaces actionable migrate error — NOT a bare connection-refused", async () => {
+    const h = makeHarness();
+    try {
+      const installDir = join(h.installRoot, "vault");
+      writePackageJson(installDir, { name: "@openparachute/vault", version: "0.4.0" });
+      seedVault(h.manifestPath, installDir, "0.4.0");
+
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          // `bun add -g` rewrites the package.json with a new version → the
+          // module restart leg (`restartTarget`) is reached.
+          if (cmd[0] === "bun" && cmd[1] === "add" && cmd[2] === "-g") {
+            writePackageJson(installDir, { name: "@openparachute/vault", version: "0.5.0" });
+          }
+          return 0;
+        },
+        async capture(cmd) {
+          // Not a git checkout → npm-install branch.
+          if (cmd[1] === "rev-parse" && cmd[2] === "--is-inside-work-tree") {
+            return { code: 128, stdout: "fatal: not a git repository\n" };
+          }
+          return { code: 0, stdout: "" };
+        },
+      };
+
+      // A NO-UNIT box: force `isHubUnitInstalled` → false deterministically
+      // (regardless of the test host) by stubbing the unit-file existence probe.
+      const noUnitDeps: HubUnitDeps = { ...defaultHubUnitDeps, exists: () => false };
+
+      // The supervised arm's loopback module-ops call MUST NOT run on a no-unit
+      // box. If the regressed code forced `unitInstalled: true`, the verb would
+      // skip the probe and hit this — surfacing a bare connection-refused.
+      let driveModuleOpCalled = false;
+      const refuse = async (): Promise<never> => {
+        driveModuleOpCalled = true;
+        throw new Error("connect ECONNREFUSED 127.0.0.1:1939");
+      };
+
+      // Capture the opts `restartTarget` hands `lifecycle.restart`, then delegate
+      // to the REAL `lifecycle.restart` so the no-unit handling actually runs.
+      // The offer is overridden to a deterministic `declined` so the outcome
+      // doesn't depend on the host's stdin-TTY / prior-detached state.
+      let seenOpts: LifecycleOpts | undefined;
+      let offerCalls = 0;
+      const restartFn = async (svc: string, opts: LifecycleOpts): Promise<number> => {
+        seenOpts = opts;
+        return await lifecycleRestart(svc, {
+          ...opts,
+          supervisor: {
+            ...opts.supervisor,
+            hubUnitDeps: noUnitDeps,
+            driveModuleOp: refuse,
+          },
+          migrateOffer: {
+            enabled: opts.migrateOffer?.enabled ?? false,
+            offer: async (): Promise<MigrateOfferResult> => {
+              offerCalls++;
+              return { outcome: "declined" };
+            },
+          },
+        });
+      };
+
+      const logs: string[] = [];
+      const code = await upgrade("vault", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: () => join(installDir, "package.json"),
+        restartFn,
+        // Upgrade-side supervisor seam: feeds `r.hubUnitDeps`, which
+        // `restartTarget` threads into `lifecycle.restart`'s supervisor block.
+        supervisor: { hubUnitDeps: noUnitDeps },
+        log: (l) => logs.push(l),
+      });
+
+      // The package rewrite + restart attempt happened (non-zero because the box
+      // is un-migrated and the offer was declined — a clean, actionable failure).
+      expect(code).toBe(1);
+
+      // The contract fix: `restartTarget` passes `supervisor` WITHOUT forcing
+      // `unitInstalled: true`, plus an ENABLED migrate offer — exactly what a
+      // bare `parachute restart <svc>` threads.
+      expect(seenOpts).toBeDefined();
+      expect(seenOpts?.supervisor).toBeDefined();
+      expect(seenOpts?.supervisor?.unitInstalled).toBeUndefined();
+      expect(seenOpts?.migrateOffer?.enabled).toBe(true);
+
+      // The no-unit handling ran: the auto-offer fired (real probe → no unit),
+      // and the supervised loopback call was NEVER reached (no connection-refused).
+      expect(offerCalls).toBe(1);
+      expect(driveModuleOpCalled).toBe(false);
+      expect(logs.join("\n")).not.toMatch(/ECONNREFUSED|connection refused/i);
+    } finally {
+      h.cleanup();
+    }
+  });
+});