@powerhousedao/switchboard 6.2.3-dev.5 → 6.2.3-dev.50

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/snapshot-writer.ts

@@ -0,0 +1,94 @@
+// Test-only v1 snapshot.bin writer over a loose on-disk tree.
+import { promises as fs } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import path from "node:path";
+
+const MAGIC = new Uint8Array([0x50, 0x47, 0x4c, 0x41]);
+const FORMAT_VERSION = 1;
+const HEADER_SIZE = 12;
+const ENTRY_PREFIX_SIZE = 9;
+const DEFAULT_SKIP = ["snapshot.bin", "snapshot.bin.tmp"];
+
+export interface SnapshotEntry {
+  type: 0 | 1;
+  mode: number;
+  relPath: string;
+  data?: Buffer;
+}
+
+export interface WriteSnapshotOptions {
+  /** Root-level names to leave out. Defaults to the snapshot files. */
+  skip?: string[];
+}
+
+export async function collectDiskEntries(
+  dataDir: string,
+  options: WriteSnapshotOptions = {},
+): Promise<SnapshotEntry[]> {
+  const skip = new Set(options.skip ?? DEFAULT_SKIP);
+  const entries: SnapshotEntry[] = [];
+  const walk = async (dir: string, rel: string) => {
+    const names = (await fs.readdir(dir)).sort();
+    for (const name of names) {
+      if (rel === "" && skip.has(name)) continue;
+      const full = path.join(dir, name);
+      const relPath = rel === "" ? name : `${rel}/${name}`;
+      const stat = await fs.lstat(full);
+      if (stat.isDirectory()) {
+        entries.push({ type: 0, mode: stat.mode & 0o7777, relPath });
+        await walk(full, relPath);
+      } else if (stat.isFile()) {
+        entries.push({
+          type: 1,
+          mode: stat.mode & 0o7777,
+          relPath,
+          data: await fs.readFile(full),
+        });
+      }
+    }
+  };
+  await walk(dataDir, "");
+  return entries;
+}
+
+export function encodeSnapshot(entries: SnapshotEntry[]): Buffer {
+  const encoder = new TextEncoder();
+  const parts: Buffer[] = [];
+  const header = Buffer.alloc(HEADER_SIZE);
+  header.set(MAGIC, 0);
+  header.writeUInt32LE(FORMAT_VERSION, 4);
+  header.writeUInt32LE(entries.length, 8);
+  parts.push(header);
+  for (const entry of entries) {
+    const pathBytes = encoder.encode(entry.relPath);
+    const dataLen = entry.data?.byteLength ?? 0;
+    const prefix = Buffer.alloc(ENTRY_PREFIX_SIZE + pathBytes.byteLength + 4);
+    prefix.writeUInt8(entry.type, 0);
+    prefix.writeUInt32LE(entry.mode, 1);
+    prefix.writeUInt32LE(pathBytes.byteLength, 5);
+    prefix.set(pathBytes, ENTRY_PREFIX_SIZE);
+    prefix.writeUInt32LE(dataLen, ENTRY_PREFIX_SIZE + pathBytes.byteLength);
+    parts.push(prefix);
+    if (entry.data && dataLen > 0) parts.push(entry.data);
+  }
+  return Buffer.concat(parts);
+}
+
+/** Serializes `dataDir` into `snapshotPath`. Returns the entry count and size. */
+export async function writeSnapshotFromDir(
+  dataDir: string,
+  snapshotPath: string,
+  options: WriteSnapshotOptions = {},
+): Promise<{ entries: number; bytes: number }> {
+  const entries = await collectDiskEntries(dataDir, options);
+  const bytes = encodeSnapshot(entries);
+  let fh: FileHandle | undefined;
+  try {
+    fh = await fs.open(snapshotPath, "w");
+    await fh.writeFile(bytes);
+    await fh.sync();
+  } finally {
+    await fh?.close();
+  }
+  return { entries: entries.length, bytes: bytes.byteLength };
+}

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

package/test/worker-pool.test.ts

@@ -1,9 +1,12 @@
 import type { ILogger } from "document-model";
-import { existsSync } from "node:fs";
+import { existsSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
 import { describe, expect, it, vi } from "vitest";
 import {
   autoWorkerCount,
   buildWorkerDbConfig,
+  keepImportableSources,
   resolveHostPoolSize,
   resolveWorkerModelSources,
   resolveWorkerPoolOptions,
@@ -264,3 +267,26 @@ describe("resolveWorkerModelSources", () => {
     expect(logger.warn).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("keepImportableSources", () => {
+  it("keeps sources that export a model and drops one that throws or has none", async () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "ph-model-sources-"));
+    const good = path.join(dir, "good.mjs");
+    const broken = path.join(dir, "broken.mjs");
+    const empty = path.join(dir, "empty.mjs");
+    writeFileSync(
+      good,
+      'export const Model = { reducer: () => ({}), documentModel: { global: { id: "test/model" } } };',
+    );
+    writeFileSync(broken, 'throw new Error("stale dist");');
+    // What `ph init` builds for a project with no models yet.
+    writeFileSync(empty, "export {};");
+
+    const kept = await keepImportableSources(
+      [{ filePath: broken }, { filePath: good }, { filePath: empty }],
+      stubLogger(),
+    );
+
+    expect(kept).toEqual([{ filePath: good }]);
+  });
+});