@openparachute/hub 0.6.2 → 0.6.3-rc.2

package/src/__tests__/hub-control.test.ts

@@ -2,21 +2,11 @@ import { describe, expect, test } from "bun:test";
 import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import {
-  type HubPortProbe,
-  type HubSpawner,
-  clearHubPort,
-  ensureHubRunning,
-  hubPortPath,
-  readHubPort,
-  stopHub,
-  writeHubPort,
-} from "../hub-control.ts";
+import { clearHubPort, hubPortPath, readHubPort, stopHub, writeHubPort } from "../hub-control.ts";
 import { pidPath, readPid, writePid } from "../process-state.ts";
 
 interface Harness {
   configDir: string;
-  wellKnownDir: string;
   cleanup: () => void;
 }
 
@@ -24,32 +14,10 @@ function makeHarness(): Harness {
   const dir = mkdtempSync(join(tmpdir(), "pcli-hub-ctl-"));
   return {
     configDir: dir,
-    wellKnownDir: join(dir, "well-known"),
     cleanup: () => rmSync(dir, { recursive: true, force: true }),
   };
 }
 
-interface SpawnerStub {
-  spawn: HubSpawner["spawn"];
-  calls: Array<{ cmd: readonly string[]; logFile: string }>;
-}
-
-function makeSpawner(pid: number): SpawnerStub {
-  const calls: Array<{ cmd: readonly string[]; logFile: string }> = [];
-  return {
-    calls,
-    spawn(cmd, logFile) {
-      calls.push({ cmd: [...cmd], logFile });
-      return pid;
-    },
-  };
-}
-
-/** Probe that claims every port in a set is taken. */
-function probeTaken(taken: Set<number>): HubPortProbe {
-  return async (p) => !taken.has(p);
-}
-
 describe("port persistence helpers", () => {
   test("writeHubPort + readHubPort round-trip", () => {
     const h = makeHarness();
@@ -65,215 +33,6 @@ describe("port persistence helpers", () => {
   });
 });
 
-describe("ensureHubRunning", () => {
-  test("spawns with --port + --well-known-dir, writes pid + port files", async () => {
-    const h = makeHarness();
-    try {
-      const spawner = makeSpawner(5555);
-      const result = await ensureHubRunning({
-        configDir: h.configDir,
-        wellKnownDir: h.wellKnownDir,
-        spawner,
-        alive: () => true,
-        probe: probeTaken(new Set()),
-        readyWaitMs: 0,
-      });
-      expect(result.started).toBe(true);
-      expect(result.pid).toBe(5555);
-      expect(result.port).toBe(1939);
-      expect(spawner.calls).toHaveLength(1);
-      const cmd = spawner.calls[0]?.cmd ?? [];
-      expect(cmd[0]).toBe("bun");
-      expect(cmd).toContain("--port");
-      expect(cmd).toContain("1939");
-      expect(cmd).toContain("--well-known-dir");
-      expect(cmd).toContain(h.wellKnownDir);
-      expect(readPid("hub", h.configDir)).toBe(5555);
-      expect(readHubPort(h.configDir)).toBe(1939);
-    } finally {
-      h.cleanup();
-    }
-  });
-
-  test("default fallback is 1 slot: fails when 1939 is taken (no pid resolvable)", async () => {
-    // Canonical layout pins hub to 1939. Walking up would collide with the
-    // next service's slot, so the default is to fail and let the user unblock
-    // the port — not quietly land somewhere else. When `lsof` can't name a
-    // PID (Windows, lsof missing, permission), fall back to the classic
-    // lsof-iTCP hint.
-    const h = makeHarness();
-    try {
-      const spawner = makeSpawner(7777);
-      await expect(
-        ensureHubRunning({
-          configDir: h.configDir,
-          wellKnownDir: h.wellKnownDir,
-          spawner,
-          alive: () => true,
-          probe: probeTaken(new Set([1939])),
-          pidOnPort: () => undefined,
-          readyWaitMs: 0,
-        }),
-      ).rejects.toThrow(/lsof -iTCP:1939/);
-    } finally {
-      h.cleanup();
-    }
-  });
-
-  test("fails with orphan-PID hint when lsof names the holder (hub#287)", async () => {
-    // When `lsof` can resolve the orphan PID holding the canonical port,
-    // we surface it + recommend `parachute restart hub` (which now detects
-    // and kills the orphan) rather than the bare lsof hint.
-    const h = makeHarness();
-    try {
-      const spawner = makeSpawner(7777);
-      await expect(
-        ensureHubRunning({
-          configDir: h.configDir,
-          wellKnownDir: h.wellKnownDir,
-          spawner,
-          alive: () => true,
-          probe: probeTaken(new Set([1939])),
-          pidOnPort: () => 4242,
-          readyWaitMs: 0,
-        }),
-      ).rejects.toThrow(/PID 4242 is already listening.*parachute restart hub/);
-    } finally {
-      h.cleanup();
-    }
-  });
-
-  test("fallback walks up when caller widens the range (debug/tests only)", async () => {
-    const h = makeHarness();
-    try {
-      const spawner = makeSpawner(7777);
-      const result = await ensureHubRunning({
-        configDir: h.configDir,
-        wellKnownDir: h.wellKnownDir,
-        spawner,
-        alive: () => true,
-        probe: probeTaken(new Set([1939, 1940])),
-        readyWaitMs: 0,
-        fallbackRange: 5,
-      });
-      expect(result.port).toBe(1941);
-      expect(readHubPort(h.configDir)).toBe(1941);
-    } finally {
-      h.cleanup();
-    }
-  });
-
-  test("idempotent: returns existing pid + port when hub is already running", async () => {
-    const h = makeHarness();
-    try {
-      writePid("hub", 12345, h.configDir);
-      writeHubPort(1944, h.configDir);
-      const spawner = makeSpawner(9999);
-      const result = await ensureHubRunning({
-        configDir: h.configDir,
-        wellKnownDir: h.wellKnownDir,
-        spawner,
-        alive: () => true,
-        probe: probeTaken(new Set()),
-        readyWaitMs: 0,
-      });
-      expect(result.started).toBe(false);
-      expect(result.pid).toBe(12345);
-      expect(result.port).toBe(1944);
-      expect(spawner.calls).toHaveLength(0);
-    } finally {
-      h.cleanup();
-    }
-  });
-
-  test("stale pid (process gone) is cleared and a fresh hub is spawned", async () => {
-    const h = makeHarness();
-    try {
-      writePid("hub", 99, h.configDir);
-      writeHubPort(1939, h.configDir);
-      const spawner = makeSpawner(100);
-      const result = await ensureHubRunning({
-        configDir: h.configDir,
-        wellKnownDir: h.wellKnownDir,
-        spawner,
-        alive: () => false,
-        probe: probeTaken(new Set()),
-        readyWaitMs: 0,
-      });
-      expect(result.started).toBe(true);
-      expect(result.pid).toBe(100);
-      expect(spawner.calls).toHaveLength(1);
-    } finally {
-      h.cleanup();
-    }
-  });
-
-  test("throws when no port in the fallback range is free", async () => {
-    const h = makeHarness();
-    try {
-      const spawner = makeSpawner(1);
-      await expect(
-        ensureHubRunning({
-          configDir: h.configDir,
-          wellKnownDir: h.wellKnownDir,
-          spawner,
-          alive: () => true,
-          probe: async () => false,
-          pidOnPort: () => undefined,
-          readyWaitMs: 0,
-          fallbackRange: 3,
-        }),
-      ).rejects.toThrow(/unavailable/);
-    } finally {
-      h.cleanup();
-    }
-  });
-
-  test("skips reserved service ports during fallback (widened range)", async () => {
-    // Fallback is off by default (range=1). When a caller opens it up for
-    // debug, reservedPorts must still be honored so the hub never steals a
-    // registered service's slot even if the service isn't yet bound.
-    const h = makeHarness();
-    try {
-      const spawner = makeSpawner(3333);
-      const result = await ensureHubRunning({
-        configDir: h.configDir,
-        wellKnownDir: h.wellKnownDir,
-        spawner,
-        alive: () => true,
-        probe: probeTaken(new Set([1939])), // default port is held
-        reservedPorts: [1940], // vault's reservation
-        readyWaitMs: 0,
-        fallbackRange: 5,
-      });
-      // 1939 is taken, 1940 is reserved → we get 1941.
-      expect(result.port).toBe(1941);
-      expect(readHubPort(h.configDir)).toBe(1941);
-    } finally {
-      h.cleanup();
-    }
-  });
-
-  test("honors startPort override", async () => {
-    const h = makeHarness();
-    try {
-      const spawner = makeSpawner(2222);
-      const result = await ensureHubRunning({
-        configDir: h.configDir,
-        wellKnownDir: h.wellKnownDir,
-        spawner,
-        alive: () => true,
-        probe: probeTaken(new Set()),
-        readyWaitMs: 0,
-        startPort: 18080,
-      });
-      expect(result.port).toBe(18080);
-    } finally {
-      h.cleanup();
-    }
-  });
-});
-
 describe("stopHub", () => {
   test("SIGTERMs running hub, clears pid + port", async () => {
     const h = makeHarness();

package/src/__tests__/hub-server.test.ts

@@ -4268,3 +4268,67 @@ describe("POST /account/vault-token/<name> — friend scoped mint (routed end-to
     }
   });
 });
+
+describe("hubFetch routing — /api/hub/upgrade (D4 SPA hub-upgrade)", () => {
+  test("POST /api/hub/upgrade dispatches to the handler (401 without bearer, NOT 404)", async () => {
+    const h = makeHarness();
+    try {
+      const db = openHubDb(hubDbPath(h.dir));
+      try {
+        rotateSigningKey(db);
+        await createUser(db, "owner", "pw");
+        // No bearer → the handler's auth gate returns 401. A 404 would mean
+        // the route never reached the handler (dispatch missing). The endpoint
+        // does NOT require a supervisor — assert it works without one.
+        const res = await hubFetch(h.dir, { getDb: () => db, manifestPath: h.manifestPath })(
+          req("/api/hub/upgrade", { method: "POST" }),
+        );
+        expect(res.status).toBe(401);
+      } finally {
+        db.close();
+      }
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("GET /api/hub/upgrade/status dispatches to the handler (401 without bearer)", async () => {
+    const h = makeHarness();
+    try {
+      const db = openHubDb(hubDbPath(h.dir));
+      try {
+        rotateSigningKey(db);
+        await createUser(db, "owner", "pw");
+        const res = await hubFetch(h.dir, { getDb: () => db, manifestPath: h.manifestPath })(
+          req("/api/hub/upgrade/status"),
+        );
+        expect(res.status).toBe(401);
+      } finally {
+        db.close();
+      }
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("GET on /api/hub/upgrade → 405 (POST-only) once authenticated path is reached", async () => {
+    const h = makeHarness();
+    try {
+      const db = openHubDb(hubDbPath(h.dir));
+      try {
+        rotateSigningKey(db);
+        await createUser(db, "owner", "pw");
+        // GET on the POST-only upgrade route: no bearer means auth runs first
+        // (401). The point of this case is the route is wired (not 404).
+        const res = await hubFetch(h.dir, { getDb: () => db, manifestPath: h.manifestPath })(
+          req("/api/hub/upgrade", { method: "GET" }),
+        );
+        expect(res.status).not.toBe(404);
+      } finally {
+        db.close();
+      }
+    } finally {
+      h.cleanup();
+    }
+  });
+});