create-ailk 0.23.0 → 0.25.1

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

@@ -1,474 +0,0 @@
-/**
- * Tests for the read_content MCP tool handler.
- *
- * Acceptance criteria verified here:
- * - readContentInputSchema validates correct inputs (type + slug)
- * - readContentInputSchema rejects unknown type values and malformed slugs
- * - ailkReadContent returns { slug, type, frontmatter, body } for a known slug
- * - ailkReadContent returns null (not throws) for an unknown slug
- * - Output validates against readContentOutputSchema
- * - No console.* calls in handler (structural test)
- * - #6030 AC-1: BlogPosting and DocsDetail — the two types this issue admits —
- *   are readable through the adapter on both the MDX leg and the database
- *   leg, and both are asserted against the shared adapter seam
- *   (`ContentAdapter.getPageSource`) per the API↔MCP parity contract (D3).
- */
-
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { resolve, join } from "node:path";
-
-import {
-  createMdxAdapter,
-  resetResolvedContentAdapter,
-  type ArtifactPrismaClient,
-} from "@working-theory/content-adapters";
-
-import {
-  ailkReadContent,
-  readContentInputSchema,
-  readContentOutputSchema,
-} from "../src/tools/read_content.js";
-import {
-  __setMcpPublicWorkspaceForTest,
-  resetMcpPublicWorkspace,
-} from "../src/lib/public-workspace.js";
-
-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) — `artifact` and
- * `artifactVersion` jest.fn()s, injected directly, no database.
- */
-function makeArtifactPrismaClientStub(overrides: {
-  artifact?: { publishedVersionId: string | null } | null;
-  version?: { content: unknown } | null;
-}): ArtifactPrismaClient {
-  const artifact =
-    overrides.artifact === undefined || overrides.artifact === null
-      ? null
-      : {
-          id: "artifact_1",
-          workspaceId: WORKSPACE_ID,
-          contentType: "text/page",
-          locale: "en",
-          slug: "home",
-          title: "Home",
-          publishedVersionId: overrides.artifact.publishedVersionId,
-        };
-  const version =
-    overrides.version === undefined || overrides.version === null
-      ? null
-      : {
-          id: "version_1",
-          artifactId: "artifact_1",
-          workspaceId: WORKSPACE_ID,
-          content: overrides.version.content,
-          isCurrent: false,
-        };
-  return {
-    artifact: {
-      findFirst: jest.fn().mockResolvedValue(artifact),
-      findMany: jest.fn().mockResolvedValue([]),
-      create: jest.fn(),
-      updateMany: jest.fn(),
-      deleteMany: jest.fn(),
-    },
-    artifactVersion: {
-      findFirst: jest.fn().mockResolvedValue(version),
-      findMany: jest.fn().mockResolvedValue([]),
-      create: jest.fn(),
-      updateMany: jest.fn(),
-    },
-    $transaction: jest.fn(),
-  };
-}
-
-describe("readContentInputSchema", () => {
-  it("accepts a valid type + slug", () => {
-    const result = readContentInputSchema.safeParse({
-      type: "HomePage",
-      slug: "home",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts a HomePage slug", () => {
-    const result = readContentInputSchema.safeParse({
-      type: "HomePage",
-      slug: "home",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects missing slug", () => {
-    const result = readContentInputSchema.safeParse({ type: "HomePage" });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects missing type", () => {
-    const result = readContentInputSchema.safeParse({
-      slug: "launching-ailk",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects an unknown type", () => {
-    const result = readContentInputSchema.safeParse({
-      type: "NotAType",
-      slug: "some-slug",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects empty slug", () => {
-    const result = readContentInputSchema.safeParse({
-      type: "HomePage",
-      slug: "",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects slug with path traversal characters", () => {
-    const result = readContentInputSchema.safeParse({
-      type: "HomePage",
-      slug: "../etc/passwd",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects slug with forward slashes", () => {
-    const result = readContentInputSchema.safeParse({
-      type: "HomePage",
-      slug: "some/path",
-    });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("ailkReadContent handler", () => {
-  it("returns slug, type, frontmatter, body for a known HomePage", async () => {
-    const result = await ailkReadContent(
-      { type: "HomePage", slug: "home" },
-      CONTENT_ROOT,
-    );
-
-    expect(result).not.toBeNull();
-    expect(result!.slug).toBe("home");
-    expect(result!.type).toBe("HomePage");
-    expect(typeof result!.frontmatter).toBe("object");
-    expect(typeof result!.body).toBe("string");
-  });
-
-  it("returns null (not throws) for an unknown slug", async () => {
-    const result = await ailkReadContent(
-      { type: "HomePage", slug: "does-not-exist" },
-      CONTENT_ROOT,
-    );
-    expect(result).toBeNull();
-  });
-
-  it("returns null for a slug that exists in a different type", async () => {
-    // home.mdx exists under HomePage, not AboutPage
-    const result = await ailkReadContent(
-      { type: "AboutPage", slug: "home" },
-      CONTENT_ROOT,
-    );
-    expect(result).toBeNull();
-  });
-
-  it("returns null for a valid type with no files when given an unknown slug", async () => {
-    const result = await ailkReadContent(
-      { type: "FAQPage", slug: "nonexistent" },
-      CONTENT_ROOT,
-    );
-    expect(result).toBeNull();
-  });
-
-  it("output shape validates against readContentOutputSchema when non-null", async () => {
-    const result = await ailkReadContent(
-      { type: "HomePage", slug: "home" },
-      CONTENT_ROOT,
-    );
-    const parsed = readContentOutputSchema.safeParse(result);
-    expect(parsed.success).toBe(true);
-  });
-
-  it("null validates against readContentOutputSchema", async () => {
-    const result = await ailkReadContent(
-      { type: "HomePage", slug: "does-not-exist" },
-      CONTENT_ROOT,
-    );
-    const parsed = readContentOutputSchema.safeParse(result);
-    expect(parsed.success).toBe(true);
-  });
-});
-
-describe("ailkReadContent — CONTENT_ADAPTER=database (#5876)", () => {
-  const previous = process.env.CONTENT_ADAPTER;
-
-  beforeEach(() => {
-    process.env.CONTENT_ADAPTER = "database";
-    // resolveContentAdapter() memoises per (kind, workspaceId, contentRoot,
-    // defaultLocale, manifestPath) — NOT per prisma instance — so every case
-    // below (same workspaceId, same defaults) would otherwise reuse the FIRST
-    // test's adapter, bound to the FIRST test's stub.
-    resetResolvedContentAdapter();
-  });
-
-  afterEach(() => {
-    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
-    else process.env.CONTENT_ADAPTER = previous;
-    resetMcpPublicWorkspace();
-    resetResolvedContentAdapter();
-  });
-
-  it("AC-1: returns { slug, type, frontmatter, body } for a published page", async () => {
-    const stub = makeArtifactPrismaClientStub({
-      artifact: { publishedVersionId: "version_1" },
-      version: {
-        content: {
-          type: "HomePage",
-          slug: "home",
-          title: "Home",
-          description: "The homepage.",
-          body: "# Hello",
-        },
-      },
-    });
-    __setMcpPublicWorkspaceForTest({
-      kind: "resolved",
-      workspaceId: WORKSPACE_ID,
-      prisma: stub,
-    });
-
-    const result = await ailkReadContent({ type: "HomePage", slug: "home" });
-
-    expect(result).not.toBeNull();
-    expect(result!.slug).toBe("home");
-    expect(result!.type).toBe("HomePage");
-    expect(result!.body).toBe("# Hello");
-    // The reach test (§5.2 AC-1) — the read is bound to the resolved workspace.
-    expect(stub.artifact.findFirst).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.objectContaining({ workspaceId: WORKSPACE_ID }),
-      }),
-    );
-  });
-
-  it("AC-1: returns null for a draft-only artifact (no published version)", async () => {
-    const stub = makeArtifactPrismaClientStub({
-      artifact: { publishedVersionId: null },
-    });
-    __setMcpPublicWorkspaceForTest({
-      kind: "resolved",
-      workspaceId: WORKSPACE_ID,
-      prisma: stub,
-    });
-
-    const result = await ailkReadContent({ type: "HomePage", slug: "home" });
-
-    expect(result).toBeNull();
-  });
-
-  it("AC-1: returns null for an unknown slug", async () => {
-    const stub = makeArtifactPrismaClientStub({ artifact: null });
-    __setMcpPublicWorkspaceForTest({
-      kind: "resolved",
-      workspaceId: WORKSPACE_ID,
-      prisma: stub,
-    });
-
-    const result = await ailkReadContent({
-      type: "HomePage",
-      slug: "does-not-exist",
-    });
-
-    expect(result).toBeNull();
-  });
-
-  it("AC-2: returns null when the workspace is unresolved, with no content lookup", async () => {
-    const stub = makeArtifactPrismaClientStub({});
-    __setMcpPublicWorkspaceForTest({ kind: "unresolved", reason: "ambiguous" });
-
-    const result = await ailkReadContent({ type: "HomePage", slug: "home" });
-
-    expect(result).toBeNull();
-    expect(stub.artifact.findFirst).not.toHaveBeenCalled();
-  });
-});
-
-describe("ailkReadContent — BlogPosting and DocsDetail, MDX leg (#6030 AC-1)", () => {
-  let root = "";
-
-  beforeAll(() => {
-    root = mkdtempSync(join(tmpdir(), "ailk-mcp-6030-"));
-    for (const { type, slug, body } of [
-      { type: "BlogPosting", slug: "launch-post", body: "# Launch post\n\nBody." },
-      { type: "DocsDetail", slug: "getting-started", body: "# Getting started\n\nBody." },
-    ]) {
-      const dir = join(root, "en", type);
-      mkdirSync(dir, { recursive: true });
-      writeFileSync(
-        join(dir, `${slug}.mdx`),
-        [
-          "---",
-          `type: "${type}"`,
-          `slug: "${slug}"`,
-          `title: "${type} ${slug} title"`,
-          `description: "${type} ${slug} description"`,
-          "---",
-          "",
-          body,
-          "",
-        ].join("\n"),
-        "utf8",
-      );
-    }
-  });
-
-  afterAll(() => {
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  it.each(["BlogPosting", "DocsDetail"] as const)(
-    "returns the page for %s, deep-equal to the projection over getPageSource (D3)",
-    async (type) => {
-      const slug = type === "BlogPosting" ? "launch-post" : "getting-started";
-      const result = await ailkReadContent({ type, slug, locale: "en" }, root);
-
-      // The shared seam D3 asserts from both ends: read_content's payload is
-      // derived from exactly what ContentAdapter.getPageSource(type, slug,
-      // locale) returns for the arguments the tool builds — not restated.
-      const adapter = createMdxAdapter({ contentRoot: root });
-      const source = await adapter.getPageSource(type, slug, "en");
-      expect(source).not.toBeNull();
-      const expected = readContentOutputSchema.parse({
-        slug: source!.frontmatter.slug ?? slug,
-        type: source!.frontmatter.type ?? type,
-        frontmatter: source!.frontmatter,
-        body: source!.body,
-      });
-
-      expect(result).toEqual(expected);
-      expect(result!.slug).toBe(slug);
-      expect(result!.type).toBe(type);
-    },
-  );
-
-  it.each(["BlogPosting", "DocsDetail"] as const)(
-    "returns null for an absent slug of %s",
-    async (type) => {
-      const result = await ailkReadContent(
-        { type, slug: "does-not-exist", locale: "en" },
-        root,
-      );
-      expect(result).toBeNull();
-    },
-  );
-});
-
-describe("ailkReadContent — BlogPosting and DocsDetail, CONTENT_ADAPTER=database (#6030 AC-1)", () => {
-  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.each(["BlogPosting", "DocsDetail"] as const)(
-    "returns { slug, type, frontmatter, body } for a published %s",
-    async (type) => {
-      const slug = "probe";
-      const stub = makeArtifactPrismaClientStub({
-        artifact: { publishedVersionId: "version_1" },
-        version: {
-          content: {
-            type,
-            slug,
-            title: `${type} title`,
-            description: `${type} description`,
-            body: "# Published body",
-          },
-        },
-      });
-      __setMcpPublicWorkspaceForTest({
-        kind: "resolved",
-        workspaceId: WORKSPACE_ID,
-        prisma: stub,
-      });
-
-      const result = await ailkReadContent({ type, slug });
-
-      expect(result).not.toBeNull();
-      expect(result!.slug).toBe(slug);
-      expect(result!.type).toBe(type);
-      expect(result!.body).toBe("# Published body");
-    },
-  );
-
-  // D4 — the publication guard must hold for every newly-admitted type, not
-  // only HomePage's existing case.
-  it.each(["BlogPosting", "DocsDetail"] as const)(
-    "returns null for a draft-only %s artifact (no published version)",
-    async (type) => {
-      const stub = makeArtifactPrismaClientStub({
-        artifact: { publishedVersionId: null },
-      });
-      __setMcpPublicWorkspaceForTest({
-        kind: "resolved",
-        workspaceId: WORKSPACE_ID,
-        prisma: stub,
-      });
-
-      const result = await ailkReadContent({ type, slug: "probe" });
-
-      expect(result).toBeNull();
-    },
-  );
-
-  // D4 — type-as-address: a page stored under a different frontmatter.type
-  // than requested reads as absent, never as a cross-type hit.
-  it("returns null when the requested type does not match the stored frontmatter.type", async () => {
-    const stub = makeArtifactPrismaClientStub({
-      artifact: { publishedVersionId: "version_1" },
-      version: {
-        content: {
-          type: "BlogPosting",
-          slug: "probe",
-          title: "A blog post",
-          description: "Stored as BlogPosting.",
-          body: "# Body",
-        },
-      },
-    });
-    __setMcpPublicWorkspaceForTest({
-      kind: "resolved",
-      workspaceId: WORKSPACE_ID,
-      prisma: stub,
-    });
-
-    const result = await ailkReadContent({ type: "DocsDetail", slug: "probe" });
-
-    expect(result).toBeNull();
-  });
-});
-
-describe("architectural guard — no console calls", () => {
-  it("apps/mcp/src/tools/read_content.ts does not call console.*", () => {
-    const src = readFileSync(
-      resolve(__dirname, "../src/tools/read_content.ts"),
-      "utf-8",
-    );
-    expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
-  });
-});

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

@@ -1,225 +0,0 @@
-/**
- * Tests for the request_callback MCP tool handler.
- *
- * Acceptance criteria verified here:
- * 1. Malformed input → { ok: false, error: { kind: 'invalid_input', issues } }, api-client never called
- * 2. Happy path → forwards to apiClient.leads.callback, returns { ok: true, id, persisted }
- * 3. API 400 → { ok: false, error: { kind: 'api_error', status: 400 } }
- * 4. API 503 → { ok: false, error: { kind: 'api_error', status: 503 } }
- * 5. API 429 → { ok: false, error: { kind: 'api_error', status: 429 } }
- * 6. #8073 — forwards the trusted caller address + AILK_VISITOR_FORWARD_KEY
- *    as the two visitor-forwarding headers only when both are present
- */
-
-import { ailkRequestCallback } from "../src/tools/request_callback.js";
-import { trustedCallerAddress } from "../src/request-context.js";
-
-// Everything but `apiClient.leads.callback` stays the ACTUAL
-// implementation — in particular `visitorForwardHeaders`, which
-// `request-context.ts` (imported above, for `trustedCallerAddress`) reads
-// for real.
-jest.mock("@working-theory/api-client", () => {
-  const actual = jest.requireActual("@working-theory/api-client");
-  return {
-    ...actual,
-    apiClient: {
-      ...actual.apiClient,
-      leads: { ...actual.apiClient.leads, callback: jest.fn() },
-    },
-  };
-});
-
- 
-const { apiClient } = require("@working-theory/api-client") as {
-  apiClient: { leads: { callback: jest.Mock } };
-};
-
-const VALID_INPUT = {
-  name: "Jane Smith",
-  phone: "+15555550100",
-};
-
-beforeEach(() => {
-  jest.clearAllMocks();
-});
-
-describe("ailkRequestCallback — input validation", () => {
-  it("rejects malformed input (missing required fields) without calling api-client", async () => {
-    const result = await ailkRequestCallback({} as never);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.kind).toBe("invalid_input");
-      if (result.error.kind === "invalid_input") {
-        expect(Array.isArray(result.error.issues)).toBe(true);
-        expect(result.error.issues.length).toBeGreaterThan(0);
-      }
-    }
-    expect(apiClient.leads.callback).not.toHaveBeenCalled();
-  });
-});
-
-describe("ailkRequestCallback — happy path", () => {
-  it("forwards canonical body to api-client and returns ok:true with id and persisted", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "fallback-1700000000000-cb1", persisted: "file" },
-    });
-
-    const result = await ailkRequestCallback(VALID_INPUT);
-
-    expect(apiClient.leads.callback).toHaveBeenCalledWith({
-      siteId: "default",
-      name: "Jane Smith",
-      phone: "+15555550100",
-      payload: {},
-    });
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.id).toBe("fallback-1700000000000-cb1");
-      expect(result.persisted).toBe("file");
-    }
-  });
-});
-
-describe("ailkRequestCallback — API error mapping", () => {
-  it("maps API 400 to { ok: false, error: { kind: 'api_error', status: 400 } }", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({
-      ok: false,
-      status: 400,
-      body: { error: "bad_request" },
-    });
-
-    const result = await ailkRequestCallback(VALID_INPUT);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.kind).toBe("api_error");
-      if (result.error.kind === "api_error") {
-        expect(result.error.status).toBe(400);
-      }
-    }
-  });
-
-  it("maps API 503 to { ok: false, error: { kind: 'api_error', status: 503 } }", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({
-      ok: false,
-      status: 503,
-      body: { error: "service_unavailable" },
-    });
-
-    const result = await ailkRequestCallback(VALID_INPUT);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.kind).toBe("api_error");
-      if (result.error.kind === "api_error") {
-        expect(result.error.status).toBe(503);
-      }
-    }
-  });
-
-  it("maps API 429 to { ok: false, error: { kind: 'api_error', status: 429 } }", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({
-      ok: false,
-      status: 429,
-      body: { error: "rate_limited" },
-    });
-
-    const result = await ailkRequestCallback(VALID_INPUT);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.kind).toBe("api_error");
-      if (result.error.kind === "api_error") {
-        expect(result.error.status).toBe(429);
-      }
-    }
-  });
-});
-
-describe("ailkRequestCallback — siteId default", () => {
-  it("uses siteId 'default' when AILK_SITE_ID is unset", async () => {
-    delete process.env.AILK_SITE_ID;
-    apiClient.leads.callback.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "fallback-1700000000000-cb2", persisted: "file" },
-    });
-
-    await ailkRequestCallback(VALID_INPUT);
-
-    const call = apiClient.leads.callback.mock.calls[0][0] as { siteId: string };
-    expect(call.siteId).toBe("default");
-  });
-});
-
-describe("ailkRequestCallback — siteId override", () => {
-  afterEach(() => {
-    delete process.env.AILK_SITE_ID;
-  });
-
-  it("uses AILK_SITE_ID env var when set", async () => {
-    process.env.AILK_SITE_ID = "site-abc";
-    apiClient.leads.callback.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "fallback-1700000000000-cb3", persisted: "file" },
-    });
-
-    await ailkRequestCallback(VALID_INPUT);
-
-    const call = apiClient.leads.callback.mock.calls[0][0] as { siteId: string };
-    expect(call.siteId).toBe("site-abc");
-  });
-});
-
-describe("ailkRequestCallback — visitor-forwarding headers (#8073)", () => {
-  afterEach(() => {
-    delete process.env.AILK_VISITOR_FORWARD_KEY;
-  });
-
-  it("calls api-client with exactly one argument when there is no trusted address", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "fallback-1700000000000-e1", persisted: "file" },
-    });
-    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
-
-    await ailkRequestCallback(VALID_INPUT);
-
-    expect(apiClient.leads.callback.mock.calls[0]).toHaveLength(1);
-  });
-
-  it("forwards the trusted address and the forward key as the two visitor headers", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "fallback-1700000000000-e2", persisted: "file" },
-    });
-    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
-
-    await trustedCallerAddress.run("203.0.113.9", () =>
-      ailkRequestCallback(VALID_INPUT),
-    );
-
-    const init = apiClient.leads.callback.mock.calls[0][1] as
-      | { headers?: Record<string, string> }
-      | undefined;
-    expect(init?.headers).toEqual({
-      "x-ailk-visitor-ip": "203.0.113.9",
-      "x-ailk-visitor-forward-key": "spoke-key",
-    });
-  });
-
-  it("sends no headers when there is a trusted address but no forward key", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "fallback-1700000000000-e3", persisted: "file" },
-    });
-    delete process.env.AILK_VISITOR_FORWARD_KEY;
-
-    await trustedCallerAddress.run("203.0.113.9", () =>
-      ailkRequestCallback(VALID_INPUT),
-    );
-
-    expect(apiClient.leads.callback.mock.calls[0]).toHaveLength(1);
-  });
-});