npm - @openparachute/hub - Versions diffs - 0.7.7-rc.7 → 0.7.7-rc.9 - Mend

@openparachute/hub 0.7.7-rc.7 → 0.7.7-rc.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/package.json +1 -1
package/src/__tests__/account-api.test.ts +287 -27
package/src/__tests__/install.test.ts +187 -5
package/src/__tests__/notes-serve.test.ts +216 -0
package/src/__tests__/port-assign.test.ts +43 -14
package/src/__tests__/services-manifest.test.ts +350 -40
package/src/__tests__/setup.test.ts +5 -1
package/src/account-api.ts +111 -66
package/src/api-invites.ts +19 -0
package/src/api-modules.ts +1 -1
package/src/commands/install.ts +44 -0
package/src/commands/setup.ts +9 -4
package/src/help.ts +6 -5
package/src/hub-server.ts +11 -4
package/src/hub-settings.ts +15 -1
package/src/invites.ts +42 -0
package/src/notes-serve.ts +73 -31
package/src/service-spec.ts +113 -29
package/src/services-manifest.ts +104 -11

package/src/__tests__/notes-serve.test.ts CHANGED Viewed

@@ -149,6 +149,124 @@ describe("notesFetch with empty mount (root deployment)", () => {
   });
 });
+describe("notesFetch /health (2026-07-11, hub-parity P5)", () => {
+  test("GET /notes/health answers 2xx explicitly, not the SPA shell", async () => {
+    const h = makeHarness();
+    try {
+      const res = notesFetch(h.dir, "/notes")(req("/notes/health"));
+      expect(res.status).toBe(200);
+      // Explicit JSON, not the index.html SPA-shell fallback — proves the
+      // health path is a real handler, not an accident of the catch-all.
+      expect(res.headers.get("content-type")).toBe("application/json");
+      expect(await res.text()).not.toContain("notes spa");
+    } finally {
+      h.cleanup();
+    }
+  });
+  test("GET /health answers 2xx at the mount root too (empty mount)", async () => {
+    const h = makeHarness();
+    try {
+      const res = notesFetch(h.dir, "")(req("/health"));
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toBe("application/json");
+    } finally {
+      h.cleanup();
+    }
+  });
+  test("survives a missing dist/index.html — health doesn't depend on the SPA shell existing", async () => {
+    // A harness with NO index.html written — the SPA-shell fallback would
+    // throw/404 on this dist, but /health is answered before that code path
+    // is ever reached.
+    const dir = mkdtempSync(join(tmpdir(), "pcli-notes-serve-empty-"));
+    try {
+      const res = notesFetch(dir, "/app")(req("/app/health"));
+      expect(res.status).toBe(200);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+// hub-parity P5 (2026-07-11): the shim generalized beyond notes to serve
+// @openparachute/parachute-app (mount `/app`, port 1944) via the same
+// FIRST_PARTY_FALLBACKS startCmd shape (`--package @openparachute/parachute-app`).
+// These tests re-run the load-bearing PWA regression (sw.js / manifest
+// content-type, SPA fallback, mount-strip) for a NON-notes package/mount to
+// prove the generalization didn't accidentally hardcode "notes" anywhere in
+// the serving path (only `resolveNotesDistFrom`'s package resolution is
+// notes-specific, and that's parameterized separately below).
+describe("notesFetch generalized for a non-notes package (hub-parity P5 — the app mount)", () => {
+  function makeAppHarness(): Harness {
+    const dir = mkdtempSync(join(tmpdir(), "pcli-app-serve-"));
+    writeFileSync(join(dir, "index.html"), "<html><body>app spa</body></html>");
+    writeFileSync(join(dir, "sw.js"), "self.addEventListener('install', () => {});");
+    writeFileSync(join(dir, "manifest.webmanifest"), '{"name":"Parachute","start_url":"/app/"}');
+    return { dir, cleanup: () => rmSync(dir, { recursive: true, force: true }) };
+  }
+  test("GET /app/sw.js serves the SW with JS content-type, not text/html", async () => {
+    const h = makeAppHarness();
+    try {
+      const res = notesFetch(h.dir, "/app")(req("/app/sw.js"));
+      expect(res.status).toBe(200);
+      const ct = res.headers.get("content-type") ?? "";
+      expect(ct).not.toContain("text/html");
+      expect(ct).toMatch(/javascript/);
+    } finally {
+      h.cleanup();
+    }
+  });
+  test("GET /app/manifest.webmanifest serves application/manifest+json", async () => {
+    const h = makeAppHarness();
+    try {
+      const res = notesFetch(h.dir, "/app")(req("/app/manifest.webmanifest"));
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toBe("application/manifest+json");
+      expect(await res.text()).toContain('"name":"Parachute"');
+    } finally {
+      h.cleanup();
+    }
+  });
+  test("GET /app/ serves the SPA shell", async () => {
+    const h = makeAppHarness();
+    try {
+      const res = notesFetch(h.dir, "/app")(req("/app/"));
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toBe("text/html; charset=utf-8");
+      expect(await res.text()).toContain("app spa");
+    } finally {
+      h.cleanup();
+    }
+  });
+  test("GET /app/some/deep/route falls back to the SPA shell (client-side routing)", async () => {
+    const h = makeAppHarness();
+    try {
+      const res = notesFetch(h.dir, "/app")(req("/app/some/deep/route"));
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toBe("text/html; charset=utf-8");
+      expect(await res.text()).toContain("app spa");
+    } finally {
+      h.cleanup();
+    }
+  });
+  test("GET /appendix/foo (mount-prefix collision) is not stripped", async () => {
+    const h = makeAppHarness();
+    try {
+      const res = notesFetch(h.dir, "/app")(req("/appendix/foo"));
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toBe("text/html; charset=utf-8");
+    } finally {
+      h.cleanup();
+    }
+  });
+});
 describe("notesDistCandidates", () => {
   test("returns cwd, then global node_modules, then global root", () => {
     const cands = notesDistCandidates("/some/cwd", "/home/user");
@@ -295,3 +413,101 @@ describe("resolveNotesDistFrom (hub#194)", () => {
     ).toThrow(/has no dist\/ directory/);
   });
 });
+/**
+ * `--package` generalization (hub-parity P5, 2026-07-11). `resolveNotesDistFrom`
+ * defaults `pkg` to `@openparachute/notes` (every test above omits it and
+ * still resolves notes — back-compat), but a caller like the `app`
+ * FIRST_PARTY_FALLBACKS entry passes a different package name. These tests
+ * pin the resolver against a real on-disk fixture for a NON-notes package,
+ * proving the specifier passed to `Bun.resolveSync` (and every error message)
+ * is the caller's `pkg`, not a hardcoded "notes" string.
+ */
+describe("resolveNotesDistFrom --package (hub-parity P5)", () => {
+  const APP_PKG = "@openparachute/parachute-app";
+  function makeAppFixture(): { home: string; cleanup: () => void; dist: string } {
+    const root = realpathSync(mkdtempSync(join(tmpdir(), "pcli-app-resolve-")));
+    const home = join(root, "home");
+    const pkgRoot = join(home, ".bun/install/global/node_modules", APP_PKG);
+    mkdirSync(pkgRoot, { recursive: true });
+    const dist = join(pkgRoot, "dist");
+    mkdirSync(dist, { recursive: true });
+    writeFileSync(join(pkgRoot, "package.json"), JSON.stringify({ name: APP_PKG }));
+    return { home, dist, cleanup: () => rmSync(root, { recursive: true, force: true }) };
+  }
+  test("resolves a non-notes package's dist/ via the global node_modules fallback", () => {
+    const f = makeAppFixture();
+    try {
+      const out = resolveNotesDistFrom({
+        cwd: "/hub-repo-cwd-without-app",
+        home: f.home,
+        pkg: APP_PKG,
+        resolveSync: (specifier, base) => {
+          if (base === "/hub-repo-cwd-without-app") {
+            throw new Error(`Cannot find module '${specifier}' from '${base}'`);
+          }
+          return Bun.resolveSync(specifier, base);
+        },
+      });
+      expect(out).toBe(f.dist);
+    } finally {
+      f.cleanup();
+    }
+  });
+  test("default pkg (no --package) still resolves @openparachute/notes — back-compat", () => {
+    // Every earlier describe block already exercises this implicitly (none
+    // pass `pkg`); this test pins it explicitly against the specifier the
+    // resolver hands to `resolveSync`.
+    const specifiers: string[] = [];
+    expect(() =>
+      resolveNotesDistFrom({
+        cwd: "/cwd",
+        home: "/h",
+        resolveSync: (specifier) => {
+          specifiers.push(specifier);
+          throw new Error("not found");
+        },
+      }),
+    ).toThrow();
+    expect(specifiers).toEqual([
+      "@openparachute/notes/package.json",
+      "@openparachute/notes/package.json",
+      "@openparachute/notes/package.json",
+    ]);
+  });
+  test("error message names the caller's package, not a hardcoded 'notes'", () => {
+    let caught: unknown;
+    try {
+      resolveNotesDistFrom({
+        cwd: "/probe-cwd",
+        home: "/probe-home",
+        pkg: APP_PKG,
+        resolveSync: () => {
+          throw new Error("nope");
+        },
+      });
+    } catch (err) {
+      caught = err;
+    }
+    const msg = (caught as Error).message;
+    expect(msg).toContain(`Could not resolve ${APP_PKG}`);
+    expect(msg).toContain(`bun add -g ${APP_PKG}`);
+    expect(msg).not.toContain("@openparachute/notes");
+  });
+  test("no-dist/ hard error names the caller's package", () => {
+    expect(() =>
+      resolveNotesDistFrom({
+        cwd: "/cwd-with-app",
+        home: "/h",
+        pkg: APP_PKG,
+        resolveSync: () => "/cwd-with-app/node_modules/@openparachute/parachute-app/package.json",
+        existsSync: () => false,
+      }),
+    ).toThrow(new RegExp(`${APP_PKG.replace("/", "\\/")} resolved at .* has no dist/ directory`));
+  });
+});

package/src/__tests__/port-assign.test.ts CHANGED Viewed

@@ -3,7 +3,26 @@ import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "no
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { assignPort, assignServicePort } from "../port-assign.ts";
-import { CANONICAL_PORT_MAX, CANONICAL_PORT_MIN } from "../service-spec.ts";
+import { CANONICAL_PORT_MAX, CANONICAL_PORT_MIN, PORT_RESERVATIONS } from "../service-spec.ts";
+describe("PORT_RESERVATIONS (registry shape)", () => {
+  test("every port in the canonical range appears exactly once", () => {
+    const ports = PORT_RESERVATIONS.map((r) => r.port);
+    expect(new Set(ports).size).toBe(ports.length);
+    expect(ports.slice().sort((a, b) => a - b)).toEqual(ports);
+    for (const p of ports) {
+      expect(p).toBeGreaterThanOrEqual(CANONICAL_PORT_MIN);
+      expect(p).toBeLessThanOrEqual(CANONICAL_PORT_MAX);
+    }
+  });
+  test("1944 (parachute-app, hub-parity P5) doesn't collide with any other reservation", () => {
+    const owners = PORT_RESERVATIONS.filter((r) => r.port === 1944);
+    expect(owners).toHaveLength(1);
+    expect(owners[0]?.name).toBe("parachute-app");
+    expect(owners[0]?.status).toBe("assigned");
+  });
+});
 function makeTempDir(): { dir: string; cleanup: () => void } {
   const dir = mkdtempSync(join(tmpdir(), "pcli-port-assign-"));
@@ -25,16 +44,20 @@ describe("assignPort (pure)", () => {
   });
   test("walks the unassigned reservation range when canonical is occupied", () => {
-    // 1940 is taken; canonical reserved range starts at 1944 → first hit.
+    // 1940 is taken. 1944 is now `parachute-app`'s canonical slot (hub-parity
+    // P5, status "assigned") so the walker skips it; the first RESERVED
+    // (walkable) slot is 1945.
     const result = assignPort(1940, [1940]);
-    expect(result.port).toBe(1944);
+    expect(result.port).toBe(1945);
     expect(result.source).toBe("fallback-in-range");
     expect(result.warning).toMatch(/canonical port 1940 is in use/);
-    expect(result.warning).toMatch(/1944/);
+    expect(result.warning).toMatch(/1945/);
   });
   test("skips reservations that are also occupied", () => {
-    // Canonical 1940 + the first three reserved slots are all in use.
+    // Canonical 1940 is in use. 1944 is assigned (parachute-app, skipped
+    // regardless of `occupied`); 1945 is reserved-but-occupied; 1946 is
+    // assigned (parachute-surface, skipped); 1947 is reserved-and-free.
     const result = assignPort(1940, [1940, 1944, 1945, 1946]);
     expect(result.port).toBe(1947);
     expect(result.source).toBe("fallback-in-range");
@@ -60,19 +83,21 @@ describe("assignPort (pure)", () => {
   });
   test("third-party (no canonical slot) jumps straight to the reservation range", () => {
+    // 1944 is assigned (parachute-app, hub-parity P5) so the walker skips it;
+    // the first RESERVED (walkable) slot is 1945.
     const result = assignPort(undefined, []);
-    expect(result.port).toBe(1944);
+    expect(result.port).toBe(1945);
     expect(result.source).toBe("fallback-in-range");
     expect(result.warning).toMatch(/no canonical slot/);
-    expect(result.warning).toMatch(/1944/);
+    expect(result.warning).toMatch(/1945/);
   });
   test("third-party with reservations occupied walks further in the range", () => {
-    // PORT_RESERVATIONS post-hub#323: 1944 reserved, 1945 reserved, 1946
-    // assigned (parachute-app — KNOWN_MODULES carries the canonical slot
-    // so the fallback walker doesn't hand it to a third party), 1947
-    // reserved. With 1944 + 1945 occupied, the walker skips the assigned
-    // 1946 slot and lands on the next reserved-and-free port — 1947.
+    // PORT_RESERVATIONS: 1944 assigned (parachute-app), 1945 reserved, 1946
+    // assigned (parachute-surface — both carry canonical slots so the
+    // fallback walker doesn't hand them to a third party), 1947 reserved.
+    // With 1944 + 1945 occupied, the walker skips the assigned 1946 slot and
+    // lands on the next reserved-and-free port — 1947.
     const result = assignPort(undefined, [1944, 1945]);
     expect(result.port).toBe(1947);
     expect(result.source).toBe("fallback-in-range");
@@ -145,7 +170,9 @@ describe("assignServicePort (hub#206 — services.json is authoritative)", () =>
         canonical: 1940,
         occupied: [1940],
       });
-      expect(result.port).toBe(1944);
+      // 1944 is parachute-app's assigned (non-walkable) slot as of
+      // hub-parity P5 — the first walkable reserved slot is 1945.
+      expect(result.port).toBe(1945);
       expect(result.source).toBe("fallback-in-range");
       expect(result.warning).toMatch(/canonical port 1940 is in use/);
       // .env stays bit-for-bit identical.
@@ -162,7 +189,9 @@ describe("assignServicePort (hub#206 — services.json is authoritative)", () =>
       const result = assignServicePort({
         occupied: [],
       });
-      expect(result.port).toBe(1944);
+      // 1944 is parachute-app's assigned (non-walkable) slot as of
+      // hub-parity P5 — the first walkable reserved slot is 1945.
+      expect(result.port).toBe(1945);
       expect(result.source).toBe("fallback-in-range");
       expect(existsSync(envPath)).toBe(false);
     } finally {