@openparachute/hub 0.6.3 → 0.6.4-rc.10

package/src/__tests__/install.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { install } from "../commands/install.ts";
+import { defaultStartLifecycleOpts, install } from "../commands/install.ts";
 import { findService, upsertService } from "../services-manifest.ts";
 
 function makeTempPath(): { path: string; configDir: string; cleanup: () => void } {
@@ -40,6 +40,9 @@ describe("install", () => {
       const calls: string[][] = [];
       const logs: string[] = [];
       const code = await install("vault", {
+        // --interactive: opt back into vault's full `init` (#579). The light
+        // default skips it; this test exercises the interactive path.
+        interactive: true,
         runner: async (cmd) => {
           calls.push([...cmd]);
           return 0;
@@ -67,6 +70,8 @@ describe("install", () => {
     try {
       const logs: string[] = [];
       const code = await install("vault", {
+        // --interactive: this test asserts init wrote the authoritative entry.
+        interactive: true,
         runner: async (cmd) => {
           if (cmd[0] === "parachute-vault") {
             upsertService(
@@ -133,6 +138,8 @@ describe("install", () => {
       const calls: string[][] = [];
       const logs: string[] = [];
       const code = await install("vault", {
+        // --interactive: this test asserts init still ran after the bun quirk.
+        interactive: true,
         runner: async (cmd) => {
           calls.push([...cmd]);
           // `bun add -g` exits 1; `parachute-vault init` succeeds.
@@ -334,6 +341,96 @@ describe("install", () => {
     }
   });
 
+  test("names the squatter holding the canonical port when the walk assigns a fallback (#590)", async () => {
+    // Field bug #590 item 2: a stale pre-supervisor vault zombie squats 1940;
+    // the install-time port walk silently routed to a fallback. Now it names the
+    // holder (pid + command line) + hints it may be a stale daemon. Detection
+    // only — never kills. Reuses the #581 pidOnPort / ownerOfPid seams.
+    const { path, configDir, cleanup } = makeTempPath();
+    try {
+      const logs: string[] = [];
+      const code = await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        configDir,
+        startService: async () => 0,
+        isLinked: () => false,
+        // Only vault's canonical 1940 is held → the walk picks a fallback in-range.
+        portProbe: async (p) => p === 1940,
+        // Inject the #581 seams: a foreign pid squats 1940.
+        pidOnPort: (p) => (p === 1940 ? 1234 : undefined),
+        ownerOfPid: (pid) => (pid === 1234 ? "bun /opt/vault/src/server.ts" : undefined),
+        log: (l) => logs.push(l),
+      });
+      expect(code).toBe(0);
+      const joined = logs.join("\n");
+      // The fallback warning still fires…
+      expect(joined).toMatch(/canonical port 1940 is in use; assigned/);
+      // …and now it NAMES the squatter + hints at a stale daemon.
+      expect(joined).toContain("pid 1234 (bun /opt/vault/src/server.ts)");
+      expect(joined).toMatch(/stale pre-supervisor daemon/);
+      expect(joined).toContain("kill 1234");
+      const entry = findService("parachute-vault", path);
+      expect(entry?.port).not.toBe(1940);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("squatter pid present but command line unreadable → names the pid alone (#590)", async () => {
+    const { path, configDir, cleanup } = makeTempPath();
+    try {
+      const logs: string[] = [];
+      const code = await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        configDir,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async (p) => p === 1940,
+        pidOnPort: (p) => (p === 1940 ? 4321 : undefined),
+        ownerOfPid: () => undefined, // ps failed / pid gone
+        log: (l) => logs.push(l),
+      });
+      expect(code).toBe(0);
+      const joined = logs.join("\n");
+      expect(joined).toContain("held by pid 4321.");
+      expect(joined).not.toContain("(undefined)");
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("no squatter naming when the canonical port is free (#590 — no false positive)", async () => {
+    const { path, configDir, cleanup } = makeTempPath();
+    try {
+      const logs: string[] = [];
+      let pidProbed = false;
+      const code = await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        configDir,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false, // canonical 1940 is free
+        pidOnPort: () => {
+          pidProbed = true;
+          return 9999;
+        },
+        ownerOfPid: () => "should-not-appear",
+        log: (l) => logs.push(l),
+      });
+      expect(code).toBe(0);
+      const joined = logs.join("\n");
+      // Canonical assigned → no fallback warning, no squatter probe at all.
+      expect(joined).not.toMatch(/is in use; assigned/);
+      expect(joined).not.toContain("should-not-appear");
+      expect(pidProbed).toBe(false);
+    } finally {
+      cleanup();
+    }
+  });
+
   test("`install lens` aliases to notes with a rename notice", async () => {
     // Transition alias for the brief Notes→Lens rename (Apr 19) that was
     // reverted on launch eve (Apr 22). Accepted for one release cycle so
@@ -796,12 +893,14 @@ describe("install", () => {
     }
   });
 
-  test("linked vault still runs init and defers to init's manifest write", async () => {
+  test("linked vault still runs init and defers to init's manifest write (--interactive)", async () => {
     const { path, cleanup } = makeTempPath();
     try {
       const calls: string[][] = [];
       const logs: string[] = [];
       const code = await install("vault", {
+        // --interactive: this test asserts vault's own init wrote the entry.
+        interactive: true,
         runner: async (cmd) => {
           calls.push([...cmd]);
           if (cmd[0] === "parachute-vault") {
@@ -1721,3 +1820,350 @@ describe("install", () => {
     }
   });
 });
+
+describe("#579 / #580 item 1 — light manual install + guidance", () => {
+  test("default vault install skips the interactive init (no parachute-vault init runs)", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const logs: string[] = [];
+      const code = await install("vault", {
+        // No `interactive` flag → the light default path.
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+      });
+      expect(code).toBe(0);
+      // bun add ran; vault's interactive init did NOT.
+      expect(calls).toEqual([["bun", "add", "-g", "@openparachute/vault"]]);
+      expect(calls).not.toContainEqual(["parachute-vault", "init"]);
+      // The skip is announced + points at the admin UI / --interactive.
+      expect(logs.join("\n")).toMatch(/skipping parachute-vault init/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("default vault install still starts the module under the supervisor", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const startCalls: string[] = [];
+      const code = await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        startService: async (short) => {
+          startCalls.push(short);
+          return 0;
+        },
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: () => {},
+      });
+      expect(code).toBe(0);
+      // Light ≠ no-start: the supervisor owns the lifecycle; vault is started.
+      expect(startCalls).toEqual(["vault"]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("guidance block prints the admin URL + extras on a supervised box (loopback)", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const logs: string[] = [];
+      const code = await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+        // Deterministic supervised-box context: hub unit installed, not exposed.
+        guidanceCtx: { hubUnitInstalled: true, exposeState: undefined, hubPort: 1939 },
+      });
+      expect(code).toBe(0);
+      const joined = logs.join("\n");
+      expect(joined).toMatch(/Manage \+ create vaults in the admin UI/);
+      expect(joined).toMatch(/http:\/\/127\.0\.0\.1:1939\/admin\//);
+      expect(joined).toMatch(/parachute-vault mcp-install/);
+      expect(joined).toMatch(/--interactive/);
+      // It does NOT mint a token or wire MCP — just points there.
+      expect(joined).toMatch(/Mint an API token.*admin UI/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("guidance uses the exposed public FQDN when the hub is exposed", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const logs: string[] = [];
+      await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+        guidanceCtx: {
+          hubUnitInstalled: true,
+          exposeState: {
+            version: 1,
+            layer: "public",
+            mode: "path",
+            canonicalFqdn: "friends.parachute.computer",
+            port: 1939,
+            funnel: false,
+            entries: [],
+          },
+          hubPort: 1939,
+        },
+      });
+      const joined = logs.join("\n");
+      expect(joined).toMatch(/https:\/\/friends\.parachute\.computer\/admin\//);
+      expect(joined).not.toMatch(/127\.0\.0\.1/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("no guidance block on a non-supervised box (no hub unit)", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const logs: string[] = [];
+      await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+        guidanceCtx: { hubUnitInstalled: false, exposeState: undefined, hubPort: 1939 },
+      });
+      const joined = logs.join("\n");
+      expect(joined).not.toMatch(/Manage \+ create vaults in the admin UI/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("--interactive runs vault init and suppresses the guidance block", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const logs: string[] = [];
+      const code = await install("vault", {
+        interactive: true,
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+        // Even on a supervised box, --interactive means the service's own
+        // init owns the next-steps surface — no light guidance block.
+        guidanceCtx: { hubUnitInstalled: true, exposeState: undefined, hubPort: 1939 },
+      });
+      expect(code).toBe(0);
+      expect(calls).toContainEqual(["parachute-vault", "init"]);
+      expect(logs.join("\n")).not.toMatch(/Manage \+ create vaults in the admin UI/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("scribe (no interactive init) is unaffected — no skip log, no vault guidance", async () => {
+    const { path, cleanup } = makeTempPath();
+    const configDir = join(path, "..");
+    try {
+      const logs: string[] = [];
+      const code = await install("scribe", {
+        runner: async () => 0,
+        manifestPath: path,
+        configDir,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        scribeAvailability: { kind: "not-tty" },
+        log: (l) => logs.push(l),
+        guidanceCtx: { hubUnitInstalled: true, exposeState: undefined, hubPort: 1939 },
+      });
+      expect(code).toBe(0);
+      const joined = logs.join("\n");
+      expect(joined).not.toMatch(/skipping/);
+      expect(joined).not.toMatch(/Manage \+ create vaults in the admin UI/);
+    } finally {
+      cleanup();
+    }
+  });
+});
+
+describe("#580 item 3 — install-time stale-unit sweep", () => {
+  test("sweeps stale per-module units before starting on a supervised box", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const logs: string[] = [];
+      let sweepCalls = 0;
+      const code = await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+        guidanceCtx: { hubUnitInstalled: true, exposeState: undefined, hubPort: 1939 },
+        disableStaleModuleUnits: () => {
+          sweepCalls += 1;
+          return {
+            actions: [
+              {
+                short: "vault",
+                kind: "launchd",
+                unit: "computer.parachute.vault",
+                result: "disabled",
+                messages: ["  ✓ Disabled stale computer.parachute.vault"],
+              },
+            ],
+          };
+        },
+      });
+      expect(code).toBe(0);
+      expect(sweepCalls).toBe(1);
+      expect(logs.join("\n")).toMatch(
+        /Swept 1 stale per-module autostart unit\(s\).*computer\.parachute\.vault/,
+      );
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("does NOT sweep on a non-supervised box (no hub unit)", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      let sweepCalls = 0;
+      await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: () => {},
+        guidanceCtx: { hubUnitInstalled: false, exposeState: undefined, hubPort: 1939 },
+        disableStaleModuleUnits: () => {
+          sweepCalls += 1;
+          return { actions: [] };
+        },
+      });
+      // No supervised hub → the per-module unit is the legitimate lifecycle;
+      // the sweep must not run.
+      expect(sweepCalls).toBe(0);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("does NOT sweep under --no-start (caller owns the process model)", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      let sweepCalls = 0;
+      await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        noStart: true,
+        log: () => {},
+        guidanceCtx: { hubUnitInstalled: true, exposeState: undefined, hubPort: 1939 },
+        disableStaleModuleUnits: () => {
+          sweepCalls += 1;
+          return { actions: [] };
+        },
+      });
+      expect(sweepCalls).toBe(0);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("does NOT sweep under --no-create (wizard defers the start; N2)", async () => {
+    // Parallel to the --no-start guard above. `noCreate` (the wizard's
+    // install path) also suppresses the start — and the sweep touches real
+    // launchctl/systemctl on a live box, so it must NOT fire when we're not
+    // about to start the module. A silent regression here would have the
+    // wizard disabling operator units mid-init.
+    const { path, cleanup } = makeTempPath();
+    try {
+      let sweepCalls = 0;
+      await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        noCreate: true,
+        log: () => {},
+        guidanceCtx: { hubUnitInstalled: true, exposeState: undefined, hubPort: 1939 },
+        disableStaleModuleUnits: () => {
+          sweepCalls += 1;
+          return { actions: [] };
+        },
+      });
+      expect(sweepCalls).toBe(0);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("a clean no-op sweep (nothing stale) logs nothing extra", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const logs: string[] = [];
+      await install("vault", {
+        runner: async () => 0,
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+        guidanceCtx: { hubUnitInstalled: true, exposeState: undefined, hubPort: 1939 },
+        disableStaleModuleUnits: () => ({ actions: [] }),
+      });
+      expect(logs.join("\n")).not.toMatch(/Swept .* stale per-module/);
+    } finally {
+      cleanup();
+    }
+  });
+});
+
+describe("hub#573 — install auto-start converges on supervised detection", () => {
+  test("the default start opts opt into real supervisor detection + the migrate offer", () => {
+    const log = () => {};
+    const opts = defaultStartLifecycleOpts({
+      manifestPath: "/tmp/services.json",
+      configDir: "/tmp/cfg",
+      log,
+    });
+    // `supervisor: {}` (present, even if empty) → lifecycle resolves
+    // `unitInstalled` via the real `isHubUnitInstalled` probe instead of the
+    // omitted-supervisor default of `false`. Pre-fix this block was absent, so
+    // the auto-start ALWAYS concluded "no unit" and printed the spurious
+    // "No supervised hub unit is installed" + "didn't start cleanly".
+    expect(opts.supervisor).toEqual({});
+    // The cutover offer is armed, matching `parachute start <svc>` (cli.ts).
+    expect(opts.migrateOffer).toEqual({ enabled: true });
+    // Plumbing preserved.
+    expect(opts.manifestPath).toBe("/tmp/services.json");
+    expect(opts.configDir).toBe("/tmp/cfg");
+    expect(opts.log).toBe(log);
+  });
+});