create-ailk 0.4.0 → 0.6.0

package/templates/apps/mcp/__tests__/lib/public-workspace.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Tests for the MCP server's own workspace resolution (#5876 spec D2/D4/D6/D7).
+ *
+ * Drives the REAL `initMcpPublicWorkspace()` (not a mock) so its resolution
+ * arms are exercised for real, over an injected `WorkspacePredicateClient`
+ * stub — no database, no `@working-theory/database` root (client) import,
+ * and no internal-module mock of `./prisma.js` either: the `not-required`
+ * cases prove the D6 no-op by the RETURN VALUE alone. `resolvedAdapterKind()
+ * !== "database"` is this function's first statement and returns before any
+ * `await import()` — the source itself, read at `public-workspace.ts:88-91`,
+ * is the proof that no lazy import can fire on those two paths; a real
+ * unconfigured `PrismaPg({connectionString: undefined})` wouldn't throw
+ * synchronously anyway, so mocking the module would prove nothing further.
+ */
+
+import {
+  DEFAULT_ORG_ID,
+  DEFAULT_WORKSPACE_ID,
+  type WorkspacePredicateClient,
+} from "@working-theory/database/tenancy";
+
+import {
+  initMcpPublicWorkspace,
+  mcpPublicWorkspace,
+  resetMcpPublicWorkspace,
+} from "../../src/lib/public-workspace.js";
+
+const NON_SENTINEL_ORG_ID = "org_01930000-0000-7bcd-8000-000000000002";
+
+function makeStub(
+  count: number,
+  found: { organizationId: string } | null,
+): WorkspacePredicateClient {
+  return {
+    workspace: {
+      count: jest.fn().mockResolvedValue(count),
+      findUnique: jest.fn().mockResolvedValue(found),
+    },
+  };
+}
+
+describe("initMcpPublicWorkspace", () => {
+  const previous = process.env.CONTENT_ADAPTER;
+
+  beforeEach(() => {
+    resetMcpPublicWorkspace();
+  });
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
+    else process.env.CONTENT_ADAPTER = previous;
+    resetMcpPublicWorkspace();
+  });
+
+  it("resolves not-required on mdx", async () => {
+    process.env.CONTENT_ADAPTER = "mdx";
+
+    const result = await initMcpPublicWorkspace();
+
+    expect(result).toEqual({ kind: "not-required" });
+    expect(mcpPublicWorkspace()).toEqual({ kind: "not-required" });
+  });
+
+  it("resolves not-required on projection", async () => {
+    process.env.CONTENT_ADAPTER = "projection";
+
+    const result = await initMcpPublicWorkspace();
+
+    expect(result).toEqual({ kind: "not-required" });
+  });
+
+  describe("CONTENT_ADAPTER=database", () => {
+    beforeEach(() => {
+      process.env.CONTENT_ADAPTER = "database";
+    });
+
+    it("resolves { kind: resolved } when the sole workspace is the well-known default", async () => {
+      const stub = makeStub(1, { organizationId: DEFAULT_ORG_ID });
+
+      const result = await initMcpPublicWorkspace({ prisma: stub });
+
+      expect(result).toEqual({
+        kind: "resolved",
+        workspaceId: DEFAULT_WORKSPACE_ID,
+        prisma: stub,
+      });
+      expect(mcpPublicWorkspace()).toEqual(result);
+    });
+
+    it("resolves { kind: unresolved } when zero workspaces exist", async () => {
+      const stub = makeStub(0, null);
+
+      const result = await initMcpPublicWorkspace({ prisma: stub });
+
+      expect(result).toEqual({ kind: "unresolved", reason: "ambiguous" });
+    });
+
+    it("resolves { kind: unresolved } when two or more workspaces exist", async () => {
+      const stub = makeStub(2, null);
+
+      const result = await initMcpPublicWorkspace({ prisma: stub });
+
+      expect(result).toEqual({ kind: "unresolved", reason: "ambiguous" });
+    });
+
+    it("resolves { kind: unresolved } when the sole workspace is not the well-known default", async () => {
+      const stub = makeStub(1, { organizationId: NON_SENTINEL_ORG_ID });
+
+      const result = await initMcpPublicWorkspace({ prisma: stub });
+
+      expect(result).toEqual({ kind: "unresolved", reason: "ambiguous" });
+    });
+  });
+});
+
+describe("mcpPublicWorkspace", () => {
+  afterEach(() => {
+    resetMcpPublicWorkspace();
+  });
+
+  it("returns { kind: not-required } before initMcpPublicWorkspace has ever run", () => {
+    expect(mcpPublicWorkspace()).toEqual({ kind: "not-required" });
+  });
+});

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

@@ -13,15 +13,85 @@
 import { readFileSync } from "node:fs";
 import { resolve, join } from "node:path";
 
+import {
+  resetResolvedContentAdapter,
+  type ArtifactPrismaClient,
+} from "@working-theory/content-adapters";
+
 import {
   ailkListPages,
   listPagesInputSchema,
   listPagesOutputSchema,
 } from "../src/tools/list_pages.js";
+import {
+  __setMcpPublicWorkspaceForTest,
+  resetMcpPublicWorkspace,
+} from "../src/lib/public-workspace.js";
 
 // Content root for real-filesystem tests — repo-relative
 const REPO_ROOT = resolve(__dirname, "../../..");
 const CONTENT_ROOT = join(REPO_ROOT, "content");
+const WORKSPACE_ID = "wksp_00000000-0000-7000-8000-000000000001";
+
+/**
+ * A structural `ArtifactPrismaClient` stub (#5876 spec D11) — a published
+ * HomePage plus a draft-only HomePage that must never surface (AC-1's
+ * published-only half is a reach test — the invariant is the adapter's).
+ */
+function makeArtifactPrismaClientStub(): ArtifactPrismaClient {
+  return {
+    artifact: {
+      findFirst: jest.fn(),
+      findMany: jest.fn().mockResolvedValue([
+        {
+          id: "artifact_published",
+          workspaceId: WORKSPACE_ID,
+          contentType: "text/page",
+          locale: "en",
+          slug: "home",
+          title: "Home",
+          publishedVersionId: "version_published",
+        },
+        {
+          id: "artifact_draft",
+          workspaceId: WORKSPACE_ID,
+          contentType: "text/page",
+          locale: "en",
+          slug: "draft-page",
+          title: "Draft Page",
+          publishedVersionId: null,
+        },
+      ]),
+      create: jest.fn(),
+      updateMany: jest.fn(),
+      deleteMany: jest.fn(),
+    },
+    artifactVersion: {
+      findFirst: jest.fn(),
+      // Only the PUBLISHED version's row is ever returned — the adapter
+      // filters publishedIds to non-null before this query, so a draft-only
+      // artifact's version id never appears in the `id: { in: [...] }` set.
+      findMany: jest.fn().mockResolvedValue([
+        {
+          id: "version_published",
+          artifactId: "artifact_published",
+          workspaceId: WORKSPACE_ID,
+          content: {
+            type: "HomePage",
+            slug: "home",
+            title: "Home",
+            description: "The homepage.",
+            body: "# Hello",
+          },
+          isCurrent: false,
+        },
+      ]),
+      create: jest.fn(),
+      updateMany: jest.fn(),
+    },
+    $transaction: jest.fn(),
+  };
+}
 
 describe("listPagesInputSchema", () => {
   it("accepts empty input (type is optional)", () => {
@@ -101,6 +171,52 @@ describe("listPagesInputSchema — Zod boundary security", () => {
   });
 });
 
+describe("ailkListPages — CONTENT_ADAPTER=database (#5876)", () => {
+  const previous = process.env.CONTENT_ADAPTER;
+
+  beforeEach(() => {
+    process.env.CONTENT_ADAPTER = "database";
+    resetResolvedContentAdapter();
+  });
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
+    else process.env.CONTENT_ADAPTER = previous;
+    resetMcpPublicWorkspace();
+    resetResolvedContentAdapter();
+  });
+
+  it("AC-1: lists only published pages", async () => {
+    const stub = makeArtifactPrismaClientStub();
+    __setMcpPublicWorkspaceForTest({
+      kind: "resolved",
+      workspaceId: WORKSPACE_ID,
+      prisma: stub,
+    });
+
+    const result = await ailkListPages({ type: "HomePage" });
+
+    expect(result.pages).toEqual([
+      expect.objectContaining({ slug: "home", type: "HomePage" }),
+    ]);
+    expect(stub.artifact.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ workspaceId: WORKSPACE_ID }),
+      }),
+    );
+  });
+
+  it("AC-2: returns { pages: [] } when the workspace is unresolved, with no query", async () => {
+    const stub = makeArtifactPrismaClientStub();
+    __setMcpPublicWorkspaceForTest({ kind: "unresolved", reason: "ambiguous" });
+
+    const result = await ailkListPages({ type: "HomePage" });
+
+    expect(result.pages).toEqual([]);
+    expect(stub.artifact.findMany).not.toHaveBeenCalled();
+  });
+});
+
 describe("architectural guard — no console calls", () => {
   it("apps/mcp/src/tools/list_pages.ts does not call console.*", () => {
     const src = readFileSync(

package/templates/apps/mcp/__tests__/module-exclusion.test.ts

@@ -18,7 +18,13 @@ import { getMcpToolRegistrations } from "@working-theory/metadata";
 
 import { createMcpServer, listRegisteredTools } from "../src/server.js";
 
-const PAID_MODULES = ["scheduling", "content-write", "signal-collectors"] as const;
+// `content-write` left this list in #5853: its three tools (create_page /
+// update_page / delete_page) were deleted with the untenanted HTTP routes they
+// twinned, so the module now owns NO catalog tool at all and the
+// "owns at least one" fixture check below would fail for it. The flag itself
+// is unchanged — it still gates the tenant-guarded editor routes in apps/api
+// (D8), which this MCP-side matrix has never covered.
+const PAID_MODULES = ["scheduling", "signal-collectors"] as const;
 
 function withEnabledModules<T>(enabled: string, fn: () => T): T {
   const prior = process.env.AILK_ENABLED_MODULES;

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

@@ -105,10 +105,7 @@ const MCP_ONLY_TOOLS = new Set([
   "ailkAudit", // audit — AEO scoring tool, no web action equivalent (I5; ADR 0013)
   "ailkSubscribeNewsletter", // subscribe_newsletter — anonymous write via MCP; no Server Action (B7)
   "ailkRequestCallback", // request_callback — anonymous write via MCP; no Server Action (B7)
-  "ailkScaffold", // scaffold — agent-only scaffolder; no Server Action equivalent (#299)
-  "ailkCreatePage", // create_page — agent-first Pro content write; HTTP twin is apps/api, not a Server Action (D14a #55)
-  "ailkUpdatePage", // update_page — agent-first Pro content write; HTTP twin is apps/api, not a Server Action (D14a #55)
-  "ailkDeletePage", // delete_page — agent-first Pro content write; HTTP twin is apps/api, not a Server Action (D14a #55)
+  "ailkCreateProject", // create_project — agent-only project creator; no Server Action equivalent (#299)
   "ailkGetFlow", // get_flow — agent-callable flow-engine read; no web Server Action (#3956 D7)
   "ailkListAvailability", // list_availability — anonymous scheduling read via MCP; the booker section is a client island calling apps/api directly, not a Server Action (#4416)
   "ailkGetEventMeta", // get_event_meta — meta-only scheduling read via MCP; a tile-rendering page is an RSC calling apps/api via api-client, not a Server Action (#4633)
@@ -246,9 +243,15 @@ describe("MCP ↔ Server-Action parity (filesystem)", () => {
     // - ailkAudit: MCP-only (AEO scoring; I5; in MCP_ONLY_TOOLS allow-list).
     // - ailkSubscribeNewsletter, ailkRequestCallback:
     //   MCP-only anonymous-write tools (B7; in MCP_ONLY_TOOLS allow-list).
-    // - ailkScaffold: MCP-only agent scaffolder (#299; in MCP_ONLY_TOOLS).
-    // - ailkCreatePage, ailkUpdatePage, ailkDeletePage: MCP-only agent-first
-    //   Pro content writes; HTTP twin is apps/api, not Server Actions (D14a #55).
+    // - ailkCreateProject: MCP-only agent project creator (#299; in MCP_ONLY_TOOLS).
+    // - ailkCreatePage, ailkUpdatePage, ailkDeletePage: RETIRED by #5853
+    //   (D7). Their HTTP twins — the untenanted /v1/content writes — were
+    //   deleted in the same PR, so keeping the tools would have left three
+    //   MCP tools with no HTTP equivalent, a direct breach of the parity rule
+    //   this file enforces. Their replacement is identity-BOUND
+    //   (/v1/workspaces/:workspaceId/content), which the identity-blind
+    //   anonymous MCP surface can never carry (D15); the authed MCP surface
+    //   is #3591.
     // - ailkGetFlow: MCP-only agent-callable flow-engine read; HTTP twin is
     //   apps/api, not a Server Action (#3956 D7) — the page fetch in
     //   apps/web/app/[locale]/flows/[slug]/page.tsx is a direct api-client
@@ -257,12 +260,12 @@ describe("MCP ↔ Server-Action parity (filesystem)", () => {
     //   GET /v1/schedule/availability and POST /v1/schedule/book (#4416). The
     //   `booker` section is a "use client" island that fetches those routes
     //   directly (the ContactForm/StepFlow pattern) — no Server Action, so
-    //   the HTTP twin is apps/api, as with the create/update/delete_page trio.
+    //   the HTTP twin is apps/api.
     // - ailkGetEventMeta: MCP-only meta-only scheduling read, twin of
     //   GET /v1/schedule/event-meta (#4633) — same posture as the other
     //   scheduling tools.
     expect(actions.size).toBe(5);
-    expect(tools.size).toBe(23);
+    expect(tools.size).toBe(20);
     expect(r.missingTools).toEqual([]);
     expect(r.orphanTools).toEqual([]);
   });

package/templates/apps/mcp/__tests__/purchase-disabled.test.ts

@@ -1,34 +1,101 @@
 /**
- * Tests for S15a — purchase tool disabled at OSS catalog.
+ * `start_purchase` visibility — the commerce add-on claim matrix (#5971).
  *
- * Issue #610 / spec
- * `docs/internal/specs/ailk-pre-oss-security-phase-3-s15a-disable-purchase-spec.md`.
+ * Supersedes S15a (#610), which asserted blanket absence while
+ * `OSS_DISABLED_TOOLS` carried the name. The gate is now the deployment's
+ * `commerce` licence claim, so the assertion is a MATRIX, not an absence:
  *
- * Acceptance criterion verified here: `start_purchase` is NOT in the
- * registered MCP tool catalog when the server is constructed by
- * `createMcpServer()`. If a future PR re-registers the tool (by removing
- * `'start_purchase'` from `OSS_DISABLED_TOOLS` in `apps/mcp/src/server.ts`),
- * this test fails RED, forcing a deliberate review of the Phase 3
- * re-enablement criteria in
- * `docs/internal/roadmaps/phase-3-readiness.md`.
+ *   keyless (no claim) → absent from `listRegisteredTools()` and from
+ *     `createMcpServer()._registeredTools`, and calling `ailkPurchase` BY
+ *     NAME returns the module-disabled body with no `checkout.createSession`
+ *     call;
+ *   keyed (claim held)  → present in both surfaces.
  *
- * `purchase.ts` source is preserved — only the registration is filtered.
+ * Both halves are driven through `__setMcpCommerceClaimForTest()`, the same
+ * injector idiom `lib/public-workspace.ts` established (#5876). No test
+ * reaches a licence server.
  */
 
+import { checkout } from "@working-theory/api-client";
+
+import {
+  __setMcpCommerceClaimForTest,
+  resetMcpCommerceClaim,
+} from "../src/lib/commerce-claim.js";
 import { createMcpServer, listRegisteredTools } from "../src/server.js";
+import { ailkPurchase } from "../src/tools/purchase.js";
+
+jest.mock("@working-theory/api-client", () => ({
+  checkout: { createSession: jest.fn() },
+}));
+
+const createSession = checkout.createSession as jest.MockedFunction<
+  typeof checkout.createSession
+>;
+
+function registeredNames(): string[] {
+  const server = createMcpServer();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
+  const tools = (server as any)._registeredTools as Record<string, unknown>;
+  return Object.keys(tools);
+}
+
+afterEach(() => {
+  jest.clearAllMocks();
+  resetMcpCommerceClaim();
+});
+
+describe("start_purchase — keyless site (no commerce claim)", () => {
+  beforeEach(() => {
+    __setMcpCommerceClaimForTest("unclaimed");
+  });
+
+  it("is NOT in listRegisteredTools()", () => {
+    expect(listRegisteredTools().map((t) => t.name)).not.toContain(
+      "start_purchase",
+    );
+  });
+
+  it("is NOT in createMcpServer()._registeredTools", () => {
+    expect(registeredNames()).not.toContain("start_purchase");
+  });
 
-describe("purchase tool — disabled at OSS catalog (S15a)", () => {
-  it("start_purchase is NOT in listRegisteredTools()", () => {
-    const tools = listRegisteredTools();
-    const names = tools.map((t) => t.name);
-    expect(names).not.toContain("start_purchase");
+  it("calling it by name returns the module-disabled body and creates no session", async () => {
+    const result = await ailkPurchase({ productCode: "pro-plan" });
+
+    expect(result).toEqual({ error: "not_found", message: "Not found" });
+    expect(createSession).not.toHaveBeenCalled();
+  });
+
+  it("the module-disabled body does not hint that a licence gate exists", async () => {
+    const result = await ailkPurchase({ productCode: "pro-plan" });
+
+    expect(JSON.stringify(result)).not.toMatch(/commerce|licen[cs]e|claim/i);
+  });
+});
+
+describe("start_purchase — keyed site (commerce claim held)", () => {
+  beforeEach(() => {
+    __setMcpCommerceClaimForTest("claimed");
+  });
+
+  it("IS in listRegisteredTools()", () => {
+    expect(listRegisteredTools().map((t) => t.name)).toContain(
+      "start_purchase",
+    );
   });
 
-  it("start_purchase is NOT in createMcpServer()._registeredTools", () => {
-    const server = createMcpServer();
-    // _registeredTools is a plain object (Record<string, ...>) in SDK v1.x.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mirrors apps/mcp/__tests__/server.test.ts
-    const tools = (server as any)._registeredTools as Record<string, unknown>;
-    expect("start_purchase" in tools).toBe(false);
+  it("IS in createMcpServer()._registeredTools", () => {
+    expect(registeredNames()).toContain("start_purchase");
+  });
+});
+
+describe("fail-closed default", () => {
+  it("the un-initialised module state is unclaimed", () => {
+    // No injector call — this is the state a boot that never resolved the
+    // licence (or resolved it to a rejection) leaves behind.
+    expect(listRegisteredTools().map((t) => t.name)).not.toContain(
+      "start_purchase",
+    );
   });
 });