@openparachute/hub 0.5.13-rc.13 → 0.5.13-rc.21

package/src/__tests__/setup-wizard.test.ts

@@ -2709,3 +2709,231 @@ describe("bootstrap token gate (handleSetupAccountPost)", () => {
     }
   });
 });
+
+// --- hub#342 UI pass: "Start using your vault" lead tile + Use it now ---
+
+describe("done screen — 'Start using your vault' tile (hub#342)", () => {
+  let h: Harness;
+  beforeEach(() => {
+    h = makeHarness();
+    _resetOperationsRegistryForTests();
+  });
+  afterEach(() => h.cleanup());
+
+  test("when only vault is installed, the lead tile links to vault admin", async () => {
+    const db = openHubDb(hubDbPath(h.dir));
+    try {
+      const user = await createUser(db, "owner", "pw");
+      writeManifest(
+        {
+          services: [
+            {
+              name: "parachute-vault",
+              version: "0.1.0",
+              port: 1940,
+              paths: ["/vault/default"],
+              health: "/health",
+            },
+          ],
+        },
+        h.manifestPath,
+      );
+      setSetting(db, "setup_expose_mode", "localhost");
+      const { createSession } = await import("../sessions.ts");
+      const session = createSession(db, { userId: user.id });
+      const res = handleSetupGet(
+        req("/admin/setup?just_finished=1", {
+          headers: { cookie: `${SESSION_COOKIE_NAME}=${session.id}` },
+        }),
+        {
+          db,
+          manifestPath: h.manifestPath,
+          configDir: h.dir,
+          issuer: "https://hub.example",
+          registry: getDefaultOperationsRegistry(),
+        },
+      );
+      const html = await res.text();
+      // Section heading present + primary CTA points at the vault's own admin.
+      expect(html).toContain("Start using your vault");
+      expect(html).toContain('href="/vault/default/admin/"');
+      // Lead tile precedes the MCP / install tiles (it's the lead).
+      const startIdx = html.indexOf("Start using your vault");
+      const installIdx = html.indexOf("What's next?");
+      expect(startIdx).toBeLessThan(installIdx);
+    } finally {
+      db.close();
+    }
+  });
+
+  test("when app is also installed, the lead tile links to /app/notes/", async () => {
+    const db = openHubDb(hubDbPath(h.dir));
+    try {
+      const user = await createUser(db, "owner", "pw");
+      writeManifest(
+        {
+          services: [
+            {
+              name: "parachute-vault",
+              version: "0.1.0",
+              port: 1940,
+              paths: ["/vault/default"],
+              health: "/health",
+            },
+            {
+              name: "parachute-app",
+              version: "0.2.0",
+              port: 1946,
+              paths: ["/app"],
+              health: "/app/healthz",
+            },
+          ],
+        },
+        h.manifestPath,
+      );
+      setSetting(db, "setup_expose_mode", "localhost");
+      const { createSession } = await import("../sessions.ts");
+      const session = createSession(db, { userId: user.id });
+      const res = handleSetupGet(
+        req("/admin/setup?just_finished=1", {
+          headers: { cookie: `${SESSION_COOKIE_NAME}=${session.id}` },
+        }),
+        {
+          db,
+          manifestPath: h.manifestPath,
+          configDir: h.dir,
+          issuer: "https://hub.example",
+          registry: getDefaultOperationsRegistry(),
+        },
+      );
+      const html = await res.text();
+      expect(html).toContain("Start using your vault");
+      // App installed → primary CTA links to Notes-as-UI inside App.
+      expect(html).toContain('href="/app/notes/"');
+      expect(html).toContain("Open Notes");
+    } finally {
+      db.close();
+    }
+  });
+
+  test("succeeded install op renders a 'Use it now' link pointing at the module's surface", async () => {
+    const db = openHubDb(hubDbPath(h.dir));
+    try {
+      const user = await createUser(db, "owner", "pw");
+      writeManifest(
+        {
+          services: [
+            {
+              name: "parachute-vault",
+              version: "0.1.0",
+              port: 1940,
+              paths: ["/vault/default"],
+              health: "/health",
+            },
+          ],
+        },
+        h.manifestPath,
+      );
+      setSetting(db, "setup_expose_mode", "localhost");
+      const reg = getDefaultOperationsRegistry();
+      const op = reg.create("install", "app");
+      reg.update(op.id, { status: "succeeded" }, "installed @openparachute/app");
+      const { createSession } = await import("../sessions.ts");
+      const session = createSession(db, { userId: user.id });
+      const res = handleSetupGet(
+        req(`/admin/setup?just_finished=1&op_app=${op.id}`, {
+          headers: { cookie: `${SESSION_COOKIE_NAME}=${session.id}` },
+        }),
+        {
+          db,
+          manifestPath: h.manifestPath,
+          configDir: h.dir,
+          issuer: "https://hub.example",
+          registry: reg,
+        },
+      );
+      const html = await res.text();
+      expect(html).toContain("status: succeeded");
+      // Primary "Use it now" link goes to the app's surface; secondary
+      // "Manage modules" link still present.
+      expect(html).toContain(">Use it now<");
+      expect(html).toContain('href="/app/notes/"');
+      expect(html).toContain(">Manage modules<");
+    } finally {
+      db.close();
+    }
+  });
+
+  test("'Already installed' tile gains a 'Use it now' link too", async () => {
+    const db = openHubDb(hubDbPath(h.dir));
+    try {
+      const user = await createUser(db, "owner", "pw");
+      writeManifest(
+        {
+          services: [
+            {
+              name: "parachute-vault",
+              version: "0.1.0",
+              port: 1940,
+              paths: ["/vault/default"],
+              health: "/health",
+            },
+            {
+              name: "parachute-app",
+              version: "0.2.0",
+              port: 1946,
+              paths: ["/app"],
+              health: "/app/healthz",
+            },
+          ],
+        },
+        h.manifestPath,
+      );
+      setSetting(db, "setup_expose_mode", "localhost");
+      const { createSession } = await import("../sessions.ts");
+      const session = createSession(db, { userId: user.id });
+      const res = handleSetupGet(
+        req("/admin/setup?just_finished=1", {
+          headers: { cookie: `${SESSION_COOKIE_NAME}=${session.id}` },
+        }),
+        {
+          db,
+          manifestPath: h.manifestPath,
+          configDir: h.dir,
+          issuer: "https://hub.example",
+          registry: getDefaultOperationsRegistry(),
+        },
+      );
+      const html = await res.text();
+      expect(html).toContain("Already installed");
+      // App's already-installed tile carries the Use it now link.
+      expect(html).toContain('href="/app/notes/"');
+    } finally {
+      db.close();
+    }
+  });
+
+  test("install-log CSS includes overflow-wrap so long lines wrap in the card", async () => {
+    // Smoke test for the CSS fold (hub#342): the .op-log block sets
+    // overflow-x:auto and the .log-lines li set white-space:pre-wrap +
+    // overflow-wrap:anywhere. These are the three properties Aaron's
+    // bug report flagged — without them long install logs blow up the
+    // wizard layout.
+    const db = openHubDb(hubDbPath(h.dir));
+    try {
+      const res = handleSetupGet(req("/admin/setup"), {
+        db,
+        manifestPath: h.manifestPath,
+        configDir: h.dir,
+        issuer: "https://hub.example",
+        registry: getDefaultOperationsRegistry(),
+      });
+      const html = await res.text();
+      expect(html).toContain("overflow-x: auto");
+      expect(html).toContain("white-space: pre-wrap");
+      expect(html).toContain("overflow-wrap: anywhere");
+    } finally {
+      db.close();
+    }
+  });
+});

package/src/__tests__/status.test.ts

@@ -686,12 +686,12 @@ describe("status", () => {
       try {
         upsertService(
           {
-            name: "agent",
+            name: "someapp",
             port: 1946,
-            paths: ["/agent"],
-            health: "/agent/health",
+            paths: ["/someapp"],
+            health: "/someapp/health",
             version: "0.1.4-rc.1",
-            // No installDir; agent isn't in FIRST_PARTY_FALLBACKS by short name,
+            // No installDir; someapp isn't in FIRST_PARTY_FALLBACKS by short name,
             // and the fallback bun-global lookup needs a known package name.
           },
           path,

package/src/__tests__/upgrade.test.ts

@@ -3,7 +3,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { UpgradeRunner } from "../commands/upgrade.ts";
-import { upgrade } from "../commands/upgrade.ts";
+import { compareVersions, detectChannel, upgrade } from "../commands/upgrade.ts";
 import { upsertService } from "../services-manifest.ts";
 
 interface RunCall {
@@ -288,7 +288,13 @@ describe("parachute upgrade", () => {
     }
   });
 
-  test("bun-linked frontend: runs bun run build before restart", async () => {
+  // hub#301 Phase C/D (#330): `kind` retired and the bun-linked
+  // `kind === "frontend"` build branch retires with it. Notes-daemon's
+  // `prepublishOnly` builds dist at publish time so consumers don't need a
+  // post-install rebuild; this test pins the new behavior — even a
+  // historical frontend module (with a `build` script in package.json)
+  // does NOT trigger `bun run build` during an upgrade.
+  test("bun-linked: no bun run build invoked (kind branch retired in #330)", async () => {
     const h = makeHarness();
     try {
       const installDir = join(h.installRoot, "notes");
@@ -341,7 +347,7 @@ describe("parachute upgrade", () => {
         log: () => {},
       });
       expect(code).toBe(0);
-      expect(ranBuild.value).toBe(true);
+      expect(ranBuild.value).toBe(false);
     } finally {
       h.cleanup();
     }
@@ -781,4 +787,357 @@ describe("parachute upgrade", () => {
       h.cleanup();
     }
   });
+
+  // -------------------------------------------------------------------------
+  // hub#332 — channel preservation + downgrade refusal
+  // -------------------------------------------------------------------------
+
+  test("detectChannel: rc suffixes → 'rc', everything else → 'latest'", () => {
+    expect(detectChannel("0.5.13-rc.13")).toBe("rc");
+    expect(detectChannel("0.5.13-rc.1")).toBe("rc");
+    expect(detectChannel("0.5.13-rc")).toBe("rc"); // no .N suffix
+    expect(detectChannel("0.5.10")).toBe("latest");
+    expect(detectChannel("1.0.0")).toBe("latest");
+    expect(detectChannel("0.5.13-beta.1")).toBe("latest"); // not rc
+    expect(detectChannel("0.5.13-alpha")).toBe("latest");
+  });
+
+  test("compareVersions: stable > matching rc; later rc > earlier rc", () => {
+    // Stable beats prerelease at equal triple (semver §11.4.3)
+    expect(compareVersions("0.5.13", "0.5.13-rc.13")).toBeGreaterThan(0);
+    expect(compareVersions("0.5.13-rc.13", "0.5.13")).toBeLessThan(0);
+    // Aaron's reproducer: 0.5.10 < 0.5.13-rc.13 (lower triple beats prerelease tail)
+    expect(compareVersions("0.5.10", "0.5.13-rc.13")).toBeLessThan(0);
+    expect(compareVersions("0.5.13-rc.14", "0.5.13-rc.13")).toBeGreaterThan(0);
+    expect(compareVersions("0.5.13-rc.13", "0.5.13-rc.13")).toBe(0);
+    // Patch difference dominates prerelease tail
+    expect(compareVersions("0.5.14", "0.5.13-rc.99")).toBeGreaterThan(0);
+    // Garbage in → null
+    expect(compareVersions("not-a-version", "0.5.10")).toBeNull();
+  });
+
+  test("auto-detects rc channel: installed 0.5.13-rc.13 → bun add -g @openparachute/hub@rc", async () => {
+    const h = makeHarness();
+    try {
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.13-rc.13" });
+
+      const seenCmd: string[][] = [];
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          seenCmd.push([...cmd]);
+          if (cmd[0] === "bun" && cmd[1] === "add" && cmd[2] === "-g") {
+            writePackageJson(hubInstallDir, {
+              name: "@openparachute/hub",
+              version: "0.5.13-rc.14",
+            });
+          }
+          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 code = await upgrade("hub", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) =>
+          pkg === "@openparachute/hub" ? join(hubInstallDir, "package.json") : null,
+        restartFn: async () => 0,
+        // No resolveChannelVersion → npm view stub returns empty → guard skipped
+        log: () => {},
+      });
+      expect(code).toBe(0);
+      const addCall = seenCmd.find((c) => c[0] === "bun" && c[1] === "add");
+      expect(addCall).toEqual(["bun", "add", "-g", "@openparachute/hub@rc"]);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("auto-detects stable channel: installed 0.5.10 → bun add -g @openparachute/hub@latest", async () => {
+    const h = makeHarness();
+    try {
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.10" });
+
+      const seenCmd: string[][] = [];
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          seenCmd.push([...cmd]);
+          if (cmd[0] === "bun" && cmd[1] === "add" && cmd[2] === "-g") {
+            writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.11" });
+          }
+          return 0;
+        },
+        async capture(cmd) {
+          if (cmd[1] === "rev-parse" && cmd[2] === "--is-inside-work-tree") {
+            return { code: 128, stdout: "" };
+          }
+          return { code: 0, stdout: "" };
+        },
+      };
+
+      await upgrade("hub", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) =>
+          pkg === "@openparachute/hub" ? join(hubInstallDir, "package.json") : null,
+        restartFn: async () => 0,
+        log: () => {},
+      });
+      const addCall = seenCmd.find((c) => c[0] === "bun" && c[1] === "add");
+      expect(addCall).toEqual(["bun", "add", "-g", "@openparachute/hub@latest"]);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("--channel rc overrides stable detection", async () => {
+    const h = makeHarness();
+    try {
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.10" });
+
+      const seenCmd: string[][] = [];
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          seenCmd.push([...cmd]);
+          if (cmd[0] === "bun" && cmd[1] === "add" && cmd[2] === "-g") {
+            writePackageJson(hubInstallDir, {
+              name: "@openparachute/hub",
+              version: "0.5.13-rc.14",
+            });
+          }
+          return 0;
+        },
+        async capture(cmd) {
+          if (cmd[1] === "rev-parse" && cmd[2] === "--is-inside-work-tree") {
+            return { code: 128, stdout: "" };
+          }
+          return { code: 0, stdout: "" };
+        },
+      };
+
+      await upgrade("hub", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) =>
+          pkg === "@openparachute/hub" ? join(hubInstallDir, "package.json") : null,
+        restartFn: async () => 0,
+        channel: "rc",
+        log: () => {},
+      });
+      const addCall = seenCmd.find((c) => c[0] === "bun" && c[1] === "add");
+      expect(addCall).toEqual(["bun", "add", "-g", "@openparachute/hub@rc"]);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("refuses downgrade: installed 0.5.13-rc.13, @rc resolves to 0.5.10 → abort", async () => {
+    // Aaron's exact reproducer modulo the channel fix — once channel detection
+    // lands, @rc is the right tag; if @rc itself somehow resolves backward we
+    // still refuse.
+    const h = makeHarness();
+    try {
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.13-rc.13" });
+
+      const seenCmd: string[][] = [];
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          seenCmd.push([...cmd]);
+          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[] = [];
+      let restartCalled = false;
+      const code = await upgrade("hub", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) =>
+          pkg === "@openparachute/hub" ? join(hubInstallDir, "package.json") : null,
+        restartFn: async () => {
+          restartCalled = true;
+          return 0;
+        },
+        resolveChannelVersion: async (_pkg, _channel) => "0.5.10",
+        log: (l) => logs.push(l),
+      });
+      expect(code).toBe(1);
+      expect(restartCalled).toBe(false);
+      // bun add was never run
+      const addCall = seenCmd.find((c) => c[0] === "bun" && c[1] === "add");
+      expect(addCall).toBeUndefined();
+      const joined = logs.join("\n");
+      expect(joined).toMatch(/refusing to downgrade/);
+      expect(joined).toMatch(/installed 0\.5\.13-rc\.13/);
+      expect(joined).toMatch(/0\.5\.10/);
+      expect(joined).toMatch(/--allow-downgrade/);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("--allow-downgrade bypasses the refusal", async () => {
+    const h = makeHarness();
+    try {
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.13-rc.13" });
+
+      const seenCmd: string[][] = [];
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          seenCmd.push([...cmd]);
+          if (cmd[0] === "bun" && cmd[1] === "add" && cmd[2] === "-g") {
+            writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.10" });
+          }
+          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 code = await upgrade("hub", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) =>
+          pkg === "@openparachute/hub" ? join(hubInstallDir, "package.json") : null,
+        restartFn: async () => 0,
+        resolveChannelVersion: async () => "0.5.10",
+        allowDowngrade: true,
+        log: () => {},
+      });
+      expect(code).toBe(0);
+      const addCall = seenCmd.find((c) => c[0] === "bun" && c[1] === "add");
+      // Channel was auto-detected as `rc` from the rc-suffixed installed version
+      expect(addCall).toEqual(["bun", "add", "-g", "@openparachute/hub@rc"]);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("Aaron's reproducer: installed 0.5.13-rc.13 → upgrades via @rc, version goes UP not down", async () => {
+    // This is the exact bug from hub#332. Before the fix, `parachute upgrade
+    // hub` ran `bun add -g @openparachute/hub@latest` which (because @latest
+    // pointed at 0.5.10) silently downgraded an rc.13 install. With auto-
+    // channel detection: rc.13 → @rc → 0.5.13-rc.14, version increases.
+    const h = makeHarness();
+    try {
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.13-rc.13" });
+
+      const seenCmd: string[][] = [];
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          seenCmd.push([...cmd]);
+          if (
+            cmd[0] === "bun" &&
+            cmd[1] === "add" &&
+            cmd[2] === "-g" &&
+            cmd[3] === "@openparachute/hub@rc"
+          ) {
+            writePackageJson(hubInstallDir, {
+              name: "@openparachute/hub",
+              version: "0.5.13-rc.14",
+            });
+          }
+          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[] = [];
+      let restartedShort: string | undefined;
+      const code = await upgrade("hub", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) =>
+          pkg === "@openparachute/hub" ? join(hubInstallDir, "package.json") : null,
+        restartFn: async (svc) => {
+          restartedShort = svc;
+          return 0;
+        },
+        // @rc resolves to a HIGHER version than installed — no downgrade.
+        resolveChannelVersion: async (_pkg, channel) =>
+          channel === "rc" ? "0.5.13-rc.14" : "0.5.10",
+        log: (l) => logs.push(l),
+      });
+      expect(code).toBe(0);
+      expect(restartedShort).toBe("hub");
+      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");
+      // Version went UP (rc.13 → rc.14), not DOWN as in the original report
+      expect(joined).toMatch(/0\.5\.13-rc\.13 → 0\.5\.13-rc\.14/);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("--tag still overrides everything (back-compat for programmatic pin)", async () => {
+    const h = makeHarness();
+    try {
+      const hubInstallDir = join(h.installRoot, "hub");
+      writePackageJson(hubInstallDir, { name: "@openparachute/hub", version: "0.5.13-rc.13" });
+
+      const seenCmd: string[][] = [];
+      const runner: UpgradeRunner = {
+        async run(cmd) {
+          seenCmd.push([...cmd]);
+          return 0;
+        },
+        async capture(cmd) {
+          if (cmd[1] === "rev-parse" && cmd[2] === "--is-inside-work-tree") {
+            return { code: 128, stdout: "" };
+          }
+          return { code: 0, stdout: "" };
+        },
+      };
+
+      await upgrade("hub", {
+        manifestPath: h.manifestPath,
+        configDir: h.configDir,
+        runner,
+        findGlobalInstall: (pkg) =>
+          pkg === "@openparachute/hub" ? join(hubInstallDir, "package.json") : null,
+        restartFn: async () => 0,
+        // Programmatic `tag` wins over auto-detection AND --channel.
+        tag: "next",
+        channel: "rc",
+        log: () => {},
+      });
+      const addCall = seenCmd.find((c) => c[0] === "bun" && c[1] === "add");
+      expect(addCall).toEqual(["bun", "add", "-g", "@openparachute/hub@next"]);
+    } finally {
+      h.cleanup();
+    }
+  });
 });