create-ailk 0.29.1 → 0.31.0

package/templates/apps/web/lib/__tests__/site-identity-feature-list.test.ts

@@ -0,0 +1,196 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * The identity featureList under the database adapter (#10644 AC-2, D4): read
+ * through the content adapter when a page's JSON-LD is composed, never from a
+ * directory scan. Under the mdx adapter no reader is registered.
+ */
+import { mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { ContentAdapter } from "@working-theory/content-adapters";
+
+import { readFeatureListFromAdapter, readSiteIdentity } from "../site-identity";
+
+type PageRenderer = typeof import("@working-theory/page-renderer");
+
+// A spy on every directory read, so the no-scan case can see one.
+jest.mock("node:fs", () => {
+  const actual = jest.requireActual<typeof import("node:fs")>("node:fs");
+  return { ...actual, readdirSync: jest.fn(actual.readdirSync) };
+});
+
+const mockGetContentAdapter = jest.fn<Pick<ContentAdapter, "listPages">, []>();
+jest.mock("@working-theory/page-renderer", () => ({
+  ...jest.requireActual<PageRenderer>("@working-theory/page-renderer"),
+  getContentAdapter: () => mockGetContentAdapter(),
+}));
+
+type Row = { type: string; slug: string; title: string; sections?: unknown[] };
+
+function stubAdapter(rows: Partial<Record<string, Row[]>>): Pick<ContentAdapter, "listPages"> {
+  // eslint-disable-next-line no-restricted-syntax -- a partial row stub is not a full ContentPage; the reader reads only slug, title and sections
+  return {
+    listPages: jest.fn(async (type: string) => rows[type] ?? []),
+  } as unknown as Pick<ContentAdapter, "listPages">;
+}
+
+const feature = (titles: string[], variant?: string): unknown => ({
+  type: "feature",
+  data: { ...(variant ? { variant } : {}), features: titles.map((title) => ({ title })) },
+});
+
+const product = (slug: string, sections: unknown[]): Row => ({
+  type: "SoftwareProduct",
+  slug,
+  title: slug,
+  sections,
+});
+
+const PRODUCT_ROWS = {
+  SoftwareProduct: [
+    product("zeta", [feature(["Z1"])]),
+    product("alpha", [feature(["A1", "A2"]), feature(["S1"], "steps")]),
+  ],
+};
+
+describe("readFeatureListFromAdapter (#10644 D4)", () => {
+  it("the first product page in seed order gives its features, steps excluded", async () => {
+    expect(await readFeatureListFromAdapter(stubAdapter(PRODUCT_ROWS), "en")).toEqual(["A1", "A2"]);
+  });
+
+  it("orders by file name, so a-b.mdx comes before a.mdx", async () => {
+    const adapter = stubAdapter({
+      SoftwareProduct: [product("a", [feature(["from-a"])]), product("a-b", [feature(["from-a-b"])])],
+    });
+    expect(await readFeatureListFromAdapter(adapter, "en")).toEqual(["from-a-b"]);
+  });
+
+  it("with no product page, the Feature page titles in seed order, empty titles dropped", async () => {
+    const adapter = stubAdapter({
+      Feature: [
+        { type: "Feature", slug: "b-feature", title: "Beta" },
+        { type: "Feature", slug: "a-feature", title: "Alpha" },
+        { type: "Feature", slug: "c-feature", title: "" },
+      ],
+    });
+    expect(await readFeatureListFromAdapter(adapter, "en")).toEqual(["Alpha", "Beta"]);
+  });
+
+  it("with neither, an empty list", async () => {
+    expect(await readFeatureListFromAdapter(stubAdapter({}), "en")).toEqual([]);
+  });
+});
+
+describe("the featureList registration with no content directory (#10644 AC-2)", () => {
+  const ORIGIN = "https://example.com";
+  let root: string;
+  const saved = {
+    adapter: process.env.CONTENT_ADAPTER,
+    contentRoot: process.env.AILK_CONTENT_ROOT,
+    siteUrl: process.env.NEXT_PUBLIC_SITE_URL,
+  };
+
+  function restore(name: string, value: string | undefined): void {
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+  }
+
+  let renderer: PageRenderer | undefined;
+
+  /** Load site-identity afresh; return the page-renderer instance it registered with. */
+  function loadSiteIdentity(): PageRenderer {
+    jest.isolateModules(() => {
+      jest.requireActual("../site-identity");
+      renderer = jest.requireMock<PageRenderer>("@working-theory/page-renderer");
+    });
+    return renderer!;
+  }
+
+  const appNode = (result: Record<string, unknown>): Record<string, unknown> | undefined =>
+    ((result["@graph"] ?? []) as Array<Record<string, unknown>>).find(
+      (node) => node["@type"] === "SoftwareApplication",
+    );
+
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "ailk-10644-site-"));
+    writeFileSync(
+      join(root, "_site.mdx"),
+      [
+        "---",
+        "siteName: Acme",
+        `baseUrl: ${ORIGIN}`,
+        "siteIdentity:",
+        "  kind: Organization",
+        "  name: Acme Inc.",
+        `  url: ${ORIGIN}`,
+        "  secondary:",
+        "    kind: SoftwareApplication",
+        "    name: Acme App",
+        `    url: ${ORIGIN}/app`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    process.env.AILK_CONTENT_ROOT = root;
+    process.env.NEXT_PUBLIC_SITE_URL = ORIGIN;
+    mockGetContentAdapter.mockReset();
+    mockGetContentAdapter.mockReturnValue(stubAdapter(PRODUCT_ROWS));
+  });
+
+  afterEach(() => {
+    renderer?.setSiteFeatureListReader(undefined);
+    renderer?.setSiteIdentity(undefined);
+    renderer = undefined;
+    rmSync(root, { recursive: true, force: true });
+    restore("CONTENT_ADAPTER", saved.adapter);
+    restore("AILK_CONTENT_ROOT", saved.contentRoot);
+    restore("NEXT_PUBLIC_SITE_URL", saved.siteUrl);
+  });
+
+  it("database: readSiteIdentity carries no featureList and scans no directory under the root", () => {
+    process.env.CONTENT_ADAPTER = "database";
+    const readdir = jest.mocked(readdirSync);
+    readdir.mockClear();
+    const registration = readSiteIdentity(root);
+    expect(registration).toBeDefined();
+    expect(registration).not.toHaveProperty("featureList");
+    const underRoot = readdir.mock.calls.filter(([path]) => String(path).startsWith(root));
+    expect(underRoot).toEqual([]);
+  });
+
+  it("database: the composed SoftwareApplication carries the adapter's featureList", async () => {
+    process.env.CONTENT_ADAPTER = "database";
+    const renderer = loadSiteIdentity();
+    const result = await renderer.pageToJsonLd(
+      { type: "AboutPage", slug: "about", title: "About" } as Parameters<PageRenderer["pageToJsonLd"]>[0],
+      "en",
+    );
+    expect(appNode(result as Record<string, unknown>)?.["featureList"]).toEqual(["A1", "A2"]);
+  });
+
+  it("mdx: no reader is registered, and the adapter is never read", async () => {
+    delete process.env.CONTENT_ADAPTER;
+    const renderer = loadSiteIdentity();
+    const result = await renderer.pageToJsonLd(
+      { type: "AboutPage", slug: "about", title: "About" } as Parameters<PageRenderer["pageToJsonLd"]>[0],
+      "en",
+      [],
+      {
+        siteName: "Acme",
+        baseUrl: ORIGIN,
+        identity: {
+          kind: "Organization",
+          name: "Acme Inc.",
+          url: ORIGIN,
+          secondary: { kind: "SoftwareApplication", name: "Acme App", url: `${ORIGIN}/app` },
+        },
+      },
+    );
+    expect(appNode(result as Record<string, unknown>)).not.toHaveProperty("featureList");
+    expect(mockGetContentAdapter).toHaveBeenCalledTimes(0);
+  });
+});

package/templates/apps/web/lib/__tests__/structured-data.test.tsx

@@ -632,7 +632,17 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
       return;
     }
     const exempt = exemption(route, src);
-    const identity = routeIdentity(src);
+    // #10552 (merged in #10586) put a program-Event renderPage ahead of the
+    // meet hub's BookCall one in `[slug]/[detail]`. The params this check
+    // builds for that route are the meet hub's (`renderRoute`), so its checked
+    // type stays BookCall; the Event branch is covered by the page's own suite.
+    if (route === "[slug]/[detail]") {
+      expect(src).toMatch(/renderPage\(\{\s*type:\s*"BookCall",\s*slug:\s*detail\b/);
+    }
+    const identity =
+      route === "[slug]/[detail]"
+        ? { type: "BookCall", slug: null }
+        : routeIdentity(src);
     if (exempt !== undefined) {
       // Declared, with a reason, in NO_STRUCTURED_DATA_ROUTES above. The
       // reason is false for a route that does render through renderPage —

package/templates/apps/web/lib/auth-routes.ts

@@ -4,8 +4,8 @@
  * ONE module, so the list `app/[locale]/layout.tsx` branches on to drop the
  * marketing chrome and the list the `(auth)` group's page segments exist at
  * cannot drift. A route group contributes no URL segment, so these are the
- * real paths: `/sign-in`, `/sign-up`, `/forgot-password`, `/reset-password`
- * and `/verify-email`, each under next-intl's `as-needed` prefixing (bare for
+ * real paths: `/sign-in`, `/sign-up`, `/forgot-password`, `/reset-password`,
+ * `/verify-email` and the MCP consent step `/consent` (#10357), each under next-intl's `as-needed` prefixing (bare for
  * the default locale, `/<locale>/…` otherwise).
  *
  * `isAccountPath()` (#7430, spec 7423 D4) is the same predicate for the
@@ -21,13 +21,15 @@
  * No Next.js import — pure functions, asserted directly by their own suite.
  */
 
-/** The five segments the `(auth)` route group serves. */
+/** The six segments the `(auth)` route group serves. */
 export const AUTH_SEGMENTS = [
   "sign-in",
   "sign-up",
   "forgot-password",
   "reset-password",
   "verify-email",
+  // The MCP consent step (#10357 D6).
+  "consent",
 ] as const;
 
 export type AuthSegment = (typeof AUTH_SEGMENTS)[number];

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

@@ -12,11 +12,24 @@
  * a check that throws, answers no boolean or takes over 5 seconds is
  * `unavailable`. It runs only on Vercel (`VERCEL=1`); `AILK_BOT_CHECK=off`
  * turns every check off and `AILK_BOOKING_BOT_CHECK=off` the booking's alone.
+ * `AILK_BOT_CHECK=observe` (#10715) runs the check and logs what it found as
+ * `observed`, but passes every write — for diagnosis, never for production.
  *
- * NO SECRET IS LOGGED. A refusal logs `{ path, outcome }` and, for a failed
- * check, the error's name — never its message.
+ * A BotID-protected site MUST be reached directly (#10715): Cloudflare
+ * DNS-only, no reverse proxy in front of Vercel. Behind a proxy the browser
+ * solves BotID's challenge but the write reaches Vercel from the proxy's
+ * egress, so BotID judges every real visitor a bot. A request carrying
+ * `cf-ray` is `proxied`, and the first one per process logs an error naming
+ * that fix.
+ *
+ * NO SECRET IS LOGGED. A refusal logs `{ path, outcome }`, BotID's
+ * `classificationReason`, `bypassed` and `isVerifiedBot`, the request's
+ * `host` and `x-forwarded-host` and whether it was `proxied` — no other
+ * header value, no form field — and, for a failed check, the error's name —
+ * never its message.
  */
 import { checkBotId } from "botid/server";
+import { headers } from "next/headers";
 
 export type BotCheckScope = "write" | "booking";
 export type BotCheckOutcome = "pass" | "bot" | "unavailable";
@@ -46,6 +59,11 @@ function switchedOff(scope: BotCheckScope): boolean {
   );
 }
 
+/** `AILK_BOT_CHECK=observe`: the check runs and logs, but never refuses. */
+function observing(): boolean {
+  return process.env.AILK_BOT_CHECK?.trim().toLowerCase() === "observe";
+}
+
 /** True when the check runs for `scope`. Read on every call, never cached. */
 export function botCheckOn(scope: BotCheckScope): boolean {
   return process.env.VERCEL === "1" && !switchedOff(scope);
@@ -73,13 +91,21 @@ function namedError(name: string): Error {
   return err;
 }
 
+/** BotID's answer: `isBot` decides, the rest says why. */
+interface BotVerdict {
+  isBot: boolean;
+  classificationReason: string | null;
+  bypassed: boolean | null;
+  isVerifiedBot: boolean | null;
+}
+
 /**
- * BotID's verdict on this request: `true` for a bot, `false` for a human.
- * Throws `TimeoutError` past `BOT_CHECK_TIMEOUT_MS` and `InvalidVerdictError`
- * when `isBot` is not a boolean, as `checkBotId` returns for an error answer
- * from Vercel.
+ * BotID's verdict on this request: `isBot` is `true` for a bot, `false` for a
+ * human. Throws `TimeoutError` past `BOT_CHECK_TIMEOUT_MS` and
+ * `InvalidVerdictError` when `isBot` is not a boolean, as `checkBotId`
+ * returns for an error answer from Vercel.
  */
-async function isBotVerdict(): Promise<boolean> {
+async function botVerdict(): Promise<BotVerdict> {
   let timer: ReturnType<typeof setTimeout> | undefined;
   try {
     const verdict = await Promise.race([
@@ -91,14 +117,67 @@ async function isBotVerdict(): Promise<boolean> {
         );
       }),
     ]);
-    const isBot = (verdict as { isBot?: unknown } | undefined)?.isBot;
+    const answer = verdict as Record<string, unknown> | undefined;
+    const isBot = answer?.isBot;
     if (typeof isBot !== "boolean") throw namedError("InvalidVerdictError");
-    return isBot;
+    const reason = answer?.classificationReason;
+    return {
+      isBot,
+      classificationReason: typeof reason === "string" ? reason : null,
+      bypassed: typeof answer?.bypassed === "boolean" ? answer.bypassed : null,
+      isVerifiedBot:
+        typeof answer?.isVerifiedBot === "boolean"
+          ? answer.isVerifiedBot
+          : null,
+    };
   } finally {
     clearTimeout(timer);
   }
 }
 
+/** The only request facts a log carries: the two hosts and a proxy marker. */
+interface RequestFacts {
+  host: string | null;
+  forwardedHost: string | null;
+  proxied: boolean;
+}
+
+/** Read as `checkBotId` reads them; unreadable headers are no facts, never a throw. */
+async function requestFacts(): Promise<RequestFacts> {
+  try {
+    const h = await headers();
+    return {
+      host: h.get("host"),
+      forwardedHost: h.get("x-forwarded-host"),
+      proxied: h.has("cf-ray"),
+    };
+  } catch {
+    return { host: null, forwardedHost: null, proxied: false };
+  }
+}
+
+const PROXY_FIX =
+  "Serve the site direct to Vercel: set its Cloudflare DNS record to DNS-only (no orange cloud), never behind a reverse proxy (#10715).";
+
+let warnedProxied = false;
+
+/** A proxied request makes BotID refuse real visitors; say so once per process. */
+function warnProxiedOnce(
+  source: string,
+  target: string,
+  facts: RequestFacts,
+): void {
+  if (warnedProxied) return;
+  warnedProxied = true;
+  console.error(`[${source}] reverse proxy detected`, {
+    path: target,
+    outcome: "proxied",
+    host: facts.host,
+    forwardedHost: facts.forwardedHost,
+    fix: PROXY_FIX,
+  });
+}
+
 /**
  * The check for one write. `source` names the log prefix and `target` the
  * relayed path or the action's name — never a field value. Never throws.
@@ -116,21 +195,42 @@ export async function runBotCheck({
     warnBotCheckInactiveOnce(scope);
     return "pass";
   }
-  let isBot: boolean;
+  const observe = observing();
+  let verdict: BotVerdict | undefined;
+  let failure: unknown;
   try {
-    isBot = await isBotVerdict();
+    verdict = await botVerdict();
   } catch (err) {
+    failure = err;
+  }
+  // Read after the verdict, so the timeout starts with the check.
+  const facts = await requestFacts();
+  if (facts.proxied) warnProxiedOnce(source, target, facts);
+  if (!verdict) {
     console.error(`[${source}] bot check failed`, {
       path: target,
       outcome: "bot-check-failed",
-      error: err instanceof Error ? err.name : "unknown",
+      error: failure instanceof Error ? failure.name : "unknown",
     });
-    return "unavailable";
+    return observe ? "pass" : "unavailable";
+  }
+  const { isBot, ...detail } = verdict;
+  if (observe) {
+    console.warn(`[${source}] bot check observed`, {
+      path: target,
+      outcome: "observed",
+      isBot,
+      ...detail,
+      ...facts,
+    });
+    return "pass";
   }
   if (isBot) {
     console.warn(`[${source}] bot refused`, {
       path: target,
       outcome: "bot-detected",
+      ...detail,
+      ...facts,
     });
     return "bot";
   }

package/templates/apps/web/lib/in-page-magnet.ts

@@ -325,6 +325,8 @@ export interface NewsletterSignupOptions {
   /** The footer's compact form: stacked, the label `sr-only`, the placeholder naming the field. */
   compact?: boolean;
   className?: string;
+  /** #10629 D4 — the consent gate; the bound newsletter section passes `"on-submit"`. Omitted → the block's default. */
+  consentGate?: "disable" | "on-submit";
 }
 
 /**
@@ -335,7 +337,7 @@ export interface NewsletterSignupOptions {
  */
 export function newsletterSignup(
   view: InPageView & { form: NewsletterFormView },
-  { locale, fallbackEmail, compact = false, className }: NewsletterSignupOptions,
+  { locale, fallbackEmail, compact = false, className, consentGate }: NewsletterSignupOptions,
 ): ReactElement {
   const { form, ending } = view;
   const placeholder = form.placeholder ?? (compact ? form.label : undefined);
@@ -356,6 +358,7 @@ export function newsletterSignup(
     }),
     ...(fallbackEmail !== undefined && { fallbackEmail }),
     ...(className !== undefined && { className }),
+    ...(consentGate !== undefined && { consentGate }),
   });
 }