@powerhousedao/switchboard 6.2.3-dev.8 → 6.2.3-staging.0

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");
+  });
+});

package/test/fatal-shutdown.test.ts

@@ -0,0 +1,102 @@
+import { EventEmitter } from "node:events";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { installFatalErrorShutdown } from "../src/fatal-shutdown.mjs";
+
+function makeProc() {
+  const emitter = new EventEmitter();
+  const proc = Object.assign(emitter, {
+    pid: 1234,
+    exitCode: undefined as number | undefined,
+    kill: vi.fn((_pid: number, signal: string) => {
+      emitter.emit(signal);
+      return true;
+    }),
+    exit: vi.fn(),
+  });
+  return proc;
+}
+
+const logger = {
+  error: vi.fn(),
+} as unknown as Parameters<typeof installFatalErrorShutdown>[0];
+
+describe("installFatalErrorShutdown", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it.each(["uncaughtException", "unhandledRejection"])(
+    "routes %s through SIGTERM with exit code 1",
+    (event) => {
+      const proc = makeProc();
+      const onSigterm = vi.fn();
+      proc.on("SIGTERM", onSigterm);
+      installFatalErrorShutdown(logger, proc as never);
+
+      proc.emit(event, new Error("boom"));
+
+      expect(proc.kill).toHaveBeenCalledWith(1234, "SIGTERM");
+      expect(onSigterm).toHaveBeenCalledOnce();
+      expect(proc.exitCode).toBe(1);
+      expect(proc.exit).not.toHaveBeenCalled();
+    },
+  );
+
+  it("leaves an unhandled rejection to another listener, such as Sentry's", () => {
+    const proc = makeProc();
+    const other = vi.fn();
+    proc.on("unhandledRejection", other);
+    installFatalErrorShutdown(logger, proc as never);
+
+    proc.emit("unhandledRejection", new Error("boom"));
+
+    expect(other).toHaveBeenCalledOnce();
+    expect(proc.kill).not.toHaveBeenCalled();
+    expect(proc.exitCode).toBeUndefined();
+  });
+
+  it("still shuts down on an uncaught exception when another listener exists", () => {
+    const proc = makeProc();
+    proc.on("uncaughtException", vi.fn());
+    installFatalErrorShutdown(logger, proc as never);
+
+    proc.emit("uncaughtException", new Error("boom"));
+
+    expect(proc.kill).toHaveBeenCalledWith(1234, "SIGTERM");
+    expect(proc.exitCode).toBe(1);
+  });
+
+  it("signals once when a second fatal error arrives during shutdown", () => {
+    const proc = makeProc();
+    installFatalErrorShutdown(logger, proc as never);
+
+    proc.emit("unhandledRejection", new Error("first"));
+    proc.emit("uncaughtException", new Error("second"));
+
+    expect(proc.kill).toHaveBeenCalledOnce();
+  });
+
+  it("forces exit 1 through the original exit when shutdown hangs", () => {
+    vi.useFakeTimers();
+    const proc = makeProc();
+    const originalExit = proc.exit;
+    installFatalErrorShutdown(logger, proc as never);
+    // The builder swaps process.exit for a recording shim during shutdown.
+    proc.exit = vi.fn();
+
+    proc.emit("unhandledRejection", new Error("boom"));
+    vi.advanceTimersByTime(15_000);
+
+    expect(originalExit).toHaveBeenCalledWith(1);
+    expect(proc.exit).not.toHaveBeenCalled();
+  });
+
+  it("installs its listeners once per process", () => {
+    const proc = makeProc();
+    installFatalErrorShutdown(logger, proc as never);
+    installFatalErrorShutdown(logger, proc as never);
+
+    expect(proc.listenerCount("uncaughtException")).toBe(1);
+    expect(proc.listenerCount("unhandledRejection")).toBe(1);
+  });
+});

package/test/mcp-flag.test.ts

@@ -0,0 +1,56 @@
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+import { initFeatureFlags } from "../src/feature-flags.js";
+import { MCP_ENABLED, resolveMcpEnabled } from "../src/mcp-flag.mjs";
+import type { BooleanFlagSource } from "../src/workflow-runtime.mjs";
+
+describe("resolveMcpEnabled", () => {
+  let featureFlags: BooleanFlagSource;
+
+  beforeAll(async () => {
+    featureFlags = await initFeatureFlags();
+  });
+
+  afterEach(() => {
+    delete process.env[MCP_ENABLED];
+  });
+
+  it("defaults to on", async () => {
+    await expect(resolveMcpEnabled({ featureFlags })).resolves.toBe(true);
+    await expect(
+      resolveMcpEnabled({ featureFlags, option: true }),
+    ).resolves.toBe(true);
+  });
+
+  it('is turned off by MCP_ENABLED="false"', async () => {
+    process.env[MCP_ENABLED] = "false";
+
+    await expect(resolveMcpEnabled({ featureFlags })).resolves.toBe(false);
+  });
+
+  // `ph vetra` passes `mcp: true` explicitly; the env var still wins.
+  it("turns off a host that asked for MCP", async () => {
+    process.env[MCP_ENABLED] = "false";
+
+    await expect(
+      resolveMcpEnabled({ featureFlags, option: true }),
+    ).resolves.toBe(false);
+  });
+
+  it("never turns on a host that switched MCP off", async () => {
+    process.env[MCP_ENABLED] = "true";
+
+    await expect(
+      resolveMcpEnabled({ featureFlags, option: false }),
+    ).resolves.toBe(false);
+  });
+
+  it("leaves MCP on for any value but the string false", async () => {
+    for (const raw of ["true", "0", "no", ""]) {
+      process.env[MCP_ENABLED] = raw;
+      await expect(
+        resolveMcpEnabled({ featureFlags }),
+        `MCP_ENABLED=${JSON.stringify(raw)}`,
+      ).resolves.toBe(true);
+    }
+  });
+});

package/test/renown-trust-policy.test.ts

@@ -0,0 +1,315 @@
+import type {
+  ActionSigner,
+  ISigner,
+} from "@powerhousedao/shared/document-model";
+import {
+  ReactorBuilder,
+  ReactorClientBuilder,
+  type SignatureTrustPolicy,
+} from "@powerhousedao/reactor";
+import type { IRenown } from "@renown/sdk/node";
+import { existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { applySwitchboardReactorDefaults } from "../src/builder-defaults.mjs";
+import {
+  assertWorkerTrustPolicy,
+  getRenownTrustPolicyConfig,
+} from "../src/renown.js";
+
+const WALLET = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+const CONNECT_KEY = "did:key:zDnaeConnectKey";
+const SWITCHBOARD_KEY = "did:key:zDnaeSwitchboardKey";
+const SWITCHBOARD_USER = {
+  address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+  networkId: "eip155",
+  chainId: 1,
+};
+const GRAPHQL = "http://renown.test/graphql";
+
+// Signed by WALLET's Anvil dev key; its expiry is ignored by the policy.
+const CREDENTIAL_ROW = {
+  documentId: "doc-cred",
+  credentialId: "urn:uuid:c7882913-68ef-48e5-9e89-f2948d2ca22c",
+  context: ["https://www.w3.org/2018/credentials/v1"],
+  type: ["VerifiableCredential", "RenownCredential"],
+  issuerId: "did:pkh:eip155:1:0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+  issuerEthereumAddress: WALLET,
+  issuanceDate: "2026-09-24T00:48:25.566Z",
+  expirationDate: "2026-10-01T00:48:25.566Z",
+  credentialSubjectId: CONNECT_KEY,
+  credentialSubjectApp: "connect",
+  credentialStatusId: null,
+  credentialStatusType: null,
+  credentialSchemaId: "https://renown.id/schemas/renown-credential/v1",
+  credentialSchemaType: "JsonSchemaValidator2018",
+  proofVerificationMethod:
+    "did:pkh:eip155:1:0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+  proofEthereumAddress: WALLET,
+  proofCreated: "2026-09-24T00:48:25.566Z",
+  proofPurpose: "assertionMethod",
+  proofType: "EthereumEip712Signature2021",
+  proofValue:
+    "0xe8d7a2468b9eb21286483fd88601d350ac7a8ed908506e51a34c6b119f93a7d75c6284a3f231698f6fcc8a3ad0ec5096a34811c7b6adef2d1e4146ddb22826a91c",
+  proofEip712Domain: JSON.stringify({ version: "1", chainId: 1 }),
+  proofEip712PrimaryType: "VerifiableCredential",
+  revoked: false,
+};
+
+function stubRenown(user: ActionSigner["user"] = SWITCHBOARD_USER): IRenown {
+  const signer = {
+    user,
+    app: { name: "switchboard", key: SWITCHBOARD_KEY },
+  } as unknown as ISigner;
+  return { signer } as unknown as IRenown;
+}
+
+function claim(address: string, key: string): ActionSigner {
+  return {
+    user: { address, networkId: "eip155", chainId: 1 },
+    app: { name: "connect", key },
+    signatures: [],
+  };
+}
+
+/** Answers the renown read model with `rows`; counts the requests. */
+function mockReadModel(rows: unknown[] = [CREDENTIAL_ROW]) {
+  return vi.spyOn(globalThis, "fetch").mockImplementation(() =>
+    Promise.resolve(
+      new Response(JSON.stringify({ data: { renownCredentials: rows } }), {
+        status: 200,
+      }),
+    ),
+  );
+}
+
+async function remotePolicy(
+  renown = stubRenown(),
+): Promise<SignatureTrustPolicy> {
+  const { trustPolicy } = await getRenownTrustPolicyConfig(
+    { source: "remote", switchboardUrl: GRAPHQL },
+    renown,
+  );
+  return trustPolicy!;
+}
+
+describe("getRenownTrustPolicyConfig", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it("accepts a key a credential binds to the claimed wallet", async () => {
+    const fetchMock = mockReadModel();
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).resolves.toBe(true);
+    expect(fetchMock.mock.calls[0][0]).toBe(GRAPHQL);
+  });
+
+  it("refuses a mismatched address or key", async () => {
+    mockReadModel();
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(
+        claim(SWITCHBOARD_USER.address, CONNECT_KEY),
+        CONNECT_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(false);
+    await expect(
+      policy.authorizeSigner(
+        claim(WALLET, "did:key:zDnaeOther"),
+        "did:key:zDnaeOther",
+        "doc",
+      ),
+    ).resolves.toBe(false);
+  });
+
+  it("refuses a key no credential binds yet", async () => {
+    const fetchMock = mockReadModel([]);
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).resolves.toBe(false);
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).resolves.toBe(false);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("caches an acceptance per (address, key)", async () => {
+    const fetchMock = mockReadModel();
+    const policy = await remotePolicy();
+    const signer = claim(WALLET, CONNECT_KEY);
+
+    await policy.authorizeSigner(signer, CONNECT_KEY, "doc-1");
+    fetchMock.mockRejectedValue(new TypeError("offline"));
+
+    await expect(
+      policy.authorizeSigner(signer, CONNECT_KEY, "doc-2"),
+    ).resolves.toBe(true);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("throws on a network failure rather than refusing", async () => {
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new TypeError("offline"));
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).rejects.toThrow("offline");
+  });
+
+  it("accepts the switchboard's own key for its own user without a lookup", async () => {
+    const fetchMock = mockReadModel([]);
+    const policy = await remotePolicy();
+
+    await expect(
+      policy.authorizeSigner(
+        claim(SWITCHBOARD_USER.address, SWITCHBOARD_KEY),
+        SWITCHBOARD_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(true);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("matches the switchboard's own key against its current user", async () => {
+    const fetchMock = mockReadModel([]);
+    const renown = stubRenown();
+    const policy = await remotePolicy(renown);
+
+    renown.signer.user = { address: WALLET, networkId: "eip155", chainId: 1 };
+
+    await expect(
+      policy.authorizeSigner(
+        claim(WALLET, SWITCHBOARD_KEY),
+        SWITCHBOARD_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(true);
+    expect(fetchMock).not.toHaveBeenCalled();
+    await expect(
+      policy.authorizeSigner(
+        claim(SWITCHBOARD_USER.address, SWITCHBOARD_KEY),
+        SWITCHBOARD_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(false);
+  });
+
+  it("gives pooled workers a spec that builds the same policy", async () => {
+    const fetchMock = mockReadModel();
+    const { workerTrustPolicy } = await getRenownTrustPolicyConfig(
+      { source: "remote", switchboardUrl: GRAPHQL },
+      stubRenown(),
+    );
+
+    const module = workerTrustPolicy!.module;
+    expect(module.exportName).toBe("createRenownTrustPolicy");
+    const filePath = "filePath" in module ? module.filePath : "";
+    expect(existsSync(filePath)).toBe(true);
+    expect(workerTrustPolicy!.initArgs).toEqual({
+      switchboard: GRAPHQL,
+      self: { key: SWITCHBOARD_KEY, user: SWITCHBOARD_USER },
+    });
+
+    const imported = (await import(pathToFileURL(filePath).href)) as Record<
+      string,
+      (args: unknown) => SignatureTrustPolicy
+    >;
+    const policy = imported[module.exportName](workerTrustPolicy!.initArgs);
+    await expect(
+      policy.authorizeSigner(claim(WALLET, CONNECT_KEY), CONNECT_KEY, "doc"),
+    ).resolves.toBe(true);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("reads a self source in process and gives workers no spec", async () => {
+    const request = vi.fn(() =>
+      Promise.resolve({ renownCredentials: [CREDENTIAL_ROW] }),
+    );
+    const config = await getRenownTrustPolicyConfig(
+      { source: "self", request },
+      null,
+    );
+
+    expect(config.workerTrustPolicy).toBeUndefined();
+    await expect(
+      config.trustPolicy!.authorizeSigner(
+        claim(WALLET, CONNECT_KEY),
+        CONNECT_KEY,
+        "doc",
+      ),
+    ).resolves.toBe(true);
+    expect(request).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("assertWorkerTrustPolicy", () => {
+  it("fails with workers, authEnforcement and a self source", () => {
+    expect(() =>
+      assertWorkerTrustPolicy({
+        workers: 2,
+        authEnforcement: true,
+        renownSource: "self",
+      }),
+    ).toThrow(
+      /REACTOR_WORKERS[\s\S]*REACTOR_AUTH_ENFORCEMENT[\s\S]*RENOWN_SOURCE/,
+    );
+  });
+
+  it.each([
+    { workers: 0, authEnforcement: true, renownSource: "self" as const },
+    { workers: 2, authEnforcement: false, renownSource: "self" as const },
+    { workers: 2, authEnforcement: true, renownSource: "remote" as const },
+  ])("passes %o", (config) => {
+    expect(() => assertWorkerTrustPolicy(config)).not.toThrow();
+  });
+});
+
+describe("applySwitchboardReactorDefaults with a trust policy", () => {
+  it("gives the reactor the policy and its worker spec", () => {
+    const reactorBuilder = new ReactorBuilder();
+    const withTrustPolicy = vi.spyOn(reactorBuilder, "withTrustPolicy");
+    const trustPolicy: SignatureTrustPolicy = {
+      authorizeSigner: () => Promise.resolve(true),
+    };
+    const workerTrustPolicy = {
+      module: { filePath: "/trust.js", exportName: "createTrustPolicy" },
+    };
+
+    applySwitchboardReactorDefaults(
+      reactorBuilder,
+      new ReactorClientBuilder(),
+      {
+        includeBaseModels: false,
+        signalHandlers: false,
+        trustPolicy: { trustPolicy, workerTrustPolicy },
+      },
+    );
+
+    expect(withTrustPolicy).toHaveBeenCalledWith(
+      trustPolicy,
+      workerTrustPolicy,
+    );
+    expect(reactorBuilder.hasTrustPolicy()).toBe(true);
+  });
+
+  it("leaves the reactor on the default without one", () => {
+    const reactorBuilder = new ReactorBuilder();
+
+    applySwitchboardReactorDefaults(
+      reactorBuilder,
+      new ReactorClientBuilder(),
+      {
+        includeBaseModels: false,
+        signalHandlers: false,
+      },
+    );
+
+    expect(reactorBuilder.hasTrustPolicy()).toBe(false);
+  });
+});

package/test/unsupported-stored-documents.test.ts

@@ -0,0 +1,72 @@
+import { UnsupportedStoredProtocolError } from "@powerhousedao/reactor";
+import { describe, expect, it } from "vitest";
+import {
+  StoredDocumentsRefusedError,
+  resolveUnsupportedStoredDocuments,
+} from "../src/unsupported-stored-documents.mjs";
+
+describe("resolveUnsupportedStoredDocuments", () => {
+  it("refuses by default", () => {
+    expect(resolveUnsupportedStoredDocuments(undefined, {})).toBe("refuse");
+    expect(
+      resolveUnsupportedStoredDocuments(undefined, {
+        REACTOR_UNSUPPORTED_STORED_DOCUMENTS: " ",
+      }),
+    ).toBe("refuse");
+  });
+
+  it("reads REACTOR_UNSUPPORTED_STORED_DOCUMENTS", () => {
+    expect(
+      resolveUnsupportedStoredDocuments(undefined, {
+        REACTOR_UNSUPPORTED_STORED_DOCUMENTS: " read-only ",
+      }),
+    ).toBe("read-only");
+    expect(
+      resolveUnsupportedStoredDocuments(undefined, {
+        REACTOR_UNSUPPORTED_STORED_DOCUMENTS: "refuse",
+      }),
+    ).toBe("refuse");
+  });
+
+  it("lets the option win over the env var", () => {
+    expect(
+      resolveUnsupportedStoredDocuments("refuse", {
+        REACTOR_UNSUPPORTED_STORED_DOCUMENTS: "read-only",
+      }),
+    ).toBe("refuse");
+  });
+
+  it("refuses an unknown value", () => {
+    expect(() =>
+      resolveUnsupportedStoredDocuments(undefined, {
+        REACTOR_UNSUPPORTED_STORED_DOCUMENTS: "readonly",
+      }),
+    ).toThrow(
+      'REACTOR_UNSUPPORTED_STORED_DOCUMENTS must be "refuse" or "read-only", got "readonly"',
+    );
+  });
+});
+
+describe("StoredDocumentsRefusedError", () => {
+  it("names the versions, the count and both ways forward", () => {
+    const cause = new UnsupportedStoredProtocolError(
+      [
+        { protocol: "base-reducer", version: 3 },
+        { protocol: "base-reducer", version: 7 },
+      ],
+      4,
+    );
+
+    const error = new StoredDocumentsRefusedError(cause);
+
+    expect(error.message).toBe(
+      "Refusing to start: 4 stored document(s) require base-reducer 3, base-reducer 7, which this switchboard does not run. " +
+        "Either start a switchboard build that runs base-reducer 3, base-reducer 7, or set REACTOR_UNSUPPORTED_STORED_DOCUMENTS=read-only to start with those documents read-only.",
+    );
+    expect(error.documents).toBe(4);
+    expect(error.versions).toBe(cause.versions);
+    expect(error.cause).toBe(cause);
+    expect(StoredDocumentsRefusedError.isError(error)).toBe(true);
+    expect(StoredDocumentsRefusedError.isError(cause)).toBe(false);
+  });
+});