create-ailk 0.29.0 → 0.30.0

package/templates/apps/web/app/[locale]/(auth)/consent/__tests__/consent-actions.test.ts

@@ -0,0 +1,56 @@
+/**
+ * @jest-environment node
+ *
+ * `decideConsent` — the consent page's Allow and Deny (#10357 D6). `auth` is
+ * mocked; `POST /mcp/consent` runs for real in
+ * `__tests__/auth/mcp-oauth-flow.test.ts`. This suite proves the fallback
+ * redirect is always a path on this site.
+ */
+const mockConsent = jest.fn();
+const mockRedirect = jest.fn();
+
+// eslint-disable-next-line no-restricted-syntax -- #507: auth.ts loads ESM-only better-auth; its consent endpoint runs for real in mcp-oauth-flow.test.ts.
+jest.mock("../../../../../auth", () => ({
+  auth: { api: { mcpConsent: (...args: unknown[]) => mockConsent(...args) } },
+}));
+
+jest.mock("next/headers", () => ({ headers: jest.fn().mockResolvedValue(new Headers()) }));
+
+jest.mock("next/navigation", () => ({ redirect: (...args: unknown[]) => mockRedirect(...args) }));
+
+import { decideConsent } from "../consent.actions";
+
+function form(values: Record<string, string>): FormData {
+  const data = new FormData();
+  for (const [key, value] of Object.entries(values)) data.append(key, value);
+  return data;
+}
+
+beforeEach(() => {
+  mockConsent.mockReset();
+  mockRedirect.mockReset();
+});
+
+it("goes to the client's callback when the consent endpoint answers one", async () => {
+  mockConsent.mockResolvedValue({ redirectURI: "http://127.0.0.1:53682/callback?code=c" });
+  await decideConsent(form({ consent_code: "abc", locale: "en", decision: "deny" }));
+  expect(mockRedirect).toHaveBeenCalledWith("http://127.0.0.1:53682/callback?code=c");
+});
+
+it("returns to this site's consent page on a refusal", async () => {
+  mockConsent.mockRejectedValue(new Error("refused"));
+  await decideConsent(form({ consent_code: "abc", locale: "en", decision: "allow" }));
+  expect(mockRedirect).toHaveBeenCalledWith(expect.stringMatching(/^\/(en\/)?consent\?consent_code=abc$/));
+});
+
+it.each(["/evil.example", "//evil.example", "en/../..", "https://evil.example"])(
+  "never builds the fallback from a posted locale of %s",
+  async (locale) => {
+    mockConsent.mockRejectedValue(new Error("refused"));
+    await decideConsent(form({ consent_code: "abc", locale, decision: "allow" }));
+    const target = String(mockRedirect.mock.calls[0]?.[0]);
+    expect(target.startsWith("//")).toBe(false);
+    expect(target).not.toContain("evil.example");
+    expect(target).toMatch(/^\/(en\/)?consent\?consent_code=abc$/);
+  },
+);

package/templates/apps/web/app/[locale]/(auth)/consent/__tests__/page.test.tsx

@@ -0,0 +1,164 @@
+/**
+ * The MCP consent page (#10357 D6, AC-6). `auth` is mocked — the endpoints it
+ * calls run for real in `__tests__/auth/mcp-oauth-flow.test.ts`; this suite
+ * proves what the page renders from their answer and what it never reads.
+ *
+ * `next-intl/server` is mocked globally (apps/web/__tests__/setup.ts) against
+ * the real en.json.
+ */
+import { fireEvent, render, screen } from "@testing-library/react";
+
+const mockGetSession = jest.fn();
+const mockDetails = jest.fn();
+
+// eslint-disable-next-line no-restricted-syntax -- #507: auth.ts loads ESM-only better-auth; its consent endpoints run for real in mcp-oauth-flow.test.ts.
+jest.mock("../../../../../auth", () => ({
+  auth: {
+    api: {
+      getSession: (...args: unknown[]) => mockGetSession(...args),
+      mcpConsentDetails: (...args: unknown[]) => mockDetails(...args),
+    },
+  },
+}));
+
+// eslint-disable-next-line no-restricted-syntax -- #507: the server action imports auth.ts (ESM-only better-auth).
+jest.mock("../consent.actions", () => ({ decideConsent: jest.fn() }));
+
+jest.mock("next/headers", () => ({
+  headers: jest.fn().mockResolvedValue(new Headers({ cookie: "session=1" })),
+}));
+
+jest.mock("better-auth/react", () => ({
+  __esModule: true,
+  createAuthClient: () => ({ signOut: jest.fn() }),
+}));
+
+// The shared mock neither interpolates nor reads nested keys; this page shows
+// the email, the client name and the scope labels, so this suite's mock does.
+jest.mock("next-intl/server", () => {
+  const catalog = jest.requireActual("../../../../../messages/en.json") as Record<string, unknown>;
+  return {
+    getTranslations: async ({ namespace }: { namespace: string }) =>
+      (key: string, values: Record<string, string> = {}) => {
+        const found = `${namespace}.${key}`
+          .split(".")
+          .reduce<unknown>((node, part) => (node as Record<string, unknown> | undefined)?.[part], catalog);
+        return String(found ?? `${namespace}.${key}`).replace(/\{(\w+)\}/g, (_, name: string) => values[name] ?? "");
+      },
+  };
+});
+
+jest.mock("next/navigation", () => ({
+  useRouter: () => ({ push: jest.fn(), refresh: jest.fn() }),
+  redirect: jest.fn(),
+}));
+
+import en from "../../../../../messages/en.json";
+import ConsentPage, { generateMetadata } from "../page";
+
+const params = Promise.resolve({ locale: "en" });
+const MEMBER_SCOPES = ["ailk:people-read", "ailk:member-pieces-manage", "ailk:people-memory-propose", "ailk:inbox-act"];
+const t = en.mcpConsent;
+
+const twoWorkspaces = {
+  client: { name: "Some App", redirectOrigin: "http://127.0.0.1:53682" },
+  workspaces: [
+    { id: "wksp_a", name: "Alpha", organizationName: "Alpha Co", role: "member", offered: MEMBER_SCOPES },
+    { id: "wksp_b", name: "Beta", organizationName: "Beta Co", role: "member", offered: MEMBER_SCOPES },
+  ],
+};
+
+async function renderPage(query: Record<string, string> = { consent_code: "code-1" }) {
+  render(await ConsentPage({ params, searchParams: Promise.resolve(query) }));
+}
+
+beforeEach(() => {
+  mockGetSession.mockResolvedValue({ user: { email: "person@example.test" } });
+  mockDetails.mockResolvedValue(twoWorkspaces);
+});
+
+describe("the consent page (#10357 AC-6)", () => {
+  it("names the signed-in person, the client's own claim and where the code goes", async () => {
+    await renderPage();
+    expect(screen.getByTestId("mcp-consent-signed-in")).toHaveTextContent("person@example.test");
+    expect(screen.getByTestId("mcp-consent-client")).toHaveTextContent(
+      t.clientClaim.replace("{name}", "Some App"),
+    );
+    expect(screen.getByTestId("mcp-consent-redirect-origin")).toHaveTextContent("http://127.0.0.1:53682");
+    expect(screen.getByTestId("mcp-consent-sign-out")).toBeInTheDocument();
+  });
+
+  it("renders one radio per workspace, none checked when there are two, and Allow disabled", async () => {
+    await renderPage();
+    for (const id of ["wksp_a", "wksp_b"]) {
+      expect(screen.getByTestId(`mcp-consent-workspace-${id}`)).toHaveAttribute("aria-checked", "false");
+    }
+    expect(screen.getByTestId("mcp-consent-allow")).toBeDisabled();
+    expect(screen.queryByTestId("mcp-consent-scope-people-read")).toBeNull();
+  });
+
+  it("on choosing a workspace shows its offered scopes unticked, the member-reads line, and enables Allow", async () => {
+    await renderPage();
+    fireEvent.click(screen.getByTestId("mcp-consent-workspace-wksp_b"));
+    for (const scope of MEMBER_SCOPES) {
+      const permission = scope.slice("ailk:".length);
+      expect(screen.getByTestId(`mcp-consent-scope-${permission}`)).toHaveAttribute("aria-checked", "false");
+    }
+    expect(screen.queryByTestId("mcp-consent-scope-content-edit")).toBeNull();
+    expect(screen.getByText(t.scopes["people-read"])).toBeInTheDocument();
+    expect(screen.getByTestId("mcp-consent-member-reads")).toHaveTextContent(t.memberReads);
+    expect(screen.getByTestId("mcp-consent-allow")).not.toBeDisabled();
+  });
+
+  it("pre-selects the only workspace", async () => {
+    mockDetails.mockResolvedValue({ ...twoWorkspaces, workspaces: [twoWorkspaces.workspaces[0]] });
+    await renderPage();
+    expect(screen.getByTestId("mcp-consent-workspace-wksp_a")).toHaveAttribute("aria-checked", "true");
+    expect(screen.getByTestId("mcp-consent-allow")).not.toBeDisabled();
+  });
+
+  it("reads only consent_code from its query — never a client-controlled scope or client_id", async () => {
+    await renderPage({ consent_code: "code-1", scope: "ailk:content-edit", client_id: "evil" });
+    expect(mockDetails).toHaveBeenCalledWith(
+      expect.objectContaining({ query: { consent_code: "code-1" } }),
+    );
+    fireEvent.click(screen.getByTestId("mcp-consent-workspace-wksp_a"));
+    expect(screen.queryByTestId("mcp-consent-scope-content-edit")).toBeNull();
+    expect(document.body.textContent).not.toContain(t.scopes["content-edit"]);
+    expect(document.body.textContent).not.toContain("evil");
+  });
+
+  it("has Allow and Deny as 44 px buttons in one form", async () => {
+    await renderPage();
+    expect(screen.getByTestId("mcp-consent-form")).toContainElement(screen.getByTestId("mcp-consent-deny"));
+    expect(screen.getByTestId("mcp-consent-deny").className).toContain("control-height-big");
+  });
+
+  it("renders the unavailable line and no form when details are refused", async () => {
+    mockDetails.mockRejectedValue(new Error("invalid_request"));
+    await renderPage();
+    expect(screen.getByTestId("mcp-consent-unavailable")).toHaveTextContent(t.unavailable);
+    expect(screen.queryByTestId("mcp-consent-form")).toBeNull();
+  });
+
+  it("renders the unavailable line with no session, and without a consent_code", async () => {
+    mockGetSession.mockResolvedValue(null);
+    await renderPage();
+    expect(screen.getByTestId("mcp-consent-unavailable")).toBeInTheDocument();
+    mockGetSession.mockResolvedValue({ user: { email: "person@example.test" } });
+  });
+
+  it("offers Deny only when the person has no workspace", async () => {
+    mockDetails.mockResolvedValue({ ...twoWorkspaces, workspaces: [] });
+    await renderPage();
+    expect(screen.getByTestId("mcp-consent-no-workspace")).toHaveTextContent(t.noWorkspace);
+    expect(screen.queryByTestId("mcp-consent-allow")).toBeNull();
+    expect(screen.getByTestId("mcp-consent-deny")).toBeInTheDocument();
+  });
+
+  it("is noindex and sends no cross-site referrer", async () => {
+    const metadata = await generateMetadata({ params, searchParams: Promise.resolve({}) });
+    expect(metadata.robots).toEqual({ index: false, follow: false });
+    expect(metadata.referrer).toBe("same-origin");
+  });
+});

package/templates/apps/web/app/[locale]/(auth)/consent/consent-form.tsx

@@ -0,0 +1,132 @@
+"use client"; // the workspace choice decides which scopes show and whether Allow is enabled
+
+/**
+ * The consent page's client island (#10357 D6): the workspace radio list, the
+ * chosen workspace's offered scopes as checkboxes — none ticked — and Allow,
+ * disabled until a workspace is chosen. Deliberate selection is the defence
+ * against a phished authorization (SEC-10357-11, -13). Strings arrive
+ * translated from the server page.
+ */
+import {
+  Button,
+  Checkbox,
+  Input,
+  Label,
+  RadioGroup,
+  RadioGroupItem,
+  Text,
+} from "@working-theory/ui/primitives";
+import type { ReactElement } from "react";
+import { useState } from "react";
+
+import { decideConsent } from "./consent.actions";
+
+export interface ConsentWorkspace {
+  id: string;
+  name: string;
+  organizationName: string;
+  /** Each offered scope with its label. */
+  offered: Array<{ scope: string; permission: string; label: string }>;
+}
+
+export interface ConsentFormText {
+  workspaceLegend: string;
+  scopesLegend: string;
+  memberReads: string;
+  noScopes: string;
+  allow: string;
+  deny: string;
+}
+
+export interface ConsentFormProps {
+  consentCode: string;
+  locale: string;
+  workspaces: ConsentWorkspace[];
+  text: ConsentFormText;
+}
+
+export function ConsentForm({ consentCode, locale, workspaces, text }: ConsentFormProps): ReactElement {
+  const [workspaceId, setWorkspaceId] = useState<string>(
+    workspaces.length === 1 ? (workspaces[0]?.id ?? "") : "",
+  );
+  const chosen = workspaces.find((w) => w.id === workspaceId);
+
+  return (
+    <form action={decideConsent} className="flex flex-col gap-6" data-testid="mcp-consent-form">
+      <Input type="hidden" name="consent_code" value={consentCode} />
+      <Input type="hidden" name="locale" value={locale} />
+      {workspaces.length > 0 ? (
+        <div className="flex flex-col gap-3">
+          <Text as="p" variant="body-sm" className="font-semibold">
+            {text.workspaceLegend}
+          </Text>
+          <RadioGroup
+            name="workspace_id"
+            value={workspaceId}
+            onValueChange={setWorkspaceId}
+            aria-label={text.workspaceLegend}
+          >
+            {workspaces.map((w) => (
+              <div key={w.id} className="flex min-h-11 items-center gap-3">
+                <RadioGroupItem
+                  id={`mcp-consent-ws-${w.id}`}
+                  value={w.id}
+                  data-testid={`mcp-consent-workspace-${w.id}`}
+                />
+                <Label htmlFor={`mcp-consent-ws-${w.id}`}>
+                  {/* i18n-allow: a separator between two data values */}
+                  {w.name} · {w.organizationName}
+                </Label>
+              </div>
+            ))}
+          </RadioGroup>
+        </div>
+      ) : null}
+      {chosen ? (
+        <div className="flex flex-col gap-3">
+          <Text as="p" variant="body-sm" className="font-semibold">
+            {text.scopesLegend}
+          </Text>
+          {chosen.offered.length === 0 ? (
+            <Text as="p" variant="body-sm" tone="muted">
+              {text.noScopes}
+            </Text>
+          ) : (
+            chosen.offered.map((o) => (
+              <div key={o.scope} className="flex min-h-11 items-center gap-3">
+                <Checkbox
+                  id={`mcp-consent-scope-${o.permission}`}
+                  name="scopes"
+                  value={o.scope}
+                  defaultChecked={false}
+                  data-testid={`mcp-consent-scope-${o.permission}`}
+                />
+                <Label htmlFor={`mcp-consent-scope-${o.permission}`}>{o.label}</Label>
+              </div>
+            ))
+          )}
+          <Text as="p" variant="body-sm" tone="muted" data-testid="mcp-consent-member-reads">
+            {text.memberReads}
+          </Text>
+        </div>
+      ) : null}
+      <div className="flex flex-wrap gap-3">
+        {workspaces.length > 0 ? (
+          <Button
+            type="submit"
+            name="decision"
+            value="allow"
+            size="big"
+            disabled={!chosen}
+            data-testid="mcp-consent-allow"
+          >
+            {text.allow}
+          </Button>
+        ) : null}
+        <Button type="submit" name="decision" value="deny" variant="secondary" size="big" data-testid="mcp-consent-deny">
+          {text.deny}
+        </Button>
+      </div>
+    </form>
+  );
+}

package/templates/apps/web/app/[locale]/(auth)/consent/consent.actions.ts

@@ -0,0 +1,51 @@
+"use server";
+
+/**
+ * `decideConsent` — the consent page's Allow and Deny (#10357 D6).
+ *
+ * Hands the person's choice to AILK's `POST /mcp/consent` in-process
+ * (`auth.api.mcpConsent`), which checks the session, the signed consent
+ * cookie and the role bound on every scope, and answers the client's own
+ * callback URL. Next's Server Action origin check plus that cookie match make
+ * a cross-site submit fail. A refusal returns to the page, which then renders
+ * what is still true.
+ */
+import { localeHref } from "@working-theory/ui";
+import { headers } from "next/headers";
+import { redirect } from "next/navigation";
+
+import { auth } from "../../../../auth";
+
+const LOCALE_PATTERN = /^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/;
+
+export async function decideConsent(formData: FormData): Promise<void> {
+  const field = (name: string): string => {
+    const value = formData.get(name);
+    return typeof value === "string" ? value : "";
+  };
+  const consentCode = field("consent_code");
+  // The fallback redirect is built from it, so only a locale-shaped value
+  // counts: `/evil.example` would make `//evil.example/…`.
+  const locale = LOCALE_PATTERN.test(field("locale")) ? field("locale") : "en";
+  const accept = formData.get("decision") === "allow";
+  const workspaceId = formData.get("workspace_id");
+  const scopes = formData.getAll("scopes").filter((s): s is string => typeof s === "string");
+
+  let redirectURI: string | null;
+  try {
+    const answer = await auth.api.mcpConsent({
+      headers: await headers(),
+      body: {
+        consent_code: consentCode,
+        accept,
+        ...(accept && typeof workspaceId === "string" ? { workspace_id: workspaceId, scopes } : {}),
+      },
+    });
+    redirectURI = answer.redirectURI;
+  } catch {
+    redirectURI = null;
+  }
+  redirect(
+    redirectURI ?? localeHref(locale, `/consent?consent_code=${encodeURIComponent(consentCode)}`),
+  );
+}

package/templates/apps/web/app/[locale]/(auth)/consent/page.tsx

@@ -0,0 +1,144 @@
+/**
+ * `/[locale]/consent` — the MCP consent step (#10357 D6).
+ *
+ * The `mcp` plugin sends every authorization here (AILK's before-hook forces
+ * `prompt=consent`, D2) with a `consent_code` and a signed cookie. The page
+ * reads ONLY `consent_code` from its query — never `client_id` or `scope`,
+ * which the client controls — and asks AILK's `GET /mcp/consent-details`
+ * in-process. That endpoint checks the session, the cookie and that the code
+ * was issued to this person, and answers the client's self-claimed name,
+ * where the code will go, and each workspace with the scopes the person's
+ * role there may approve. Any refusal, or no session, renders the
+ * `unavailable` line and no form.
+ *
+ * It names who is signed in (with a sign-out back to this page), names the
+ * client as the client names itself — an unchecked claim — and its redirect
+ * origin, then hands the workspaces to the `ConsentForm` island. `noindex`,
+ * `referrer: same-origin` (the `account/connect` precedent). Framed by
+ * `AuthShell` like sign-in: `"consent"` is an `AUTH_SEGMENTS` entry.
+ */
+import { localeHref } from "@working-theory/ui";
+import { Button, Heading, Text } from "@working-theory/ui/primitives";
+import { SCOPE_GRANT_MAP, type McpScope } from "@working-theory/validation";
+import type { Metadata } from "next";
+import { headers } from "next/headers";
+import { getTranslations } from "next-intl/server";
+import type { ReactElement } from "react";
+
+import { auth } from "../../../../auth";
+import { SignOutTrigger } from "../../../../components/sign-out-trigger";
+
+import { ConsentForm, type ConsentWorkspace } from "./consent-form";
+
+interface Props {
+  params: Promise<{ locale: string }>;
+  searchParams: Promise<{ consent_code?: string | string[] }>;
+}
+
+interface ConsentDetails {
+  client: { name: string; redirectOrigin: string };
+  workspaces: Array<{ id: string; name: string; organizationName: string; offered: McpScope[] }>;
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { locale } = await params;
+  const t = await getTranslations({ locale, namespace: "mcpConsent" });
+  return {
+    title: t("metaTitle"),
+    robots: { index: false, follow: false },
+    referrer: "same-origin",
+  };
+}
+
+/** The details and the signed-in email, or `null` on any refusal. */
+async function readDetails(consentCode: string): Promise<{ details: ConsentDetails; email: string } | null> {
+  try {
+    const requestHeaders = await headers();
+    const session = await auth.api.getSession({ headers: requestHeaders });
+    if (!session) return null;
+    const details = (await auth.api.mcpConsentDetails({
+      headers: requestHeaders,
+      query: { consent_code: consentCode },
+    })) as ConsentDetails;
+    return { details, email: session.user.email };
+  } catch {
+    return null;
+  }
+}
+
+export default async function ConsentPage({ params, searchParams }: Props): Promise<ReactElement> {
+  const { locale } = await params;
+  const { consent_code: raw } = await searchParams;
+  const t = await getTranslations({ locale, namespace: "mcpConsent" });
+  const consentCode = typeof raw === "string" ? raw : "";
+  const read = consentCode ? await readDetails(consentCode) : null;
+
+  if (!read) {
+    return (
+      <div className="flex flex-col gap-4" data-testid="mcp-consent-unavailable">
+        <Heading level={1} visual={3}>
+          {t("heading")}
+        </Heading>
+        <Text as="p" variant="body-sm" tone="muted">
+          {t("unavailable")}
+        </Text>
+      </div>
+    );
+  }
+
+  const { details, email } = read;
+  const here = localeHref(locale, `/consent?consent_code=${encodeURIComponent(consentCode)}`);
+  const workspaces: ConsentWorkspace[] = details.workspaces.map((w) => ({
+    id: w.id,
+    name: w.name,
+    organizationName: w.organizationName,
+    offered: w.offered.map((scope) => {
+      const permission = SCOPE_GRANT_MAP[scope];
+      return { scope, permission, label: t(`scopes.${permission}`) };
+    }),
+  }));
+
+  return (
+    <div className="flex flex-col gap-6" data-testid="mcp-consent">
+      <div className="flex flex-col gap-2">
+        <Heading level={1} visual={3}>
+          {t("heading")}
+        </Heading>
+        <Text as="p" variant="body-sm" data-testid="mcp-consent-signed-in">
+          {t("signedInAs", { email })}
+        </Text>
+        <SignOutTrigger homeHref={here}>
+          <Button type="button" variant="link" data-testid="mcp-consent-sign-out">
+            {t("signOut")}
+          </Button>
+        </SignOutTrigger>
+      </div>
+      <div className="flex flex-col gap-2">
+        <Text as="p" variant="body-sm" data-testid="mcp-consent-client">
+          {t("clientClaim", { name: details.client.name })}
+        </Text>
+        <Text as="p" variant="body-sm" tone="muted" data-testid="mcp-consent-redirect-origin">
+          {t("returnsTo", { origin: details.client.redirectOrigin })}
+        </Text>
+      </div>
+      {workspaces.length === 0 ? (
+        <Text as="p" variant="body-sm" tone="muted" data-testid="mcp-consent-no-workspace">
+          {t("noWorkspace")}
+        </Text>
+      ) : null}
+      <ConsentForm
+        consentCode={consentCode}
+        locale={locale}
+        workspaces={workspaces}
+        text={{
+          workspaceLegend: t("workspaceLegend"),
+          scopesLegend: t("scopesLegend"),
+          memberReads: t("memberReads"),
+          noScopes: t("noScopes"),
+          allow: t("allow"),
+          deny: t("deny"),
+        }}
+      />
+    </div>
+  );
+}

package/templates/apps/web/app/[locale]/about/__tests__/about-routes.test.tsx

@@ -329,7 +329,7 @@ describe("the sitemap and llms.txt advertise /about/<slug>, never a bare /<slug>
 
   it("sitemap.xml: one <loc> ending in /about/sam-henry, none ending in a bare /sam-henry", async () => {
     const stubAdapter = makeStubAdapter();
-    const GET = createSitemapHandler({ getContentAdapter: () => stubAdapter, getDocsPages: () => [] });
+    const GET = createSitemapHandler({ getContentAdapter: () => stubAdapter, getDocsPages: () => [], discoverable: async () => true });
     const response = await GET();
     const text = await response.text();
     const locs = Array.from(text.matchAll(/<loc>([^<]*)<\/loc>/g)).map(
@@ -341,7 +341,7 @@ describe("the sitemap and llms.txt advertise /about/<slug>, never a bare /<slug>
 
   it("llms.txt: names a URL ending in /about/sam-henry", async () => {
     const stubAdapter = makeStubAdapter();
-    const GET = createLlmsHandler({ getContentAdapter: () => stubAdapter, getDocsPages: () => [] });
+    const GET = createLlmsHandler({ getContentAdapter: () => stubAdapter, getDocsPages: () => [], discoverable: async () => true });
     const response = await GET();
     const text = await response.text();
     expect(text).toContain("URL: https://site.example/about/sam-henry");

package/templates/apps/web/app/api/auth/hub/continuation.ts

@@ -30,7 +30,10 @@ export const CONTINUATION_REF_MAX = 4096;
  */
 export const CONTINUATION_TTL_SECONDS = 600;
 
-/** A fixed name: a value sealed for a cookie never opens here, nor the reverse. */
+/**
+ * A fixed name: a value sealed for a cookie never opens here, nor the reverse.
+ * The MCP sign-in leg seals under its own name (`../mcp/continuation.ts`).
+ */
 const AAD = "hub-continue";
 
 const BASE64URL = /^[A-Za-z0-9_-]+$/;
@@ -40,12 +43,13 @@ export function mintContinuation(
   search: string,
   secret: string,
   now: number = Date.now(),
+  name: string = AAD,
 ): string {
   return seal(
     { v: 1, q: search, exp: now + CONTINUATION_TTL_SECONDS * 1000 },
     secret,
     "continue",
-    AAD,
+    name,
   );
 }
 
@@ -62,9 +66,10 @@ export function openContinuation(
   ref: string,
   secret: string,
   now: number = Date.now(),
+  name: string = AAD,
 ): string | null {
   if (ref.length > CONTINUATION_REF_MAX || !BASE64URL.test(ref)) return null;
-  const value = unseal(ref, secret, "continue", AAD);
+  const value = unseal(ref, secret, "continue", name);
   if (typeof value !== "object" || value === null) return null;
   const { v, q, exp } = value as Record<string, unknown>;
   if (v !== 1 || typeof q !== "string" || q === "") return null;