@openparachute/hub 0.7.0 → 0.7.2-rc.1

package/src/__tests__/invites.test.ts

@@ -28,6 +28,7 @@ import {
   listInvites,
   revokeInvite,
   revokeInvitesForVault,
+  usernameReservedByPendingInvite,
 } from "../invites.ts";
 import { createUser } from "../users.ts";
 
@@ -68,7 +69,7 @@ describe("issueInvite", () => {
     }
   });
 
-  test("defaults: role=write, provision_vault=1, 7-day expiry", async () => {
+  test("defaults: role=write, provision_vault=1, 7-day expiry, no pre-named username", async () => {
     const { db, adminId, cleanup } = await makeDb();
     try {
       const now = new Date("2026-06-04T00:00:00Z");
@@ -76,12 +77,74 @@ describe("issueInvite", () => {
       expect(invite.role).toBe("write");
       expect(invite.provisionVault).toBe(true);
       expect(invite.vaultName).toBeNull();
+      expect(invite.username).toBeNull();
       const expiry = new Date(invite.expiresAt).getTime() - now.getTime();
       expect(Math.round(expiry / 1000)).toBe(DEFAULT_INVITE_TTL_SECONDS);
     } finally {
       cleanup();
     }
   });
+
+  test("pre-named username round-trips through the row", async () => {
+    const { db, adminId, cleanup } = await makeDb();
+    try {
+      const { rawToken, invite } = issueInvite(db, {
+        createdBy: adminId,
+        username: "jonathan",
+        vaultName: "shared",
+        provisionVault: false,
+        role: "read",
+      });
+      expect(invite.username).toBe("jonathan");
+      const found = findInviteByRawToken(db, rawToken);
+      expect(found?.username).toBe("jonathan");
+      expect(found?.vaultName).toBe("shared");
+      expect(found?.provisionVault).toBe(false);
+      expect(found?.role).toBe("read");
+    } finally {
+      cleanup();
+    }
+  });
+});
+
+describe("usernameReservedByPendingInvite", () => {
+  test("pending reserves; redeemed / revoked / expired / other-name do not", async () => {
+    const { db, adminId, cleanup } = await makeDb();
+    try {
+      const now = new Date("2026-06-10T00:00:00Z");
+      // Pending → reserved.
+      issueInvite(db, { createdBy: adminId, username: "pending-name", now: () => now });
+      expect(usernameReservedByPendingInvite(db, "pending-name", now)).toBe(true);
+      expect(usernameReservedByPendingInvite(db, "other-name", now)).toBe(false);
+      // Redeemed → free.
+      const redeemed = issueInvite(db, {
+        createdBy: adminId,
+        username: "used-name",
+        now: () => now,
+      });
+      consumeInvite(db, redeemed.invite.tokenHash, adminId, now);
+      expect(usernameReservedByPendingInvite(db, "used-name", now)).toBe(false);
+      // Revoked → free.
+      const revoked = issueInvite(db, {
+        createdBy: adminId,
+        username: "gone-name",
+        now: () => now,
+      });
+      revokeInvite(db, revoked.invite.tokenHash, now);
+      expect(usernameReservedByPendingInvite(db, "gone-name", now)).toBe(false);
+      // Expired → free.
+      issueInvite(db, {
+        createdBy: adminId,
+        username: "old-name",
+        expiresInSeconds: 60,
+        now: () => now,
+      });
+      const later = new Date(now.getTime() + 120_000);
+      expect(usernameReservedByPendingInvite(db, "old-name", later)).toBe(false);
+    } finally {
+      cleanup();
+    }
+  });
 });
 
 describe("findInviteByRawToken", () => {

package/src/__tests__/lifecycle.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { mkdtempSync, openSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, openSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -678,10 +678,37 @@ describe("group-aware kill / liveness (hub#88)", () => {
 });
 
 // ---------------------------------------------------------------------------
-// `parachute logs <svc>` — unchanged by Phase 5b. Reads the per-service logfile
-// keyed by short name (the readers §7.5 keeps). Includes the internal `hub`.
+// `parachute logs <svc>`. Under hub-as-supervisor (Phase 5b) a module's output
+// is multiplexed into the HUB log with a `[<svc>] ` line prefix, so `logs <svc>`
+// reads that stream filtered to the service (hub#652). The per-service logfile
+// keyed by short name (the readers §7.5 keeps) survives as the legacy source
+// when it's fresher than the hub log (pre-supervised installs). `logs hub`
+// reads the hub log unfiltered.
 // ---------------------------------------------------------------------------
 
+/** The supervisor's multiplexed hub-log shape (supervisor.ts pipeOutput). */
+const INTERLEAVED_HUB_LOG =
+  "[vault] vault boot\n" +
+  "[scribe] scribe boot\n" +
+  "[vault] GET /vault/default/api/notes 200 7ms\n" +
+  "[surface] [app-dcr] client registered\n" +
+  "[vaultx] not vault's line\n" +
+  "[vault] sync ok\n";
+
+const VAULT_LINES_STRIPPED = ["vault boot", "GET /vault/default/api/notes 200 7ms", "sync ok"];
+
+function writeHubLog(configDir: string, content: string): string {
+  const path = ensureLogPath("hub", configDir);
+  writeFileSync(path, content);
+  return path;
+}
+
+/** Backdate a file's mtime so freshness comparisons are deterministic. */
+function backdate(path: string, secondsAgo: number): void {
+  const t = new Date(Date.now() - secondsAgo * 1000);
+  utimesSync(path, t, t);
+}
+
 describe("parachute logs", () => {
   test("hint when no log file exists", async () => {
     const h = makeHarness();
@@ -829,4 +856,212 @@ describe("parachute logs", () => {
       h.cleanup();
     }
   });
+
+  // ---- hub#652: supervised modules read the hub log's [svc]-prefixed stream ----
+
+  test("supervised module: reads the hub log filtered to its prefix, stripped (hub#652)", async () => {
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      writeHubLog(h.configDir, INTERLEAVED_HUB_LOG);
+      // No per-service vault.log — the supervised steady state.
+      const log: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        log: (l) => log.push(l),
+      });
+      expect(code).toBe(0);
+      // Exact-prefix match: `[vaultx]` noise excluded; `[vault] ` stripped.
+      expect(log).toEqual(VAULT_LINES_STRIPPED);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("stale per-service file + fresher hub log: the hub stream wins (the live hub#652 shape)", async () => {
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      const legacy = ensureLogPath("vault", h.configDir);
+      writeFileSync(legacy, "stale pre-cutover line\n");
+      backdate(legacy, 3600);
+      writeHubLog(h.configDir, INTERLEAVED_HUB_LOG);
+      const log: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        log: (l) => log.push(l),
+      });
+      expect(code).toBe(0);
+      expect(log).toEqual(VAULT_LINES_STRIPPED);
+      expect(log.join("\n")).not.toContain("stale pre-cutover line");
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("per-service file fresher than the hub log: legacy file wins (pre-supervised install)", async () => {
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      const hubLog = writeHubLog(h.configDir, "[vault] old supervised line\n");
+      backdate(hubLog, 3600);
+      const legacy = ensureLogPath("vault", h.configDir);
+      writeFileSync(legacy, "live detached line\n");
+      const log: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        log: (l) => log.push(l),
+      });
+      expect(code).toBe(0);
+      expect(log).toEqual(["live detached line"]);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("lines cap applies to the FILTERED set, not raw hub-log lines", async () => {
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      writeHubLog(h.configDir, INTERLEAVED_HUB_LOG);
+      const log: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        lines: 2,
+        log: (l) => log.push(l),
+      });
+      expect(code).toBe(0);
+      expect(log).toEqual(VAULT_LINES_STRIPPED.slice(-2));
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("hub log has no lines for the service + no per-service file: start hint", async () => {
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      writeHubLog(h.configDir, "[scribe] scribe boot\n");
+      const log: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        log: (l) => log.push(l),
+      });
+      expect(code).toBe(0);
+      expect(log.join("\n")).toMatch(/no logs yet for vault/);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("hub log has no lines for the service + per-service file exists: legacy shown with a note", async () => {
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      const legacy = ensureLogPath("vault", h.configDir);
+      writeFileSync(legacy, "old detached line\n");
+      backdate(legacy, 3600);
+      writeHubLog(h.configDir, "[scribe] scribe boot\n");
+      const log: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        log: (l) => log.push(l),
+      });
+      expect(code).toBe(0);
+      // The note distinguishes the stale per-service file from the live
+      // stream — the exact "stale logs presented as current" trap in hub#652.
+      expect(log[0]).toMatch(/no vault lines in the hub log/);
+      expect(log).toContain("old detached line");
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("follow mode filters the hub stream and strips the prefix (hub#652)", async () => {
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      writeHubLog(h.configDir, INTERLEAVED_HUB_LOG);
+      const encoder = new TextEncoder();
+      let streamedPath: string | undefined;
+      const followStream = (path: string): ReadableStream<Uint8Array> => {
+        streamedPath = path;
+        return new ReadableStream<Uint8Array>({
+          start(controller) {
+            controller.enqueue(encoder.encode("[vault] live one\n[scribe] noise\n"));
+            // Split a line across chunks to exercise the line buffer.
+            controller.enqueue(encoder.encode("[vault] live "));
+            controller.enqueue(encoder.encode("two\n"));
+            controller.close();
+          },
+        });
+      };
+      const log: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        follow: true,
+        followStream,
+        log: (l) => log.push(l),
+      });
+      expect(code).toBe(0);
+      expect(streamedPath).toContain("hub.log");
+      expect(log).toEqual([...VAULT_LINES_STRIPPED, "live one", "live two"]);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("follow mode with a fresher per-service file tails THAT file via tail -f", async () => {
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      const hubLog = writeHubLog(h.configDir, "[vault] old supervised line\n");
+      backdate(hubLog, 3600);
+      const legacy = ensureLogPath("vault", h.configDir);
+      writeFileSync(legacy, "live detached line\n");
+      const spawned: string[][] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        follow: true,
+        tailSpawner: {
+          spawn(cmd) {
+            spawned.push([...cmd]);
+            return 12345;
+          },
+        },
+        log: () => {},
+      });
+      expect(code).toBe(0);
+      expect(spawned).toHaveLength(1);
+      expect(spawned[0]?.[0]).toBe("tail");
+      expect(spawned[0]?.at(-1)).toBe(legacy);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("logs hub: stays unfiltered — module-prefixed lines included", async () => {
+    const h = makeHarness();
+    try {
+      writeHubLog(h.configDir, INTERLEAVED_HUB_LOG);
+      const log: string[] = [];
+      const code = await logs("hub", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        log: (l) => log.push(l),
+      });
+      expect(code).toBe(0);
+      expect(log).toEqual(INTERLEAVED_HUB_LOG.replace(/\n$/, "").split("\n"));
+    } finally {
+      h.cleanup();
+    }
+  });
 });

package/src/__tests__/migrate.test.ts

@@ -56,7 +56,7 @@ describe("safelistEntries", () => {
     expect(s.has("vault")).toBe(true);
     expect(s.has("notes")).toBe(true);
     expect(s.has("scribe")).toBe(true);
-    expect(s.has("channel")).toBe(true);
+    expect(s.has("agent")).toBe(true);
     // Internal
     expect(s.has("hub")).toBe(true);
     // CLI state

package/src/__tests__/module-manifest.test.ts

@@ -40,13 +40,13 @@ describe("validateModuleManifest", () => {
             key: "link-to-vault",
             title: "Link a channel to a vault",
             description: "Back a channel with a vault.",
-            requestedBy: "channel",
+            requestedBy: "agent",
             source: {
               module: "vault",
               event: "note.created",
-              filter: { tags: ["#channel-message/inbound"] },
+              filter: { tags: ["#agent-message/inbound"] },
             },
-            sink: { module: "channel", action: "message.deliver" },
+            sink: { module: "agent", action: "message.deliver" },
             parameters: [
               { key: "vault", target: "source.vault", title: "Vault" },
               { key: "channel", target: "sink.params.channel", example: "eng" },
@@ -61,9 +61,9 @@ describe("validateModuleManifest", () => {
     expect(t?.source).toEqual({
       module: "vault",
       event: "note.created",
-      filter: { tags: ["#channel-message/inbound"] },
+      filter: { tags: ["#agent-message/inbound"] },
     });
-    expect(t?.sink).toEqual({ module: "channel", action: "message.deliver" });
+    expect(t?.sink).toEqual({ module: "agent", action: "message.deliver" });
     expect(t?.parameters?.[1]).toEqual({
       key: "channel",
       target: "sink.params.channel",
@@ -119,7 +119,7 @@ describe("validateModuleManifest", () => {
               key: "k",
               title: "T",
               source: { module: "vault", event: "note.created" },
-              sink: { module: "channel", action: "message.deliver" },
+              sink: { module: "agent", action: "message.deliver" },
               parameters: [{ key: "p" }],
             },
           ],
@@ -417,24 +417,24 @@ describe("validateModuleManifest", () => {
         "x",
       ),
     ).toThrow(/must be namespaced as "<name>:<verb>"/);
-    // A matching-namespace scope still validates — the real channel case
-    // (channel.message.deliver → channel:send).
+    // A matching-namespace scope still validates — the real agent case
+    // (message.deliver → agent:send).
     const okm = validateModuleManifest(
       {
         ...VALID,
-        name: "channel",
+        name: "agent",
         actions: [
           {
             key: "message.deliver",
             title: "Deliver",
             endpoint: "/api/vault/inbound",
-            scope: "channel:send",
+            scope: "agent:send",
           },
         ],
       },
       "x",
     );
-    expect(okm.actions?.[0]?.scope).toBe("channel:send");
+    expect(okm.actions?.[0]?.scope).toBe("agent:send");
   });
 
   test("uiUrl accepts a leading-slash path (Phase D)", () => {