@powerhousedao/switchboard 6.2.3-dev.23 → 6.2.3-dev.25

package/test/boot-create-signature-policy.test.ts

@@ -0,0 +1,108 @@
+import {
+  hasDerivedDocumentId,
+  isDerivedDocumentId,
+  signaturePolicyOf,
+} from "@powerhousedao/shared/document-model";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ILogger } from "document-model";
+import { describe, expect, it, vi } from "vitest";
+import { startSwitchboard } from "../src/server.mjs";
+
+function stubLogger(): ILogger {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger;
+}
+
+async function withSwitchboard(
+  env: Record<string, string>,
+  run: (
+    switchboard: Awaited<ReturnType<typeof startSwitchboard>>,
+  ) => Promise<void>,
+): Promise<void> {
+  const tempRoot = await mkdtemp(join(tmpdir(), "switchboard-create-policy-"));
+  const names = ["PH_REACTOR_DATABASE_URL", ...Object.keys(env)];
+  const previous = names.map((name) => [name, process.env[name]] as const);
+  process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+  Object.assign(process.env, env);
+  let switchboard: Awaited<ReturnType<typeof startSwitchboard>> | undefined;
+
+  try {
+    switchboard = await startSwitchboard({
+      workflows: { enabled: false },
+      dbPath: join(tempRoot, "read-model"),
+      port: 0,
+      mcp: false,
+      disableLocalPackages: true,
+      identity: { keypairPath: join(tempRoot, "identity.json") },
+      drive: {
+        slug: "default-drive",
+        global: { name: "Default Drive" },
+      },
+      logger: stubLogger(),
+    });
+    await run(switchboard);
+    await switchboard.shutdown();
+    switchboard = undefined;
+  } finally {
+    await switchboard?.shutdown();
+    for (const [name, value] of previous) {
+      if (value === undefined) {
+        delete process.env[name];
+      } else {
+        process.env[name] = value;
+      }
+    }
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+describe("booting Switchboard", () => {
+  it("creates v2-required documents and drives by default", async () => {
+    await withSwitchboard({}, async ({ reactor }) => {
+      const document = await reactor.createEmpty("powerhouse/document-model");
+      expect(signaturePolicyOf(document.header)).toBe("v2-required");
+      expect(hasDerivedDocumentId(document.header)).toBe(true);
+
+      const drive = await reactor.drives.create({ global: { name: "Drive" } });
+      expect(signaturePolicyOf(drive.header)).toBe("v2-required");
+
+      const defaultDrive = await reactor.get("default-drive");
+      expect(signaturePolicyOf(defaultDrive.header)).toBe("v2-required");
+    });
+  }, 60_000);
+
+  it("creates legacy documents and drives under CREATE_SIGNATURE_POLICY=legacy", async () => {
+    await withSwitchboard(
+      { CREATE_SIGNATURE_POLICY: "legacy" },
+      async ({ reactor }) => {
+        const document = await reactor.createEmpty("powerhouse/document-model");
+        expect(signaturePolicyOf(document.header)).toBe("legacy");
+        expect(isDerivedDocumentId(document.header.id)).toBe(false);
+
+        const drive = await reactor.drives.create({
+          global: { name: "Drive" },
+        });
+        expect(signaturePolicyOf(drive.header)).toBe("legacy");
+        expect(isDerivedDocumentId(drive.header.id)).toBe(false);
+
+        const defaultDrive = await reactor.get("default-drive");
+        expect(signaturePolicyOf(defaultDrive.header)).toBe("legacy");
+
+        const asked = await reactor.createEmpty("powerhouse/document-model", {
+          signaturePolicy: "v2-required",
+        });
+        expect(hasDerivedDocumentId(asked.header)).toBe(true);
+      },
+    );
+  }, 60_000);
+});

package/test/boot-without-renown.test.ts

@@ -0,0 +1,81 @@
+import {
+  isDerivedDocumentId,
+  signaturePolicyOf,
+} from "@powerhousedao/shared/document-model";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ILogger } from "document-model";
+import { describe, expect, it, vi } from "vitest";
+import type * as RenownModule from "../src/renown.js";
+import { startSwitchboard } from "../src/server.mjs";
+
+vi.mock("../src/renown.js", async (importOriginal) => ({
+  ...(await importOriginal<typeof RenownModule>()),
+  initRenown: vi.fn().mockRejectedValue(new Error("Renown is unreachable")),
+}));
+
+function stubLogger(): ILogger & { warn: ReturnType<typeof vi.fn> } {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger & { warn: ReturnType<typeof vi.fn> };
+}
+
+describe("booting Switchboard without Renown", () => {
+  it("warns and creates legacy documents, which it can write unsigned", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "switchboard-no-renown-"));
+    const previous = process.env.PH_REACTOR_DATABASE_URL;
+    process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+    const logger = stubLogger();
+    let switchboard: Awaited<ReturnType<typeof startSwitchboard>> | undefined;
+
+    try {
+      switchboard = await startSwitchboard({
+        workflows: { enabled: false },
+        dbPath: join(tempRoot, "read-model"),
+        port: 0,
+        mcp: false,
+        disableLocalPackages: true,
+        logger,
+      });
+
+      expect(
+        logger.warn.mock.calls.some(
+          ([message]) =>
+            typeof message === "string" &&
+            message.includes("new documents are created legacy"),
+        ),
+      ).toBe(true);
+
+      const document = await switchboard.reactor.createEmpty(
+        "powerhouse/document-model",
+      );
+      expect(signaturePolicyOf(document.header)).toBe("legacy");
+      expect(isDerivedDocumentId(document.header.id)).toBe(false);
+
+      const renamed = await switchboard.reactor.rename(
+        document.header.id,
+        "Renamed",
+      );
+      expect(renamed.header.name).toBe("Renamed");
+
+      await switchboard.shutdown();
+      switchboard = undefined;
+    } finally {
+      await switchboard?.shutdown();
+      if (previous === undefined) {
+        delete process.env.PH_REACTOR_DATABASE_URL;
+      } else {
+        process.env.PH_REACTOR_DATABASE_URL = previous;
+      }
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  }, 60_000);
+});

package/test/boot-without-require-signatures.test.ts

@@ -0,0 +1,74 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ILogger } from "document-model";
+import { describe, expect, it, vi } from "vitest";
+import { startSwitchboard } from "../src/server.mjs";
+
+function stubLogger(): ILogger & { info: ReturnType<typeof vi.fn> } {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger & { info: ReturnType<typeof vi.fn> };
+}
+
+describe("booting Switchboard", () => {
+  it("has no REQUIRE_SIGNATURES flag, and ignores the variable", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "switchboard-signatures-"));
+    const previous = {
+      reactorDb: process.env.PH_REACTOR_DATABASE_URL,
+      requireSignatures: process.env.REQUIRE_SIGNATURES,
+    };
+    process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+    process.env.REQUIRE_SIGNATURES = "true";
+    const logger = stubLogger();
+    let switchboard: Awaited<ReturnType<typeof startSwitchboard>> | undefined;
+
+    try {
+      switchboard = await startSwitchboard({
+        workflows: { enabled: false },
+        dbPath: join(tempRoot, "read-model"),
+        port: 0,
+        mcp: false,
+        disableLocalPackages: true,
+        identity: { keypairPath: join(tempRoot, "identity.json") },
+        logger,
+      });
+
+      const flagLog = logger.info.mock.calls.find(
+        ([message]) => message === "Feature flags: @flags",
+      );
+      expect(flagLog).toBeDefined();
+      expect(JSON.parse(flagLog![1] as string)).not.toHaveProperty(
+        "REQUIRE_SIGNATURES",
+      );
+
+      const created = await switchboard.reactor.createEmpty(
+        "powerhouse/document-model",
+      );
+      expect(created.header.id).toBeTruthy();
+
+      await switchboard.shutdown();
+      switchboard = undefined;
+    } finally {
+      await switchboard?.shutdown();
+      for (const [name, value] of [
+        ["PH_REACTOR_DATABASE_URL", previous.reactorDb],
+        ["REQUIRE_SIGNATURES", previous.requireSignatures],
+      ] as const) {
+        if (value === undefined) {
+          delete process.env[name];
+        } else {
+          process.env[name] = value;
+        }
+      }
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  }, 60_000);
+});

package/test/boot-worker-trust-policy.test.ts

@@ -0,0 +1,90 @@
+import type { ILogger } from "document-model";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type * as RenownModule from "../src/renown.js";
+import { startSwitchboard } from "../src/server.mjs";
+
+vi.mock("../src/renown.js", async (importOriginal) => ({
+  ...(await importOriginal<typeof RenownModule>()),
+  initRenown: vi.fn().mockRejectedValue(new Error("Renown is unreachable")),
+}));
+
+const TRUST_FAILURE =
+  /REACTOR_WORKERS[\s\S]*REACTOR_AUTH_ENFORCEMENT[\s\S]*RENOWN_SOURCE/;
+const ENV_KEYS = [
+  "PH_REACTOR_DATABASE_URL",
+  "RENOWN_SOURCE",
+  "REACTOR_DOCUMENT_DECISIONS",
+  "REACTOR_AUTH_ENFORCEMENT",
+] as const;
+
+function stubLogger(): ILogger {
+  const logger = {
+    verbose: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger as unknown as ILogger;
+}
+
+describe("booting with pooled workers under authEnforcement", () => {
+  let tempRoot: string;
+  let previous: Partial<Record<(typeof ENV_KEYS)[number], string>>;
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(join(tmpdir(), "switchboard-worker-trust-"));
+    previous = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+    process.env.REACTOR_DOCUMENT_DECISIONS = "true";
+    process.env.REACTOR_AUTH_ENFORCEMENT = "true";
+  });
+
+  afterEach(async () => {
+    for (const key of ENV_KEYS) {
+      if (previous[key] === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = previous[key];
+      }
+    }
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  function boot(numWorkers: number) {
+    return startSwitchboard({
+      workflows: { enabled: false },
+      dbPath: join(tempRoot, "read-model"),
+      port: 0,
+      mcp: false,
+      disableLocalPackages: true,
+      logger: stubLogger(),
+      workerPool: { numWorkers },
+    });
+  }
+
+  it("fails with a self Renown source", async () => {
+    process.env.RENOWN_SOURCE = "self";
+
+    await expect(boot(2)).rejects.toThrow(TRUST_FAILURE);
+  });
+
+  // Postgres is the next requirement a pooled boot has; reaching it passes the check.
+  it("passes the check with a remote Renown source", async () => {
+    process.env.RENOWN_SOURCE = "remote";
+
+    await expect(boot(2)).rejects.toThrow(/requires a Postgres/);
+  });
+
+  // No loaded package serves the renown read model here; reaching that check passes this one.
+  it("passes the check without workers", async () => {
+    process.env.RENOWN_SOURCE = "self";
+
+    await expect(boot(0)).rejects.toThrow(/no loaded package serves/);
+  }, 60_000);
+});

package/test/builder-defaults.test.ts

@@ -0,0 +1,80 @@
+import type { ISigner } from "@powerhousedao/shared/document-model";
+import {
+  ReactorBuilder,
+  ReactorClientBuilder,
+  type FactorySpec,
+} from "@powerhousedao/reactor";
+import type { IRenown } from "@renown/sdk/node";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { applySwitchboardReactorDefaults } from "../src/builder-defaults.mjs";
+import {
+  getRenownSignerConfig,
+  getRenownWorkerSignerSpec,
+} from "../src/renown.js";
+
+const USER = { address: "0xswitchboard", networkId: "eip155", chainId: 1 };
+
+function stubRenown(user = USER): IRenown {
+  const signer = {
+    user,
+    app: { name: "switchboard", key: "did:key:zSwitchboard" },
+  } as unknown as ISigner;
+  return { signer } as unknown as IRenown;
+}
+
+describe("applySwitchboardReactorDefaults", () => {
+  it("gives the reactor the signer and its worker spec", () => {
+    const reactorBuilder = new ReactorBuilder();
+    const clientBuilder = new ReactorClientBuilder();
+    const reactorWithSigner = vi.spyOn(reactorBuilder, "withSigner");
+    const clientWithSigner = vi.spyOn(clientBuilder, "withSigner");
+    const signer = getRenownSignerConfig(stubRenown(), ".ph/key.json");
+
+    applySwitchboardReactorDefaults(reactorBuilder, clientBuilder, {
+      includeBaseModels: false,
+      signalHandlers: false,
+      signer,
+    });
+
+    expect(clientWithSigner).toHaveBeenCalledWith(signer);
+    expect(reactorWithSigner).toHaveBeenCalledWith(
+      signer.signer,
+      signer.workerSigner,
+    );
+    expect(reactorBuilder.hasSigner()).toBe(true);
+  });
+});
+
+describe("getRenownWorkerSignerSpec", () => {
+  it("points workers at createNodeRenownSigner over the stored key", () => {
+    const spec: FactorySpec = getRenownWorkerSignerSpec(
+      stubRenown(),
+      ".ph/key.json",
+    );
+
+    expect(spec.module.exportName).toBe("createNodeRenownSigner");
+    const filePath = "filePath" in spec.module ? spec.module.filePath : "";
+    expect(existsSync(filePath)).toBe(true);
+    expect(spec.initArgs).toEqual({
+      appName: "switchboard",
+      keypairPath: resolve(".ph/key.json"),
+      did: "did:key:zSwitchboard",
+      user: USER,
+    });
+  });
+
+  it("leaves the user out when none is logged in", () => {
+    const renown = stubRenown();
+    (renown.signer as { user?: unknown }).user = undefined;
+
+    const spec = getRenownWorkerSignerSpec(renown);
+
+    expect(spec.initArgs).toEqual({
+      appName: "switchboard",
+      keypairPath: resolve(".ph/.keypair.json"),
+      did: "did:key:zSwitchboard",
+    });
+  });
+});

package/test/create-signature-policy.test.ts

@@ -0,0 +1,69 @@
+import { ReactorBuilder, ReactorClientBuilder } from "@powerhousedao/reactor";
+import { describe, expect, it, vi } from "vitest";
+import { applySwitchboardReactorDefaults } from "../src/builder-defaults.mjs";
+import { resolveCreateSignaturePolicy } from "../src/create-signature-policy.mjs";
+
+describe("resolveCreateSignaturePolicy", () => {
+  it("defaults to v2-required with a signer", () => {
+    expect(resolveCreateSignaturePolicy({}, { hasSigner: true })).toBe(
+      "v2-required",
+    );
+  });
+
+  it("reads CREATE_SIGNATURE_POLICY", () => {
+    expect(
+      resolveCreateSignaturePolicy(
+        { CREATE_SIGNATURE_POLICY: "legacy" },
+        { hasSigner: true },
+      ),
+    ).toBe("legacy");
+    expect(
+      resolveCreateSignaturePolicy(
+        { CREATE_SIGNATURE_POLICY: " v2-required " },
+        { hasSigner: true },
+      ),
+    ).toBe("v2-required");
+  });
+
+  it("refuses an unknown value", () => {
+    expect(() =>
+      resolveCreateSignaturePolicy(
+        { CREATE_SIGNATURE_POLICY: "v2" },
+        { hasSigner: true },
+      ),
+    ).toThrow(/CREATE_SIGNATURE_POLICY/);
+  });
+
+  it("falls back to legacy with a warning when there is no signer", () => {
+    const warn = vi.fn();
+
+    expect(
+      resolveCreateSignaturePolicy({}, { hasSigner: false, logger: { warn } }),
+    ).toBe("legacy");
+    expect(warn).toHaveBeenCalledOnce();
+
+    warn.mockClear();
+    expect(
+      resolveCreateSignaturePolicy(
+        { CREATE_SIGNATURE_POLICY: "legacy" },
+        { hasSigner: false, logger: { warn } },
+      ),
+    ).toBe("legacy");
+    expect(warn).not.toHaveBeenCalled();
+  });
+});
+
+describe("applySwitchboardReactorDefaults", () => {
+  it("hands the creation policy to the client builder", () => {
+    const clientBuilder = new ReactorClientBuilder();
+    const withPolicy = vi.spyOn(clientBuilder, "withCreateSignaturePolicy");
+
+    applySwitchboardReactorDefaults(new ReactorBuilder(), clientBuilder, {
+      includeBaseModels: false,
+      signalHandlers: false,
+      createSignaturePolicy: "legacy",
+    });
+
+    expect(withPolicy).toHaveBeenCalledWith("legacy");
+  });
+});