create-ailk 0.23.0 → 0.25.1

package/templates/apps/mcp/__tests__/lib/commerce-claim.test.ts

@@ -1,531 +0,0 @@
-/**
- * Tests for the boot-memoised commerce claim (#5971 spec D2) and the held
- * licence-feature set resolved from the same read (#7136 spec D3).
- *
- * Idiom: the `checkLicense` option — `checkLicense()` is injected, never
- * called for real, so no suite reaches a licence server (NFR-6). Every arm
- * that cannot POSITIVELY establish the claim must resolve to `"unclaimed"`
- * and an empty feature set (NFR-3, fail closed).
- */
-
-import {
-  MCP_CLAIM_MAX_MISSED_REREADS,
-  MCP_CLAIM_REFRESH_MS,
-  initMcpCommerceClaim,
-  mcpCommerceClaim,
-  mcpFeatureGateOverride,
-  mcpHeldFeatures,
-  resetMcpCommerceClaim,
-  startMcpClaimRefresh,
-  __setMcpCommerceClaimForTest,
-  __setMcpFeatureGateForTest,
-  __setMcpHeldFeaturesForTest,
-} from "../../src/lib/commerce-claim.js";
-
-/**
- * The injected licence reader. Typed off `initMcpCommerceClaim`'s own option
- * rather than off `@working-theory/license`, so the stubs below satisfy
- * exactly what the function under test calls — no double assertion needed.
- */
-type CheckLicenseSeam = NonNullable<
-  NonNullable<Parameters<typeof initMcpCommerceClaim>[0]>["checkLicense"]
->;
-
-type LicenseShape = Awaited<ReturnType<CheckLicenseSeam>>;
-
-/** A licence reader that resolves to the given result. */
-function resolving(result: Partial<LicenseShape>): CheckLicenseSeam {
-  return () => Promise.resolve(result as LicenseShape);
-}
-
-/** A licence reader that rejects — the "an exception is a bug" arm. */
-function rejecting(): CheckLicenseSeam {
-  return () => Promise.reject(new Error("boom"));
-}
-
-afterEach(() => {
-  resetMcpCommerceClaim();
-});
-
-describe("initMcpCommerceClaim", () => {
-  it("resolves claimed when features[] carries 'commerce'", async () => {
-    const claim = await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "pro", features: ["commerce"] }),
-    });
-
-    expect(claim).toBe("claimed");
-    expect(mcpCommerceClaim()).toBe("claimed");
-  });
-
-  it("resolves unclaimed when features[] omits 'commerce'", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "pro", features: ["scheduling"] }),
-    });
-
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-  });
-
-  it("resolves unclaimed on a free tier with no features", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "free", features: [] }),
-    });
-
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-  });
-
-  it("resolves unclaimed when the licence is revoked, even carrying the feature", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({
-        tier: "pro",
-        features: ["commerce"],
-        revoked: true,
-      }),
-    });
-
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-  });
-
-  it("resolves unclaimed — never throws — when checkLicense() rejects", async () => {
-    const claim = await initMcpCommerceClaim({
-      checkLicense: rejecting(),
-    });
-
-    expect(claim).toBe("unclaimed");
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-  });
-
-  it("re-resolves and re-memoises on a second call", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "pro", features: ["commerce"] }),
-    });
-    expect(mcpCommerceClaim()).toBe("claimed");
-
-    await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "free", features: [] }),
-    });
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-  });
-});
-
-describe("mcpCommerceClaim — fail-closed initial state", () => {
-  it("is unclaimed before any init", () => {
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-  });
-
-  it("the test injector sets it directly", () => {
-    __setMcpCommerceClaimForTest("claimed");
-    expect(mcpCommerceClaim()).toBe("claimed");
-  });
-});
-
-describe("mcpHeldFeatures — the deployment's feature set, from the same read (#7136)", () => {
-  const FEATURES = ["scheduling", "flows-deliverables", "commerce"] as const;
-
-  it("one checkLicense() call resolves both the commerce claim and the features", async () => {
-    const fake = jest.fn(resolving({ tier: "pro", features: [...FEATURES] }));
-
-    await initMcpCommerceClaim({ checkLicense: fake });
-
-    expect(fake).toHaveBeenCalledTimes(1);
-    expect([...mcpHeldFeatures()].sort()).toEqual([...FEATURES].sort());
-    expect(mcpCommerceClaim()).toBe("claimed");
-  });
-
-  it("is empty before any init", () => {
-    expect(mcpHeldFeatures().size).toBe(0);
-  });
-
-  it("is empty when the licence is revoked, even carrying the features", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({
-        tier: "pro",
-        features: [...FEATURES],
-        revoked: true,
-      }),
-    });
-
-    expect(mcpHeldFeatures().size).toBe(0);
-  });
-
-  it("is empty — never throws — when checkLicense() rejects", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "pro", features: [...FEATURES] }),
-    });
-    await initMcpCommerceClaim({ checkLicense: rejecting() });
-
-    expect(mcpHeldFeatures().size).toBe(0);
-  });
-
-  it("reset empties a populated set and clears the mode override", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "pro", features: [...FEATURES] }),
-    });
-    __setMcpFeatureGateForTest("refuse");
-    expect(mcpFeatureGateOverride()).toBe("refuse");
-
-    resetMcpCommerceClaim();
-
-    expect(mcpHeldFeatures().size).toBe(0);
-    expect(mcpFeatureGateOverride()).toBeUndefined();
-  });
-});
-
-/** A licence reader whose promise never settles — the "one read in flight"
- * probe (#7156 AC-1). */
-function neverResolving(): CheckLicenseSeam {
-  return () => new Promise<LicenseShape>(() => {});
-}
-
-/** A licence reader the test resolves on its own schedule — the "a stale
- * read is discarded" probe (#7156 AC-1). */
-function deferred(): {
-  reader: CheckLicenseSeam;
-  resolve: (result: Partial<LicenseShape>) => void;
-} {
-  let resolveFn!: (value: LicenseShape) => void;
-  const promise = new Promise<LicenseShape>((resolve) => {
-    resolveFn = resolve;
-  });
-  return {
-    reader: () => promise,
-    resolve: (result) => resolveFn(result as LicenseShape),
-  };
-}
-
-describe("startMcpClaimRefresh — bounded re-read (#7156 AC-1)", () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterEach(() => {
-    resetMcpCommerceClaim();
-    jest.useRealTimers();
-  });
-
-  it("the bound is a 5-minute constant", () => {
-    expect(MCP_CLAIM_REFRESH_MS).toBe(300_000);
-  });
-
-  it("re-reads in both directions once the bound elapses", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({
-        tier: "pro",
-        features: ["scheduling", "commerce"],
-      }),
-    });
-
-    let current: Partial<LicenseShape> = {
-      tier: "pro",
-      features: ["scheduling", "commerce"],
-    };
-    const fake = jest.fn<CheckLicenseSeam>(() =>
-      Promise.resolve(current as LicenseShape),
-    );
-    startMcpClaimRefresh({ checkLicense: fake });
-
-    current = { tier: "free", features: [] };
-
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS - 1);
-    expect(fake).not.toHaveBeenCalled();
-    expect([...mcpHeldFeatures()].sort()).toEqual(
-      ["commerce", "scheduling"].sort(),
-    );
-
-    await jest.advanceTimersByTimeAsync(1);
-    expect(fake).toHaveBeenCalledTimes(1);
-    expect(mcpHeldFeatures().size).toBe(0);
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-
-    current = { tier: "pro", features: ["scheduling", "commerce"] };
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
-    expect([...mcpHeldFeatures()].sort()).toEqual(
-      ["commerce", "scheduling"].sort(),
-    );
-    expect(mcpCommerceClaim()).toBe("claimed");
-  });
-
-  it("fails closed on a re-read that reports revoked", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "pro", features: ["commerce"] }),
-    });
-    startMcpClaimRefresh({
-      checkLicense: resolving({
-        tier: "pro",
-        features: ["commerce"],
-        revoked: true,
-      }),
-    });
-
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
-
-    expect(mcpHeldFeatures().size).toBe(0);
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-  });
-
-  it("fails closed on a re-read that rejects, without throwing", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "pro", features: ["commerce"] }),
-    });
-    startMcpClaimRefresh({ checkLicense: rejecting() });
-
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
-
-    expect(mcpHeldFeatures().size).toBe(0);
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-  });
-
-  it("is single-flight — a read that never settles is called once across multiple intervals", async () => {
-    const fake = jest.fn(neverResolving());
-    startMcpClaimRefresh({ checkLicense: fake });
-
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS * 3);
-
-    expect(fake).toHaveBeenCalledTimes(1);
-  });
-
-  it("starting the loop twice replaces the first — only one loop runs", async () => {
-    const fake = jest.fn(resolving({ tier: "free", features: [] }));
-    startMcpClaimRefresh({ checkLicense: fake });
-    startMcpClaimRefresh({ checkLicense: fake });
-
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
-
-    expect(fake).toHaveBeenCalledTimes(1);
-  });
-
-  it("resetMcpCommerceClaim() stops the loop", async () => {
-    const fake = jest.fn(resolving({ tier: "free", features: [] }));
-    startMcpClaimRefresh({ checkLicense: fake });
-
-    resetMcpCommerceClaim();
-
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS * 2);
-
-    expect(fake).not.toHaveBeenCalled();
-  });
-
-  it("a stale read is discarded after a reset and a fresh boot", async () => {
-    const held = deferred();
-    startMcpClaimRefresh({ checkLicense: held.reader });
-
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
-
-    resetMcpCommerceClaim();
-    await initMcpCommerceClaim({
-      checkLicense: resolving({ tier: "pro", features: ["scheduling"] }),
-    });
-
-    held.resolve({ tier: "pro", features: ["scheduling", "commerce"] });
-    await Promise.resolve();
-    await Promise.resolve();
-
-    expect([...mcpHeldFeatures()]).toEqual(["scheduling"]);
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-  });
-
-  it("no stuck in-flight flag survives a reset — a fresh loop re-reads on its first interval", async () => {
-    const never = jest.fn(neverResolving());
-    startMcpClaimRefresh({ checkLicense: never });
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
-    resetMcpCommerceClaim();
-
-    const fake = jest.fn(resolving({ tier: "pro", features: ["commerce"] }));
-    startMcpClaimRefresh({ checkLicense: fake });
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
-
-    expect(fake).toHaveBeenCalledTimes(1);
-    expect(mcpCommerceClaim()).toBe("claimed");
-  });
-
-  it("never holds a process open — the timer is unref'd", () => {
-    const setIntervalSpy = jest.spyOn(global, "setInterval");
-    startMcpClaimRefresh({
-      checkLicense: resolving({ tier: "free", features: [] }),
-    });
-
-    const timer = setIntervalSpy.mock.results[0]?.value as {
-      hasRef(): boolean;
-    };
-    expect(timer.hasRef()).toBe(false);
-
-    setIntervalSpy.mockRestore();
-  });
-});
-
-describe("startMcpClaimRefresh — staleness ceiling (#7315 AC-3, L1)", () => {
-  const BOTH_PLUS_COMMERCE = [
-    "scheduling",
-    "flows-deliverables",
-    "commerce",
-  ] as const;
-
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterEach(() => {
-    resetMcpCommerceClaim();
-    jest.useRealTimers();
-  });
-
-  it("is a 3-interval constant", () => {
-    expect(MCP_CLAIM_MAX_MISSED_REREADS).toBe(3);
-  });
-
-  it("fires at the fourth interval — falls back to no claim, starts a fresh read, and an abandoned read cannot write once recovery has happened", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({
-        tier: "pro",
-        features: [...BOTH_PLUS_COMMERCE],
-      }),
-    });
-
-    let resolveFirst!: (value: LicenseShape) => void;
-    let resolveSecond!: (value: LicenseShape) => void;
-    const first = new Promise<LicenseShape>((resolve) => {
-      resolveFirst = resolve;
-    });
-    const second = new Promise<LicenseShape>((resolve) => {
-      resolveSecond = resolve;
-    });
-    const fake = jest
-      .fn<CheckLicenseSeam>()
-      .mockReturnValueOnce(first)
-      .mockReturnValueOnce(second);
-    startMcpClaimRefresh({ checkLicense: fake });
-
-    // Interval 1 starts the (never-settling, for now) read; intervals 2 and
-    // 3 are misses 1 and 2 — the ceiling has not fired yet.
-    await jest.advanceTimersByTimeAsync(3 * MCP_CLAIM_REFRESH_MS);
-    expect(fake).toHaveBeenCalledTimes(1);
-    expect([...mcpHeldFeatures()].sort()).toEqual(
-      [...BOTH_PLUS_COMMERCE].sort(),
-    );
-    expect(mcpCommerceClaim()).toBe("claimed");
-
-    // Interval 4 — the third miss reaches the ceiling: fall back to no
-    // claim and start a fresh (second) read on the same tick.
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
-    expect(mcpHeldFeatures().size).toBe(0);
-    expect(mcpCommerceClaim()).toBe("unclaimed");
-    expect(fake).toHaveBeenCalledTimes(2);
-
-    // Recovery — the fresh read finishing restores the claim.
-    resolveSecond({
-      tier: "pro",
-      features: [...BOTH_PLUS_COMMERCE],
-    } as LicenseShape);
-    await Promise.resolve();
-    await Promise.resolve();
-    expect([...mcpHeldFeatures()].sort()).toEqual(
-      [...BOTH_PLUS_COMMERCE].sort(),
-    );
-    expect(mcpCommerceClaim()).toBe("claimed");
-
-    // The read the ceiling abandoned resolving afterwards must not write —
-    // it is no longer the most recently started read.
-    resolveFirst({ tier: "pro", features: [] } as LicenseShape);
-    await Promise.resolve();
-    await Promise.resolve();
-    expect([...mcpHeldFeatures()].sort()).toEqual(
-      [...BOTH_PLUS_COMMERCE].sort(),
-    );
-    expect(mcpCommerceClaim()).toBe("claimed");
-  });
-
-  it("resets the missed count when a read finishes, so a merely slow store never reaches the ceiling", async () => {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({
-        tier: "pro",
-        features: [...BOTH_PLUS_COMMERCE],
-      }),
-    });
-
-    const fake = jest.fn<CheckLicenseSeam>(
-      () =>
-        new Promise<LicenseShape>((resolve) => {
-          setTimeout(
-            () =>
-              resolve({
-                tier: "pro",
-                features: [...BOTH_PLUS_COMMERCE],
-              } as LicenseShape),
-            1.5 * MCP_CLAIM_REFRESH_MS,
-          );
-        }),
-    );
-    startMcpClaimRefresh({ checkLicense: fake });
-
-    for (let i = 0; i < 8; i++) {
-      await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
-      expect([...mcpHeldFeatures()].sort()).toEqual(
-        [...BOTH_PLUS_COMMERCE].sort(),
-      );
-      expect(mcpCommerceClaim()).toBe("claimed");
-    }
-  });
-
-  it("the existing single-flight probe stays true at N = 3 (#7156)", async () => {
-    const fake = jest.fn(neverResolving());
-    startMcpClaimRefresh({ checkLicense: fake });
-
-    await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS * 3);
-
-    expect(fake).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("test-only writers throw outside a test run (#7156 AC-3, L2)", () => {
-  const ORIGINAL_NODE_ENV = process.env["NODE_ENV"];
-
-  afterEach(() => {
-    process.env["NODE_ENV"] = "test";
-    resetMcpCommerceClaim();
-    if (ORIGINAL_NODE_ENV === undefined) {
-      delete process.env["NODE_ENV"];
-    } else {
-      process.env["NODE_ENV"] = ORIGINAL_NODE_ENV;
-    }
-  });
-
-  async function establishNonInitialState(): Promise<void> {
-    await initMcpCommerceClaim({
-      checkLicense: resolving({
-        tier: "pro",
-        features: ["scheduling", "commerce"],
-      }),
-    });
-    __setMcpFeatureGateForTest("refuse");
-  }
-
-  it.each(["production", undefined] as const)(
-    "throws without changing state when NODE_ENV is %p",
-    async (nodeEnv) => {
-      await establishNonInitialState();
-      const preClaim = mcpCommerceClaim();
-      const preFeatures = new Set(mcpHeldFeatures());
-      const preGate = mcpFeatureGateOverride();
-
-      if (nodeEnv === undefined) {
-        delete process.env["NODE_ENV"];
-      } else {
-        process.env["NODE_ENV"] = nodeEnv;
-      }
-
-      expect(() => __setMcpCommerceClaimForTest("unclaimed")).toThrow(
-        /__setMcpCommerceClaimForTest/,
-      );
-      expect(() => __setMcpHeldFeaturesForTest([])).toThrow(
-        /__setMcpHeldFeaturesForTest/,
-      );
-      expect(() => __setMcpFeatureGateForTest("warn")).toThrow(
-        /__setMcpFeatureGateForTest/,
-      );
-      expect(() => resetMcpCommerceClaim()).toThrow(/resetMcpCommerceClaim/);
-
-      expect(mcpCommerceClaim()).toBe(preClaim);
-      expect(mcpHeldFeatures()).toEqual(preFeatures);
-      expect(mcpFeatureGateOverride()).toBe(preGate);
-    },
-  );
-});

package/templates/apps/mcp/__tests__/lib/content-adapter-parity.test.ts

@@ -1,65 +0,0 @@
-/**
- * MCP ↔ API content parity through the one resolver (#5805, Epic #5322 C1).
- *
- * `apps/api` resolves its adapter with `resolveContentAdapter()`
- * (`apps/api/src/lib/content-adapter.ts`); after this change `apps/mcp` does
- * too, via `getMcpContentAdapter()`. This test proves the two consumers read
- * the same page for the same slug when pointed at the same content root — the
- * whole point of one-function resolution.
- *
- * It resolves the "API side" by calling `resolveContentAdapter()` directly
- * with the shape `apps/api` passes, rather than importing `apps/api` — an
- * app-to-app import is banned by the architecture boundary. The assertion is
- * deliberately small: this is a proof of one-function resolution, not a second
- * content-contract suite.
- */
-
-import { join, resolve } from "node:path";
-
-import {
-  resolveContentAdapter,
-  resetResolvedContentAdapter,
-} from "@working-theory/content-adapters";
-
-import { resolveLocale } from "../../src/lib/resolve-locale.js";
-import { ailkReadContent } from "../../src/tools/read_content.js";
-
-const REPO_ROOT = resolve(__dirname, "../../../..");
-const CONTENT_ROOT = join(REPO_ROOT, "content");
-
-describe("read_content ↔ apps/api adapter parity (CONTENT_ADAPTER=mdx)", () => {
-  const previous = process.env.CONTENT_ADAPTER;
-
-  beforeEach(() => {
-    process.env.CONTENT_ADAPTER = "mdx";
-    resetResolvedContentAdapter();
-  });
-
-  afterEach(() => {
-    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
-    else process.env.CONTENT_ADAPTER = previous;
-    resetResolvedContentAdapter();
-  });
-
-  it("returns the same title and slug the API's adapter returns", async () => {
-    const viaMcp = await ailkReadContent(
-      { type: "HomePage", slug: "home" },
-      CONTENT_ROOT,
-    );
-
-    // The shape apps/api hands the resolver: a content root and the project's
-    // default locale, no workspaceId. Both sides read `project.yaml` for that
-    // locale, so resolving it once here keeps the two calls comparable.
-    const locale = resolveLocale(undefined);
-    const apiAdapter = resolveContentAdapter({
-      contentRoot: CONTENT_ROOT,
-      defaultLocale: locale,
-    });
-    const viaApi = await apiAdapter.getPageBySlug("HomePage", "home", locale);
-
-    expect(viaMcp).not.toBeNull();
-    expect(viaApi).not.toBeNull();
-    expect(viaMcp!.slug).toBe(viaApi!.slug);
-    expect(viaMcp!.frontmatter.title).toBe(viaApi!.title);
-  });
-});