fix(agent-score): address CodeRabbit review

- Hide the llms.txt directive from screen readers and the tab order
  (aria-hidden + tabIndex={-1}); audits read raw HTML, not the a11y tree.
- Bound the /docs/mcp proxy: reject request bodies over 1 MiB (413, also
  for chunked bodies without Content-Length) and abort the upstream fetch
  if headers take more than 30s, while keeping SSE bodies streaming.
- lint-agent-ready now requires all three header-matched /mcp rewrites
  (accept, content-type, mcp-session-id), not just one.
- Pin the afdocs version in the skill's reproduction commands.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ankur-arch

.claude/skills/docs-agent-ready/SKILL.md

@@ -65,9 +65,10 @@ The guard prints a size table with per-file headroom so reviewers see how close
 **(f) Reproducing the audit.** The audit is the `afdocs` npm CLI (https://afdocs.dev). To reproduce a report locally:
 
 ```bash
-npx afdocs check https://www.prisma.io/docs --sampling deterministic -v
+# version pinned against supply-chain surprises — bump deliberately
+npx afdocs@0.18.7 check https://www.prisma.io/docs --sampling deterministic -v
 # parity needs its upstream checks in the same run:
-npx afdocs check https://www.prisma.io/docs \
+npx afdocs@0.18.7 check https://www.prisma.io/docs \
   --checks markdown-url-support,content-negotiation,markdown-content-parity \
   --sampling deterministic --format json -v
 ```

apps/docs/scripts/lint-agent-ready.ts

@@ -466,14 +466,21 @@ try {
 const siteNextConfigPath = join(scriptDir, "..", "..", "site", "next.config.mjs");
 try {
   const siteConfigSource = readFileSync(siteNextConfigPath, "utf8");
-  const mcpRewriteCount = (
-    siteConfigSource.match(new RegExp(`source: "/mcp",\\s*\\n\\s*has:`, "g")) ?? []
-  ).length;
-  if (mcpRewriteCount === 0 || !siteConfigSource.includes(`destination: "${MCP_URL}"`)) {
+  // All three header conditions are needed to cover the MCP Streamable HTTP
+  // transport: POST messages (content-type), the server event stream (accept),
+  // and session teardown (mcp-session-id).
+  const requiredMcpHeaderKeys = ["accept", "content-type", "mcp-session-id"];
+  const missingMcpHeaderRewrites = requiredMcpHeaderKeys.filter(
+    (key) => !new RegExp(`source: "/mcp",[\\s\\S]{0,200}?key: "${key}"`).test(siteConfigSource),
+  );
+  if (missingMcpHeaderRewrites.length > 0) {
     mcpEndpointErrors.push(
-      `site: next.config.mjs is missing the header-matched /mcp rewrites to "${MCP_URL}"`,
+      `site: next.config.mjs is missing /mcp rewrite(s) for header key(s): ${missingMcpHeaderRewrites.join(", ")}`,
     );
   }
+  if (!siteConfigSource.includes(`destination: "${MCP_URL}"`)) {
+    mcpEndpointErrors.push(`site: next.config.mjs /mcp rewrites do not target "${MCP_URL}"`);
+  }
 } catch (error) {
   mcpEndpointErrors.push(`site: could not read ${siteNextConfigPath}: ${String(error)}`);
 }

apps/docs/src/app/layout.tsx

@@ -116,9 +116,12 @@ export default function Layout({ children }: { children: ReactNode }) {
             measure the directive's byte position within the body and flag it as
             "buried" when it sits past 50% — which happens if it renders inside
             the page content, after the sidebar markup. data-markdown-ignore
-            keeps it out of the HTML/markdown parity comparison. */}
+            keeps it out of the HTML/markdown parity comparison; aria-hidden and
+            tabIndex={-1} keep it away from screen readers and the tab order
+            (audits read the raw HTML, not the accessibility tree). */}
         <div
           data-markdown-ignore
+          aria-hidden="true"
           style={{
             position: "absolute",
             width: 1,
@@ -132,8 +135,11 @@ export default function Layout({ children }: { children: ReactNode }) {
           }}
         >
           For the complete Prisma documentation index optimized for AI agents, see{" "}
-          <a href="https://www.prisma.io/docs/llms.txt">https://www.prisma.io/docs/llms.txt</a>. A
-          markdown version of every docs page is available by appending <code>.md</code> to its URL.
+          <a href="https://www.prisma.io/docs/llms.txt" tabIndex={-1}>
+            https://www.prisma.io/docs/llms.txt
+          </a>
+          {". A markdown version of every docs page is available by appending "}
+          <code>.md</code> to its URL.
         </div>
         <Banner
           id="prisma-next-docs"

apps/docs/src/app/mcp/route.ts

@@ -34,24 +34,91 @@ const FORWARD_RESPONSE_HEADERS = [
   "www-authenticate",
 ];
 
+// MCP messages are small JSON-RPC payloads; this is a public endpoint, so cap
+// what gets buffered into memory.
+const MAX_BODY_BYTES = 1_048_576;
+
+// Bound on establishing the upstream connection and receiving headers. The
+// timer is cleared once headers arrive so long-lived SSE bodies keep streaming.
+const UPSTREAM_HEADER_TIMEOUT_MS = 30_000;
+
+/**
+ * Reads the request body, rejecting once it exceeds MAX_BODY_BYTES. The
+ * declared Content-Length short-circuits, but the stream is counted too so
+ * chunked requests without a length are equally bounded.
+ */
+async function readBoundedBody(request: Request) {
+  const declared = Number(request.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) return null;
+
+  if (!request.body) return new ArrayBuffer(0);
+
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  const reader = request.body.getReader();
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > MAX_BODY_BYTES) {
+      await reader.cancel();
+      return null;
+    }
+    chunks.push(value);
+  }
+
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body.buffer;
+}
+
 async function proxyToMcpServer(request: Request) {
   const headers = new Headers();
   for (const name of FORWARD_REQUEST_HEADERS) {
     const value = request.headers.get(name);
     if (value) headers.set(name, value);
   }
 
-  // MCP messages are small JSON-RPC payloads; buffering avoids the streaming
-  // request-body (duplex) requirements of pass-through fetch.
-  const body =
-    request.method === "GET" || request.method === "HEAD" ? undefined : await request.arrayBuffer();
+  // Buffering (instead of streaming pass-through) avoids fetch's duplex
+  // request-body requirements; readBoundedBody keeps it memory-safe.
+  let body: ArrayBuffer | undefined;
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    const bounded = await readBoundedBody(request);
+    if (bounded === null) {
+      return new Response("Request body exceeds the 1 MiB limit for MCP messages.", {
+        status: 413,
+        headers: { "Cache-Control": "no-store" },
+      });
+    }
+    body = bounded;
+  }
 
-  const upstream = await fetch(MCP_SERVER_URL, {
-    method: request.method,
-    headers,
-    body,
-    redirect: "manual",
-  });
+  const abort = new AbortController();
+  const headerTimer = setTimeout(() => abort.abort(), UPSTREAM_HEADER_TIMEOUT_MS);
+  let upstream: Response;
+  try {
+    upstream = await fetch(MCP_SERVER_URL, {
+      method: request.method,
+      headers,
+      body,
+      redirect: "manual",
+      signal: abort.signal,
+    });
+  } catch (error) {
+    if (abort.signal.aborted) {
+      return new Response("Upstream MCP server timed out.", {
+        status: 504,
+        headers: { "Cache-Control": "no-store" },
+      });
+    }
+    throw error;
+  } finally {
+    clearTimeout(headerTimer);
+  }
 
   const responseHeaders = new Headers({ "Cache-Control": "no-store" });
   for (const name of FORWARD_RESPONSE_HEADERS) {