create-ailk 0.29.1 → 0.31.0

package/templates/apps/web/lib/__tests__/bot-check.test.ts

@@ -14,6 +14,13 @@ jest.mock("botid/server", () => ({
   checkBotId: (...args: unknown[]) => checkBotIdMock(...args),
 }));
 
+// The request's headers (#10715): every case decides them here, a direct
+// request with no proxy marker unless the case says otherwise.
+const headersMock = jest.fn();
+jest.mock("next/headers", () => ({
+  headers: (...args: unknown[]) => headersMock(...args),
+}));
+
 const BOT = {
   isHuman: false,
   isBot: true,
@@ -42,6 +49,8 @@ let warnSpy: jest.SpyInstance;
 
 beforeEach(() => {
   checkBotIdMock.mockReset();
+  headersMock.mockReset();
+  headersMock.mockResolvedValue(new Headers({ host: "spoke.example" }));
   for (const name of ENV_KEYS) delete process.env[name];
   process.env.VERCEL = "1";
   errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
@@ -78,10 +87,13 @@ describe("AC-1 — runBotCheck's verdict (#9889 D3, one rule for every write)",
       checkBotIdMock.mockResolvedValue(verdict);
       expect(await runBotCheck(CHECK)).toBe("bot");
       expect(warnSpy).toHaveBeenCalledTimes(1);
-      expect(warnSpy).toHaveBeenCalledWith("[bot-check] bot refused", {
-        path: "testAction",
-        outcome: "bot-detected",
-      });
+      expect(warnSpy).toHaveBeenCalledWith(
+        "[bot-check] bot refused",
+        expect.objectContaining({
+          path: "testAction",
+          outcome: "bot-detected",
+        }),
+      );
     },
   );
 
@@ -252,3 +264,234 @@ describe("AC-4 — the switches and BotID's client list", () => {
     expect(compileBotIdPath(entry?.path ?? "").test(pathname)).toBe(true);
   });
 });
+
+describe("#10715 — a refusal names its cause", () => {
+  const DIRECT = { host: "spoke.example" };
+  const PROXIED = {
+    host: "spoke.example",
+    "x-forwarded-host": "www.spoke.example",
+    "cf-ray": "8f2b-CLE",
+    cookie: "session=secret",
+    "x-is-human": "challenge-token",
+  };
+  const VERDICT = {
+    ...BOT,
+    verifiedBotName: undefined,
+    verifiedBotCategory: undefined,
+    classificationReason: "integrity-check-failed",
+  };
+  const FIX =
+    "Serve the site direct to Vercel: set its Cloudflare DNS record to DNS-only (no orange cloud), never behind a reverse proxy (#10715).";
+
+  /** Runs `run` in a fresh copy of the module, so its once-per-process flag starts unset. */
+  async function inFreshModule(
+    run: (fresh: typeof import("../bot-check")) => Promise<void>,
+  ): Promise<void> {
+    await jest.isolateModulesAsync(async () => {
+      await run(await import("../bot-check"));
+    });
+  }
+
+  it("a direct refusal logs the full shape: the verdict's detail, both hosts and proxied false", async () => {
+    headersMock.mockResolvedValue(new Headers(DIRECT));
+    checkBotIdMock.mockResolvedValue(VERDICT);
+    await inFreshModule(async (fresh) => {
+      expect(await fresh.runBotCheck(CHECK)).toBe("bot");
+    });
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy.mock.calls[0]).toStrictEqual([
+      "[bot-check] bot refused",
+      {
+        path: "testAction",
+        outcome: "bot-detected",
+        classificationReason: "integrity-check-failed",
+        bypassed: false,
+        isVerifiedBot: false,
+        host: "spoke.example",
+        forwardedHost: null,
+        proxied: false,
+      },
+    ]);
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("a proxied refusal logs proxied true and no header value but the two hosts", async () => {
+    headersMock.mockResolvedValue(new Headers(PROXIED));
+    checkBotIdMock.mockResolvedValue({ ...VERDICT, isVerifiedBot: true });
+    await inFreshModule(async (fresh) => {
+      expect(await fresh.runBotCheck(CHECK)).toBe("bot");
+    });
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy.mock.calls[0]).toStrictEqual([
+      "[bot-check] bot refused",
+      {
+        path: "testAction",
+        outcome: "bot-detected",
+        classificationReason: "integrity-check-failed",
+        bypassed: false,
+        isVerifiedBot: true,
+        host: "spoke.example",
+        forwardedHost: "www.spoke.example",
+        proxied: true,
+      },
+    ]);
+    const logged = JSON.stringify([warnSpy.mock.calls, errorSpy.mock.calls]);
+    for (const secret of ["8f2b-CLE", "session=secret", "challenge-token"]) {
+      expect(logged).not.toContain(secret);
+    }
+  });
+
+  it("a verdict with no reason logs classificationReason null", async () => {
+    checkBotIdMock.mockResolvedValue(BOT);
+    await inFreshModule(async (fresh) => {
+      expect(await fresh.runBotCheck(CHECK)).toBe("bot");
+    });
+    expect(warnSpy.mock.calls[0]?.[1]).toMatchObject({
+      classificationReason: null,
+      proxied: false,
+    });
+  });
+
+  it("headers it cannot read log null hosts and proxied false, and still refuse", async () => {
+    headersMock.mockImplementation(() => {
+      throw new Error("outside a request scope");
+    });
+    checkBotIdMock.mockResolvedValue(BOT);
+    await inFreshModule(async (fresh) => {
+      expect(await fresh.runBotCheck(CHECK)).toBe("bot");
+    });
+    expect(warnSpy.mock.calls[0]?.[1]).toMatchObject({
+      host: null,
+      forwardedHost: null,
+      proxied: false,
+    });
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ["a human", HUMAN, "pass"],
+    ["a bot", BOT, "bot"],
+  ] as const)(
+    "the first proxied check (%s) logs the reverse-proxy error once per process, naming the fix",
+    async (_label, verdict, outcome) => {
+      headersMock.mockResolvedValue(new Headers(PROXIED));
+      checkBotIdMock.mockResolvedValue(verdict);
+      await inFreshModule(async (fresh) => {
+        for (let i = 0; i < 3; i++) {
+          expect(await fresh.runBotCheck(CHECK)).toBe(outcome);
+        }
+      });
+      expect(errorSpy).toHaveBeenCalledTimes(1);
+      expect(errorSpy.mock.calls[0]).toStrictEqual([
+        "[bot-check] reverse proxy detected",
+        {
+          path: "testAction",
+          outcome: "proxied",
+          host: "spoke.example",
+          forwardedHost: "www.spoke.example",
+          fix: FIX,
+        },
+      ]);
+    },
+  );
+
+  it("a proxied check that throws still logs the reverse-proxy error, then the failure", async () => {
+    headersMock.mockResolvedValue(new Headers(PROXIED));
+    checkBotIdMock.mockRejectedValue(new Error("token abc"));
+    await inFreshModule(async (fresh) => {
+      expect(await fresh.runBotCheck(CHECK)).toBe("unavailable");
+    });
+    expect(errorSpy.mock.calls.map(([message]) => message)).toEqual([
+      "[bot-check] reverse proxy detected",
+      "[bot-check] bot check failed",
+    ]);
+  });
+
+  it("a direct check never logs the reverse-proxy error", async () => {
+    headersMock.mockResolvedValue(new Headers(DIRECT));
+    checkBotIdMock.mockResolvedValue(HUMAN);
+    await inFreshModule(async (fresh) => {
+      expect(await fresh.runBotCheck(CHECK)).toBe("pass");
+    });
+    expect(errorSpy).not.toHaveBeenCalled();
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("proxied changes no verdict: a proxied human passes, a proxied bot refuses", async () => {
+    headersMock.mockResolvedValue(new Headers(PROXIED));
+    await inFreshModule(async (fresh) => {
+      checkBotIdMock.mockResolvedValue(HUMAN);
+      expect(await fresh.runBotCheck(CHECK)).toBe("pass");
+      checkBotIdMock.mockResolvedValue(BOT);
+      expect(await fresh.runBotCheck(CHECK)).toBe("bot");
+    });
+  });
+});
+
+describe("#10715 — AILK_BOT_CHECK=observe runs the check and never refuses", () => {
+  it.each(["observe", " OBSERVE ", "Observe"])(
+    "AILK_BOT_CHECK=%j leaves the check on for both scopes",
+    (value) => {
+      process.env.AILK_BOT_CHECK = value;
+      expect(botCheckOn("write")).toBe(true);
+      expect(botCheckOn("booking")).toBe(true);
+    },
+  );
+
+  it.each([
+    ["a bot", BOT, true],
+    ["a human", HUMAN, false],
+  ] as const)(
+    "%s passes for every scope, logging the facts and isBot as observed",
+    async (_label, verdict, isBot) => {
+      process.env.AILK_BOT_CHECK = " Observe ";
+      headersMock.mockResolvedValue(new Headers({ host: "spoke.example" }));
+      checkBotIdMock.mockResolvedValue({
+        ...verdict,
+        classificationReason: "reason-x",
+      });
+      for (const scope of ["write", "booking"] as const) {
+        expect(await runBotCheck({ ...CHECK, scope })).toBe("pass");
+      }
+      expect(checkBotIdMock).toHaveBeenCalledTimes(2);
+      expect(warnSpy).toHaveBeenCalledTimes(2);
+      expect(warnSpy.mock.calls[0]).toStrictEqual([
+        "[bot-check] bot check observed",
+        {
+          path: "testAction",
+          outcome: "observed",
+          isBot,
+          classificationReason: "reason-x",
+          bypassed: false,
+          isVerifiedBot: false,
+          host: "spoke.example",
+          forwardedHost: null,
+          proxied: false,
+        },
+      ]);
+      expect(errorSpy).not.toHaveBeenCalled();
+    },
+  );
+
+  it("a check that throws logs the failure and passes", async () => {
+    process.env.AILK_BOT_CHECK = "observe";
+    checkBotIdMock.mockRejectedValue(new Error("token abc"));
+    expect(await runBotCheck(CHECK)).toBe("pass");
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy).toHaveBeenCalledWith("[bot-check] bot check failed", {
+      path: "testAction",
+      outcome: "bot-check-failed",
+      error: "Error",
+    });
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("AILK_BOOKING_BOT_CHECK=off still passes the booking without asking BotID", async () => {
+    process.env.AILK_BOT_CHECK = "observe";
+    process.env.AILK_BOOKING_BOT_CHECK = "off";
+    checkBotIdMock.mockResolvedValue(BOT);
+    expect(await runBotCheck({ ...CHECK, scope: "booking" })).toBe("pass");
+    expect(checkBotIdMock).not.toHaveBeenCalled();
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+});

package/templates/apps/web/lib/__tests__/in-page-magnet-self-request.test.ts

@@ -0,0 +1,92 @@
+/**
+ * @jest-environment node
+ */
+// #10553 — with AILK_API_URL unset the API client falls back to
+// localhost:3001; a site server bound to 3001 then fetched its own
+// /v1/flows/newsletter, whose render (the footer reads the magnet on every
+// page) fetched it again, without end. The page's flow read now makes no
+// request to its own address and renders without the magnet, and a hub that
+// does not answer is asked once however many renders read it.
+//
+// Through the real `@working-theory/api-client` (jest maps it to source) with
+// the global `fetch` stubbed; the Server Action modules are stubbed as in
+// in-page-magnet.test.ts.
+
+export {};
+
+// eslint-disable-next-line no-restricted-syntax -- test-seam mock: a "use server" boundary the module only binds
+jest.mock("../../app/[locale]/contact/contact.actions", () => ({
+  captureLeadAction: jest.fn(),
+}));
+// eslint-disable-next-line no-restricted-syntax -- test-seam mock: a "use server" boundary the module only binds
+jest.mock("../newsletter.actions", () => ({
+  subscribeNewsletterAction: jest.fn(),
+}));
+
+const ENV_KEYS = [
+  "AILK_API_URL",
+  "NEXT_PUBLIC_AILK_API_URL",
+  "NEXT_PUBLIC_API_URL",
+  "AILK_SPOKE_KEY",
+  "__NEXT_PRIVATE_ORIGIN",
+] as const;
+const priorEnv = new Map<string, string | undefined>(
+  ENV_KEYS.map((name) => [name, process.env[name]]),
+);
+const priorFetch = global.fetch;
+const fetchMock = jest.fn(async (_url: string) => {
+  throw new TypeError("fetch failed");
+});
+
+/** A fresh `in-page-magnet` module, so the shared read starts empty. */
+function freshModule(): typeof import("../in-page-magnet") {
+  let mod: typeof import("../in-page-magnet") | undefined;
+  jest.isolateModules(() => {
+    mod = jest.requireActual("../in-page-magnet");
+  });
+  if (mod === undefined) throw new Error("in-page-magnet did not load");
+  return mod;
+}
+
+beforeEach(() => {
+  for (const name of ENV_KEYS) delete process.env[name];
+  fetchMock.mockClear();
+  global.fetch = fetchMock as jest.Mock;
+});
+
+afterAll(() => {
+  global.fetch = priorFetch;
+  for (const [name, value] of priorEnv) {
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+  }
+});
+
+describe("the flow read with AILK_API_URL unset (#10553)", () => {
+  it("on a server bound to the fallback's port, makes no request to its own /v1 and renders without the magnet", async () => {
+    process.env.__NEXT_PRIVATE_ORIGIN = "http://localhost:3001";
+    const { readServedMagnet } = freshModule();
+
+    const renders = await Promise.all(
+      Array.from({ length: 20 }, () => readServedMagnet("newsletter")),
+    );
+
+    expect(renders.every((config) => config === null)).toBe(true);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("on any other port, asks the unanswering fallback once for the flow and renders without it", async () => {
+    process.env.__NEXT_PRIVATE_ORIGIN = "http://localhost:3000";
+    const { readServedMagnet } = freshModule();
+
+    const first = await readServedMagnet("newsletter");
+    const again = await Promise.all(
+      Array.from({ length: 20 }, () => readServedMagnet("newsletter")),
+    );
+
+    expect(first).toBeNull();
+    expect(again.every((config) => config === null)).toBe(true);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0]?.[0]).toBe("http://localhost:3001/v1/flows/newsletter");
+  });
+});

package/templates/apps/web/lib/__tests__/page-chrome.test.ts

@@ -18,6 +18,7 @@ import {
 import { ROUTES } from "@working-theory/templates/routes";
 
 import {
+  readClosingFooterSettings,
   readSiteChromeSettings,
   resolveChromePage,
   resolveHomeLayout,
@@ -346,6 +347,95 @@ describe("readSiteChromeSettings and resolveChromePage (#10049 AC-4)", () => {
     expect(warn).not.toHaveBeenCalled();
   });
 
+  describe("readClosingFooterSettings (#10550 AC-1)", () => {
+    // Each case's read is cached per call site only through React's `cache`,
+    // which is a no-op outside a request, and its warnings are once per
+    // process — so every case resets the module.
+    function fresh(): typeof import("../page-chrome") {
+      let mod: typeof import("../page-chrome") | undefined;
+      jest.isolateModules(() => {
+        mod = require("../page-chrome") as typeof import("../page-chrome");
+      });
+      return mod!;
+    }
+
+    const VALID_FOOTER = [
+      "footer:",
+      "  style: closing",
+      "  locality: Colorado Springs, CO",
+      "  actions:",
+      "    - label: Get in touch →",
+      "      href: /contact",
+      "    - label: See my pricing",
+      "      href: /pricing",
+      "  legalBar: true",
+    ];
+
+    it("reads the three settings beside the style", () => {
+      writeSite(VALID_FOOTER);
+      const mod = fresh();
+      expect(mod.readClosingFooterSettings()).toEqual({
+        locality: "Colorado Springs, CO",
+        actions: [
+          { label: "Get in touch →", href: "/contact" },
+          { label: "See my pricing", href: "/pricing" },
+        ],
+        legalBar: true,
+      });
+      expect(mod.readSiteChromeSettings().footerStyle).toBe("closing");
+      expect(warn).not.toHaveBeenCalled();
+    });
+
+    it("an invalid actions drops itself alone, with one warning that never echoes the value", () => {
+      writeSite([
+        "footer:",
+        "  style: closing",
+        "  locality: Colorado Springs, CO",
+        "  actions:",
+        "    - label: x",
+        "      href: https://x.test",
+        "  legalBar: true",
+      ]);
+      const mod = fresh();
+      const settings = mod.readClosingFooterSettings();
+      expect(settings.actions).toBeUndefined();
+      expect(settings.locality).toBe("Colorado Springs, CO");
+      expect(settings.legalBar).toBe(true);
+      expect(mod.readSiteChromeSettings().footerStyle).toBe("closing");
+      expect(warn).toHaveBeenCalledTimes(1);
+      const message = String(warn.mock.calls[0]?.[0]);
+      expect(message).toContain("footer.actions");
+      expect(message).not.toContain("https://x.test");
+    });
+
+    it("no footer key is the bar off and no warning", () => {
+      writeSite([]);
+      expect(fresh().readClosingFooterSettings()).toEqual({ legalBar: false });
+      expect(warn).not.toHaveBeenCalled();
+    });
+
+    it("an unknown footer key warns once under its path and keeps the style", () => {
+      writeSite(["footer:", "  style: closing", "  colour: red"]);
+      const mod = fresh();
+      expect(mod.readClosingFooterSettings()).toEqual({ legalBar: false });
+      expect(mod.readSiteChromeSettings().footerStyle).toBe("closing");
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(String(warn.mock.calls[0]?.[0])).toContain("footer.colour");
+    });
+
+    it("a footer that is not an object warns once under footer", () => {
+      writeSite(["footer: closing"]);
+      expect(fresh().readClosingFooterSettings()).toEqual({ legalBar: false });
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(String(warn.mock.calls[0]?.[0])).toContain("_site.mdx footer:");
+    });
+
+    it("an absent _site.mdx is the bar off and no warning", () => {
+      expect(readClosingFooterSettings()).toEqual({ legalBar: false });
+      expect(warn).not.toHaveBeenCalled();
+    });
+  });
+
   it("resolveChromePage reads a page's and the home's own chrome frontmatter, and never a blog post", async () => {
     writePage("AboutPage", "about", ["header: bare", "footer: centered"]);
     writePage("HomePage", "home", ["layout: deck"]);

package/templates/apps/web/lib/__tests__/relay.test.ts

@@ -214,6 +214,31 @@ describe("AC-1 — forwarding, one entry each", () => {
   });
 });
 
+describe("never this site's own address (#10553)", () => {
+  const priorOrigin = process.env.__NEXT_PRIVATE_ORIGIN;
+  afterEach(() => {
+    if (priorOrigin === undefined) delete process.env.__NEXT_PRIVATE_ORIGIN;
+    else process.env.__NEXT_PRIVATE_ORIGIN = priorOrigin;
+  });
+
+  it("answers 502 and calls nothing when the API address is this site's own host", async () => {
+    process.env.AILK_API_URL = SITE;
+    const res = await handleRelay(relayRequest("/v1/leads/submit"));
+    expect(res.status).toBe(502);
+    expect(await errorCode(res)).toBe("relay_unreachable");
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("answers 502 and calls nothing when AILK_API_URL is unset and the fallback is this server's own port", async () => {
+    delete process.env.AILK_API_URL;
+    process.env.__NEXT_PRIVATE_ORIGIN = "http://localhost:3001";
+    const res = await handleRelay(relayRequest("/v1/leads/submit"));
+    expect(res.status).toBe(502);
+    expect(await errorCode(res)).toBe("relay_unreachable");
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});
+
 describe("AC-2 — only the list", () => {
   it.each([
     ["POST", "/v1/workspaces"],
@@ -1010,10 +1035,10 @@ describe("the booking bot check (#9889)", () => {
       expect(checkBotIdMock).toHaveBeenCalledTimes(1);
       expect(checkBotIdMock.mock.calls[0]).toEqual([]);
       expect(warnSpy).toHaveBeenCalledTimes(1);
-      expect(warnSpy).toHaveBeenCalledWith("[relay] bot refused", {
-        path: BOOK,
-        outcome: "bot-detected",
-      });
+      expect(warnSpy).toHaveBeenCalledWith(
+        "[relay] bot refused",
+        expect.objectContaining({ path: BOOK, outcome: "bot-detected" }),
+      );
     });
   });
 
@@ -1290,10 +1315,10 @@ describe("the write bot check on the lead routes (#9255)", () => {
     expect(await errorCode(res)).toBe("bot_detected");
     expect(fetchMock).not.toHaveBeenCalled();
     expect(checkBotIdMock).toHaveBeenCalledTimes(1);
-    expect(warnSpy).toHaveBeenCalledWith("[relay] bot refused", {
-      path,
-      outcome: "bot-detected",
-    });
+    expect(warnSpy).toHaveBeenCalledWith(
+      "[relay] bot refused",
+      expect.objectContaining({ path, outcome: "bot-detected" }),
+    );
   });
 
   it.each(LEAD_ROUTES)(