@powerhousedao/switchboard 6.2.3-dev.9 → 6.2.3

package/test/boot-mcp-enabled.test.ts

@@ -0,0 +1,121 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { createServer } from "node:net";
+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";
+
+// `port: 0` would bind a random port the switchboard does not report back, so
+// the test picks a free one and pins it.
+async function freePort(): Promise<number> {
+  const server = createServer();
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  if (!address || typeof address === "string") throw new Error("no port");
+  return address.port;
+}
+
+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>,
+  mcp: boolean | undefined,
+  run: (
+    switchboard: Awaited<ReturnType<typeof startSwitchboard>>,
+  ) => Promise<void>,
+): Promise<void> {
+  const tempRoot = await mkdtemp(join(tmpdir(), "switchboard-mcp-enabled-"));
+  const names = ["PH_REACTOR_DATABASE_URL", "MCP_ENABLED", ...Object.keys(env)];
+  const previous = names.map((name) => [name, process.env[name]] as const);
+  process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+  delete process.env.MCP_ENABLED;
+  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: await freePort(),
+      strictPort: true,
+      mcp,
+      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 });
+  }
+}
+
+async function postMcp(port: number): Promise<number> {
+  const response = await fetch(`http://127.0.0.1:${port}/mcp`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json, text/event-stream",
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "ping" }),
+  });
+  await response.body?.cancel();
+  return response.status;
+}
+
+describe("booting Switchboard", () => {
+  it("mounts /mcp by default", async () => {
+    await withSwitchboard({}, undefined, async ({ mcpEnabled, port }) => {
+      expect(mcpEnabled).toBe(true);
+      expect(await postMcp(port)).not.toBe(404);
+    });
+  }, 60_000);
+
+  it('leaves /mcp unmounted under MCP_ENABLED="false"', async () => {
+    await withSwitchboard(
+      { MCP_ENABLED: "false" },
+      undefined,
+      async ({ mcpEnabled, port }) => {
+        expect(mcpEnabled).toBe(false);
+        expect(await postMcp(port)).toBe(404);
+      },
+    );
+  }, 60_000);
+
+  it("keeps a host's mcp: false over MCP_ENABLED=true", async () => {
+    await withSwitchboard(
+      { MCP_ENABLED: "true" },
+      false,
+      async ({ mcpEnabled, port }) => {
+        expect(mcpEnabled).toBe(false);
+        expect(await postMcp(port)).toBe(404);
+      },
+    );
+  }, 60_000);
+});

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

@@ -0,0 +1,210 @@
+import { PGlite } from "@electric-sql/pglite";
+import { AtomicNodeFs } from "@powerhousedao/pglite-fs";
+import {
+  JobStatus,
+  ReactorBuilder,
+  type Database,
+} from "@powerhousedao/reactor";
+import { driveDocumentModelModule } from "@powerhousedao/shared/document-drive";
+import {
+  withSignaturePolicy,
+  type PeerCapability,
+} from "@powerhousedao/shared/document-model";
+import type { ILogger } from "document-model";
+import { Kysely } from "kysely";
+import { cp, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from "vitest";
+import { ClosablePGliteDialect } from "../src/pglite-dialect.js";
+import { startSwitchboard } from "../src/server.mjs";
+import { StoredDocumentsRefusedError } from "../src/unsupported-stored-documents.mjs";
+
+const ENV_KEYS = [
+  "PH_REACTOR_DATABASE_URL",
+  "DATABASE_URL",
+  "REACTOR_UNSUPPORTED_STORED_DOCUMENTS",
+] as const;
+
+const BASE_REDUCER_7: PeerCapability = {
+  kind: "protocol",
+  name: "base-reducer",
+  baseline: [1, 2],
+  supported: () => [1, 2, 7],
+  preferred: () => 2,
+  optional: false,
+};
+
+type StubLogger = ILogger & {
+  warn: ReturnType<typeof vi.fn>;
+  error: ReturnType<typeof vi.fn>;
+};
+
+function stubLogger(): StubLogger {
+  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 StubLogger;
+}
+
+/** A reactor store holding one drive created at base-reducer 7. */
+async function seedStore(dir: string): Promise<void> {
+  const db = new Kysely<Database>({
+    dialect: new ClosablePGliteDialect(
+      new PGlite({ fs: new AtomicNodeFs(dir) }),
+    ),
+  });
+  const module = await new ReactorBuilder()
+    .withKysely(db)
+    .withDocumentModelSources([driveDocumentModelModule as never])
+    .withPeerCapabilities([BASE_REDUCER_7])
+    .buildModule();
+  const created = await module.reactor.create(
+    withSignaturePolicy(
+      driveDocumentModelModule.utils.createDocument(),
+      "legacy",
+      {
+        id: "br7-stored",
+        protocolVersions: { "base-reducer": 7 },
+      },
+    ),
+  );
+  await vi.waitUntil(
+    async () => {
+      const { status } = await module.reactor.getJobStatus(created.id);
+      return status === JobStatus.READ_READY || status === JobStatus.FAILED;
+    },
+    { timeout: 10_000, interval: 5 },
+  );
+  expect((await module.reactor.getJobStatus(created.id)).status).toBe(
+    JobStatus.READ_READY,
+  );
+  await module.reactor.kill().completed;
+  await db.destroy();
+}
+
+// PGlite boots are several times slower on Windows runners.
+const BOOT_TIMEOUT = 120_000;
+
+describe("booting over documents this build does not run", () => {
+  let seeded: string;
+  let tempRoot: string;
+  let previous: Partial<Record<(typeof ENV_KEYS)[number], string>>;
+
+  beforeAll(async () => {
+    seeded = await mkdtemp(join(tmpdir(), "switchboard-stored-protocol-seed-"));
+    await seedStore(join(seeded, "reactor-storage"));
+  }, BOOT_TIMEOUT);
+
+  afterAll(async () => {
+    await rm(seeded, { recursive: true, force: true });
+  });
+
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(join(tmpdir(), "switchboard-stored-protocol-"));
+    previous = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
+    process.env.PH_REACTOR_DATABASE_URL = join(tempRoot, "reactor-storage");
+    process.env.DATABASE_URL = join(tempRoot, "read-model");
+    delete process.env.REACTOR_UNSUPPORTED_STORED_DOCUMENTS;
+    await cp(
+      join(seeded, "reactor-storage"),
+      process.env.PH_REACTOR_DATABASE_URL,
+      { recursive: 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(logger: ILogger) {
+    return startSwitchboard({
+      workflows: { enabled: false },
+      port: 0,
+      mcp: false,
+      disableLocalPackages: true,
+      identity: { keypairPath: join(tempRoot, "identity.json") },
+      logger,
+    });
+  }
+
+  it(
+    "refuses by default and tells the operator both ways forward",
+    async () => {
+      const logger = stubLogger();
+
+      const booted = boot(logger);
+
+      await expect(booted).rejects.toSatisfy(
+        (error) =>
+          StoredDocumentsRefusedError.isError(error) &&
+          error.documents === 1 &&
+          error.versions.some(
+            ({ protocol, version }) =>
+              protocol === "base-reducer" && version === 7,
+          ),
+      );
+      const message = (await booted.catch((error: Error) => error)) as Error;
+      expect(message.message).toMatch(
+        /1 stored document\(s\) require base-reducer 7/,
+      );
+      expect(message.message).toMatch(
+        /switchboard build that runs base-reducer 7/,
+      );
+      expect(message.message).toMatch(
+        /REACTOR_UNSUPPORTED_STORED_DOCUMENTS=read-only/,
+      );
+      expect(logger.error).toHaveBeenCalledWith(message.message);
+      expect(logger.error).not.toHaveBeenCalledWith(
+        "App crashed: @error",
+        expect.anything(),
+      );
+    },
+    BOOT_TIMEOUT,
+  );
+
+  it(
+    "starts read-only when REACTOR_UNSUPPORTED_STORED_DOCUMENTS says so",
+    async () => {
+      process.env.REACTOR_UNSUPPORTED_STORED_DOCUMENTS = "read-only";
+      const logger = stubLogger();
+
+      const switchboard = await boot(logger);
+      try {
+        expect(logger.warn).toHaveBeenCalledWith(
+          expect.stringContaining("read-only"),
+          expect.stringContaining(
+            "1 stored document(s) require base-reducer 7",
+          ),
+        );
+        const stored = await switchboard.reactor.get("br7-stored");
+        expect(stored.header.id).toBe("br7-stored");
+      } finally {
+        await switchboard.shutdown();
+      }
+    },
+    BOOT_TIMEOUT,
+  );
+});

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