create-ailk 0.24.0 → 0.26.0

package/templates/apps/mcp/__tests__/index.test.ts

@@ -1,195 +0,0 @@
-/**
- * Structural ordering guard for apps/mcp's bootstrap (#5876 spec D4, AC-3;
- * #7156 AC-1, AC-2; #8070 D2).
- *
- * The boot sequence moved from `src/index.ts` into `bootMcp()` in
- * `src/boot.ts` (#8070), so both entrypoints — `index.ts` (stdio, or HTTP on
- * a port) and `app.ts` (Vercel) — run the same one. The ordering assertions
- * below read `boot.ts`, retargeted from `index.ts`: "before the transport
- * branch" is now "inside `bootMcp()`", and one check on `index.ts` pins that
- * `bootMcp()` itself runs before the transport branch.
- *
- * `index.ts` and `app.ts` await at module level, which ts-jest's CommonJS
- * compile cannot load, so these read source text — the existing
- * "architectural guard" pattern (`__tests__/read_content.test.ts`).
- */
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import vm from "node:vm";
-
-import * as ts from "typescript";
-
-const indexSrc = readFileSync(resolve(__dirname, "../src/index.ts"), "utf-8");
-const bootSrc = readFileSync(resolve(__dirname, "../src/boot.ts"), "utf-8");
-
-/** The text of `bootMcp()` — from its declaration to its closing brace. */
-function bootBody(): string {
-  const start = bootSrc.indexOf("export async function bootMcp(");
-  expect(start).toBeGreaterThan(-1);
-  const end = bootSrc.indexOf("\n}\n", start);
-  expect(end).toBeGreaterThan(start);
-  return bootSrc.slice(start, end + 2);
-}
-
-describe("apps/mcp/src/index.ts — the shared boot runs before the transport (#8070 D2)", () => {
-  it("awaits bootMcp() exactly once, before either transport branch", () => {
-    const calls = [...indexSrc.matchAll(/^await bootMcp\(\);$/gm)];
-    const transportBranchIdx = indexSrc.indexOf('if (transport === "http")');
-
-    expect(calls).toHaveLength(1);
-    expect(transportBranchIdx).toBeGreaterThan(-1);
-    expect(calls[0]!.index!).toBeLessThan(transportBranchIdx);
-  });
-
-  it("the HTTP branch keeps today's stateful default (readStatelessEnv(false))", () => {
-    const transportBranchIdx = indexSrc.indexOf('if (transport === "http")');
-    const readIdx = indexSrc.indexOf("readStatelessEnv(false)");
-
-    expect(readIdx).toBeGreaterThan(transportBranchIdx);
-  });
-});
-
-describe("apps/mcp/src/boot.ts — bootstrap ordering", () => {
-  it("awaits initPublicWorkspace()", () => {
-    expect(bootBody()).toMatch(/await initPublicWorkspace\(\)/);
-  });
-
-  it("wraps the await in try/catch — a rejection (DB down at boot) must not crash the whole server (code review, #5876)", () => {
-    const body = bootBody();
-    const tryIdx = body.indexOf("try {");
-    const initIdx = body.indexOf("await initPublicWorkspace()");
-    const catchIdx = body.indexOf("} catch");
-
-    expect(tryIdx).toBeGreaterThan(-1);
-    expect(catchIdx).toBeGreaterThan(-1);
-    // The await sits strictly between its own try{ and the matching }catch.
-    expect(tryIdx).toBeLessThan(initIdx);
-    expect(initIdx).toBeLessThan(catchIdx);
-  });
-
-  it("runs the five boot steps in today's order", () => {
-    const body = bootBody();
-    const steps = [
-      "await initPublicWorkspace()",
-      "await registerLicenseKeyStore()",
-      "await initMcpCommerceClaim()",
-      "startMcpClaimRefresh();",
-      "reportUnlicensedProTools();",
-    ].map((step) => body.indexOf(step));
-
-    for (const idx of steps) expect(idx).toBeGreaterThan(-1);
-    expect([...steps].sort((a, b) => a - b)).toEqual(steps);
-  });
-});
-
-describe("apps/mcp/src/boot.ts — the claim refresh loop starts in production (#7156 AC-1)", () => {
-  it("starts after the boot read and before bootMcp() returns", () => {
-    const body = bootBody();
-    const initIdx = body.indexOf("await initMcpCommerceClaim()");
-    const callMatches = [...body.matchAll(/^\s*startMcpClaimRefresh\(\);$/gm)];
-
-    expect(initIdx).toBeGreaterThan(-1);
-    expect(callMatches).toHaveLength(1);
-
-    const callIdx = callMatches[0]!.index!;
-    expect(initIdx).toBeLessThan(callIdx);
-  });
-});
-
-describe("apps/mcp/src/boot.ts — the boot warning cannot stop the server (#7156 AC-2, D2)", () => {
-  /**
-   * The exact behavioural slice AC-2 specifies: from the last `try {` before
-   * the `reportUnlicensedProTools();` call statement, up to the end of
-   * `bootMcp()`. Transpiled and run in a fresh vm context so a real throw
-   * from the stubbed function proves the guard, not a mock of the guard
-   * itself.
-   */
-  function guardedSlice(): string {
-    const body = bootBody();
-    const callMatches = [
-      ...body.matchAll(/^\s*reportUnlicensedProTools\(\);$/gm),
-    ];
-    expect(callMatches).toHaveLength(1);
-    const callIdx = callMatches[0]!.index!;
-    const tryIdx = body.lastIndexOf("try {", callIdx);
-    // The closing brace of bootMcp() — the last character of `body`.
-    const endIdx = body.lastIndexOf("}");
-
-    expect(tryIdx).toBeGreaterThan(-1);
-    expect(endIdx).toBeGreaterThan(callIdx);
-
-    const slice = body.slice(tryIdx, endIdx);
-    // The extracted try block must be the one that immediately wraps the
-    // call, not an earlier try{}/await pair (code review, #7156): the two
-    // other try blocks each await a boot call, so a regressed boundary would
-    // carry "await" into the slice. Asserting that here turns a boundary
-    // regression into a clear failure instead of an opaque vm ReferenceError
-    // from the un-injected awaited function.
-    expect(slice).not.toContain("await");
-
-    return slice;
-  }
-
-  function runGuardedSlice(
-    reportUnlicensedProTools: () => unknown,
-    errorSpy: jest.Mock,
-  ): void {
-    const slice = guardedSlice();
-    const { outputText } = ts.transpileModule(slice, {
-      compilerOptions: {
-        module: ts.ModuleKind.CommonJS,
-        target: ts.ScriptTarget.ES2020,
-      },
-    });
-    vm.runInNewContext(outputText, {
-      reportUnlicensedProTools,
-      console: { error: errorSpy },
-    });
-  }
-
-  it("a throw is logged to stderr and does not escape", () => {
-    const errorSpy = jest.fn();
-
-    expect(() =>
-      runGuardedSlice(() => {
-        throw new Error("boom");
-      }, errorSpy),
-    ).not.toThrow();
-
-    expect(errorSpy).toHaveBeenCalledTimes(1);
-    const call = errorSpy.mock.calls[0]!;
-    expect(String(call[0])).toContain("reportUnlicensedProTools");
-    const lastArg = call[call.length - 1];
-    expect(lastArg).toBeInstanceOf(Error);
-    expect((lastArg as Error).message).toBe("boom");
-  });
-
-  it("a successful call is not logged", () => {
-    const errorSpy = jest.fn();
-    const report = jest.fn(() => []);
-
-    runGuardedSlice(report, errorSpy);
-
-    expect(report).toHaveBeenCalledTimes(1);
-    expect(errorSpy).not.toHaveBeenCalled();
-  });
-
-  it("the call statement occurs exactly once, inside bootMcp()", () => {
-    const fileMatches = [
-      ...bootSrc.matchAll(/^\s*reportUnlicensedProTools\(\);$/gm),
-    ];
-    const bodyMatches = [
-      ...bootBody().matchAll(/^\s*reportUnlicensedProTools\(\);$/gm),
-    ];
-
-    expect(fileMatches).toHaveLength(1);
-    expect(bodyMatches).toHaveLength(1);
-  });
-
-  it("logs to stderr only — the guarded slice never writes stdout", () => {
-    const slice = guardedSlice();
-
-    expect(slice).toContain("console.error");
-    expect(slice).not.toContain("console.log");
-  });
-});

package/templates/apps/mcp/__tests__/lib/audit-single-page-readiness-scan.test.ts

@@ -1,191 +0,0 @@
-/**
- * Tests for `scanSitePages` (apps/mcp/src/lib/audit-single-page.ts), exercised
- * through `buildSinglePageAuditInput` with a mocked `ContentAdapter` (#6012,
- * a follow-up from the #6010 review).
- *
- * `scanSitePages` treats two conditions differently, and this file is the
- * test that proves it:
- *
- *   - a type the adapter has no pages of resolves NORMALLY to `[]` — never an
- *     error, never logged. This is the ordinary "site has nothing of this
- *     type" case every real adapter (MDX, database) takes today.
- *   - a type whose adapter call THROWS is a genuine failure. It must not take
- *     down the audit (the other two reads still complete and their pages
- *     still count), but it must be visible — logged via `console.error`
- *     (stderr, NOT stdout — the default stdio MCP transport's JSON-RPC
- *     framing channel, #6012 round 2) — rather than silently collapsing into
- *     the same vacuous "nothing found" result.
- *
- * The call-count assertions below prove that all three reads still ran despite
- * the throw — the read AFTER the failing one is not skipped, which a
- * sequential loop that ABORTED on the first throw would fail to show. They
- * are NOT, on their own, proof of CONCURRENCY: the prior sequential `for`
- * loop this replaced used `continue` (not a re-throw), so it too issued all
- * three calls. The `Promise.all` in the source is what delivers the
- * concurrency AC; these assertions cover the narrower, still load-bearing
- * property that a throw part-way through never truncates the scan.
- */
-
-const mockResolveContentAdapter = jest.fn();
-
-jest.mock("@working-theory/content-adapters", () => ({
-  ...jest.requireActual("@working-theory/content-adapters"),
-  resolveContentAdapter: (...args: unknown[]) =>
-    mockResolveContentAdapter(...args),
-}));
-
-import type { ContentPage } from "@working-theory/content-adapters";
-
-import { buildSinglePageAuditInput } from "../../src/lib/audit-single-page.js";
-
-const HOME_PAGE: ContentPage = {
-  type: "HomePage",
-  slug: "home",
-  title: "Home",
-  description: "The home page.",
-};
-
-const PRODUCT_PAGE: ContentPage = {
-  type: "Product",
-  slug: "widget",
-  title: "Widget",
-  description: "A widget for sale.",
-  price: 49,
-  priceCurrency: "USD",
-};
-
-describe("scanSitePages — type-not-registered vs adapter-threw (#6012)", () => {
-  const previous = process.env.CONTENT_ADAPTER;
-  let errorSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    mockResolveContentAdapter.mockReset();
-    process.env.CONTENT_ADAPTER = "mdx";
-    errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
-    else process.env.CONTENT_ADAPTER = previous;
-    errorSpy.mockRestore();
-  });
-
-  it("a type the adapter legitimately has no pages of resolves silently — nothing logged", async () => {
-    const listPages = jest.fn().mockResolvedValue([]);
-    const listDetail = jest.fn().mockResolvedValue([]);
-    mockResolveContentAdapter.mockReturnValue({
-      getPageBySlug: jest.fn().mockResolvedValue(HOME_PAGE),
-      listPages,
-      listDetail,
-      getDetailBySlug: jest.fn(),
-      searchPages: jest.fn(),
-      extractStructuredData: jest.fn(),
-      createPage: jest.fn(),
-      updatePage: jest.fn(),
-      deletePage: jest.fn(),
-      getPageVersion: jest.fn(),
-    });
-
-    const result = await buildSinglePageAuditInput({
-      slug: "home",
-      type: "HomePage",
-    });
-
-    expect(result.readiness!.sitePages).toEqual([]);
-    expect(errorSpy).not.toHaveBeenCalled();
-    // All three reads still ran — two listDetail (Product, Service), one
-    // listPages (PurchasePolicyPage, #6646).
-    expect(listDetail).toHaveBeenCalledTimes(2);
-    expect(listPages).toHaveBeenCalledTimes(1);
-  });
-
-  it("a type whose adapter call throws is logged to stderr and does not fail the audit", async () => {
-    const listPages = jest.fn().mockResolvedValue([]);
-    const listDetail = jest.fn().mockImplementation((type: string) => {
-      if (type === "Service") {
-        throw new Error("simulated adapter failure");
-      }
-      return Promise.resolve([PRODUCT_PAGE]);
-    });
-    mockResolveContentAdapter.mockReturnValue({
-      getPageBySlug: jest.fn().mockResolvedValue(HOME_PAGE),
-      listPages,
-      listDetail,
-      getDetailBySlug: jest.fn(),
-      searchPages: jest.fn(),
-      extractStructuredData: jest.fn(),
-      createPage: jest.fn(),
-      updatePage: jest.fn(),
-      deletePage: jest.fn(),
-      getPageVersion: jest.fn(),
-    });
-
-    const result = await buildSinglePageAuditInput({
-      slug: "home",
-      type: "HomePage",
-    });
-
-    // The audit as a whole never fails, and the type that threw contributes
-    // nothing — but the type that succeeded (Product) still counts.
-    expect(result.readiness!.sitePages).toEqual([
-      { slug: "widget", type: "Product", price: 49 },
-    ]);
-    // The throwing type is visible, not silently swallowed — and via
-    // console.error (stderr), never console.debug/console.log (stdout,
-    // the stdio transport's JSON-RPC channel).
-    expect(errorSpy).toHaveBeenCalledTimes(1);
-    expect(errorSpy.mock.calls[0]![0]).toMatch(/Service/);
-    // All three reads still ran despite the throw — the read AFTER the
-    // throwing one (PurchasePolicyPage) was not skipped.
-    expect(listDetail).toHaveBeenCalledTimes(2);
-    expect(listPages).toHaveBeenCalledTimes(1);
-  });
-
-  it("a PurchasePolicyPage contributes its document-chassis section ids (#6646)", async () => {
-    const purchasePolicy: ContentPage = {
-      type: "PurchasePolicyPage",
-      slug: "purchase-policy",
-      title: "Purchase Policy",
-      description: "Returns, shipping and refunds.",
-      sections: [
-        {
-          id: "purchase-policy-document",
-          type: "document-chassis",
-          data: {
-            headline: "Purchase Policy",
-            sections: [
-              { id: "returns", heading: "Returns", blocks: [] },
-              { id: "shipping", heading: "Shipping", blocks: [] },
-              { id: "refunds", heading: "Refunds", blocks: [] },
-            ],
-          },
-        },
-      ] as ContentPage["sections"],
-    };
-    mockResolveContentAdapter.mockReturnValue({
-      getPageBySlug: jest.fn().mockResolvedValue(HOME_PAGE),
-      listPages: jest.fn().mockResolvedValue([purchasePolicy]),
-      listDetail: jest.fn().mockResolvedValue([]),
-      getDetailBySlug: jest.fn(),
-      searchPages: jest.fn(),
-      extractStructuredData: jest.fn(),
-      createPage: jest.fn(),
-      updatePage: jest.fn(),
-      deletePage: jest.fn(),
-      getPageVersion: jest.fn(),
-    });
-
-    const result = await buildSinglePageAuditInput({
-      slug: "home",
-      type: "HomePage",
-    });
-
-    expect(result.readiness!.sitePages).toEqual([
-      {
-        slug: "purchase-policy",
-        type: "PurchasePolicyPage",
-        chassisSectionIds: ["returns", "shipping", "refunds"],
-      },
-    ]);
-  });
-});