src/routes.ts

Functions

Imports

It imports src/access-login.ts, src/access-sync.ts, src/agents.ts, src/approval.ts, src/auth.ts, src/backup.ts, src/bench.ts, src/encoding.ts, src/env.ts, src/health.ts, src/http.ts, src/inbox-report.ts, src/inbox.ts, src/log.ts, src/mcp-handler.ts, src/oauth-client-docs.ts, src/ops-feed.ts, src/ops-hooks.ts, src/ops-otlp.ts, src/ops-sites.ts, src/portal-actions.ts, src/portal-app.ts, src/portal-auth.ts, src/portal-claims.ts, src/portal-convergence.ts, src/portal-host.ts, src/portal-library.ts, src/portal-maintenance.ts, src/portal-overnight.ts, src/portal-packages.ts, src/portal-stale.ts, src/portal-trends.ts, src/public-data.ts, src/push.ts, src/rate-limit.ts, src/scope.ts, src/security-headers.ts, src/server.ts, src/shadow.ts, src/signed-requests.ts. Imported by src/index.ts.

Source

1import { PUBLIC_CODE_PATH, PUBLIC_DOCS, PUBLIC_MODEL_PATH, PUBLIC_STATS_PATH, handlePublicDocument } from "./public-data";
2import { SHADOW_JOB_PATH, SHADOW_RESULT_PATH, handleShadowJob, handleShadowResult } from "./shadow";
3import { BENCH_DRAW_PATH, BENCH_REPRO_PATH, BENCH_SCORE_PATH, BENCH_START_PATH, BENCH_TASKS_PATH, handleBenchDraw, handleBenchRepro, handleBenchScore, handleBenchStart, handleBenchTasks } from "./bench";
4import type { AuthRequest } from "@cloudflare/workers-oauth-provider";
5import { APPROVAL_MAX_AGE_SECONDS, approvalTag } from "./approval";
6import { getCookie, hmacHex } from "./auth";
7import { safeEqual } from "@dustinedwards/site-runtime/compare";
8import { resolveAgent } from "./agents";
9import { backupHttpStatus, runBackup } from "./backup";
10import { checkScope, routeRefusal } from "./scope";
11import { gatherInbox, restrictInbox } from "./inbox";
12import { VERIFY_LIVE_CLIENT_PATH, handleClientDocument } from "./oauth-client-docs";
13import { MAX_INBOX_REPORT_BYTES, REPORT_TTL_SECONDS, parseReport, reportCallerRefusal, spendReportRate, storeReport } from "./inbox-report";
14import { readSiteConfig } from "./ops-sites";
15import { b64urlDecode, b64urlEncode } from "./encoding";
16import { CONSENT_DIALOG_HEADERS, REPORT_PATH, securityHeadersFor } from "./security-headers";
17import { receiveCspReport } from "@dustinedwards/site-runtime/csp-report";
18import { callerIp, checkRate, CSP_REPORT_LIMIT } from "./rate-limit";
19import type { Env, Props } from "./env";
20import { buildAdminServer, buildServer } from "./server";
21import { ADMIN_OPS_MCP_ROUTE, serveMcp } from "./mcp-handler";
22import {
23  BACKUP_CREDENTIAL_PATH,
24  claimJti,
25  MAX_REPORT_BYTES,
26  mintBackupCredential,
27  parseBackupCredentialRequest,
28  readBoundedText,
29  verifyBackupCredentialRequest,
30} from "./signed-requests";
31import { handleHealth } from "./health";
32import { escapeHtml } from "@dustinedwards/site-runtime/html";
33import { handlePortalApp } from "./portal-app";
34import { PORTAL_HOST } from "./portal-host";
35import { OPS_FEED_PATH, OPS_REFRESH_PATH, handleOpsFeed, handleOpsRefresh } from "./ops-feed";
36import { OTLP_LOGS_PATH, OTLP_METRICS_PATH, handleOtlpLogs, handleOtlpMetrics } from "./ops-otlp";
37import { OPS_HOOKS_PATH, handleOpsHooks } from "./ops-hooks";
38import { ACCESS_SYNC_PATH, handleAccessSync } from "./access-sync";
39import {
40  handlePortalActivity,
41  handlePortalApiNotFound,
42  handlePortalNamespaces,
43  handlePortalPerform,
44  handlePortalPreview,
45  handlePortalSignOut,
46  PORTAL_ACTIVITY_PATH,
47  PORTAL_API_PREFIX,
48  PORTAL_NAMESPACES_PATH,
49  PORTAL_PERFORM_PATH,
50  PORTAL_PREVIEW_PATH,
51  PORTAL_SIGN_OUT_PATH,
52} from "./portal-actions";
53import { handlePortalCallback, PORTAL_CALLBACK_PATH, PORTAL_PATH, PORTAL_PREFIX } from "./portal-auth";
54import { handlePortalClaims, PORTAL_CLAIMS_PATH } from "./portal-claims";
55import { handlePortalStale, PORTAL_STALE_PATH } from "./portal-stale";
56import { handlePortalDigest, handlePortalPlan, PORTAL_DIGEST_PATH, PORTAL_PLAN_PATH } from "./portal-overnight";
57import { handlePortalMaintenance, PORTAL_MAINTENANCE_PATH } from "./portal-maintenance";
58import { handlePortalConvergence, PORTAL_CONVERGENCE_PATH } from "./portal-convergence";
59import { handlePortalPushGet, handlePortalPushPost, PORTAL_PUSH_PATH } from "./push";
60import { handlePortalLibrary, PORTAL_LIBRARY_PATH } from "./portal-library";
61import { handlePortalTrends, PORTAL_TRENDS_PATH } from "./portal-trends";
62import { handlePortalPackageHistory, handlePortalSharedCode, PORTAL_PACKAGE_HISTORY_PATH, PORTAL_SHARED_CODE_PATH } from "./portal-packages";
63import { clearStateCookie, completeAccessLogin, type LoginFlow, STATE_TTL_SECONDS, startAccessLogin } from "./access-login";
64import { logEvent } from "./log";
65import { textResponse } from "./http";
66
67const APPROVAL_COOKIE = "capsid_approved";
68const CSRF_COOKIE = "capsid_csrf";
69
70// The MCP authorization flow's sign-in, through Cloudflare Access for SaaS
71// (src/access-login.ts). The state stored against the token is the JSON AuthRequest.
72const MCP_LOGIN: LoginFlow = {
73  callbackPath: "/callback",
74  stateCookie: "capsid_state",
75  cookiePath: "/callback",
76  kvPrefix: "capsid:oauth-state:",
77  restartHint: "Restart from your MCP client.",
78};
79
80// The approval cookie carries entries from src/approval.ts: a client id bound to a
81// digest of its redirect set, signed with COOKIE_ENCRYPTION_KEY, kept 30 days.
82// Cookies cap near 4KB; an entry is about 36 bytes of JSON, and the 30 day expiry
83// bounds the growth.
84async function approvedClients(request: Request, secret: string): Promise<string[]> {
85  const raw = getCookie(request, APPROVAL_COOKIE);
86  if (!raw) return [];
87  const dot = raw.indexOf(".");
88  if (dot === -1) return [];
89  const sig = raw.slice(0, dot);
90  const payload = raw.slice(dot + 1);
91  if (!await safeEqual(sig, await hmacHex(secret, payload))) return [];
92  try {
93    const parsed = JSON.parse(b64urlDecode(payload));
94    return Array.isArray(parsed) ? parsed.filter((v) => typeof v === "string") : [];
95  } catch {
96    return [];
97  }
98}
99
100async function approvalCookie(tags: string[], secret: string): Promise<string> {
101  const payload = b64urlEncode(JSON.stringify(tags));
102  const sig = await hmacHex(secret, payload);
103  return `${APPROVAL_COOKIE}=${sig}.${payload}; HttpOnly; Secure; SameSite=Lax; Path=/authorize; Max-Age=${APPROVAL_MAX_AGE_SECONDS}`;
104}
105
106function renderApprovalDialog(oauthReq: AuthRequest, clientName: string, csrf: string, registeredUris: string[] | undefined): Response {
107  const name = escapeHtml(clientName);
108  const redirect = escapeHtml(oauthReq.redirectUri);
109  const req = b64urlEncode(JSON.stringify(oauthReq));
110  // Every registered redirect URI is shown, not just the requested one. A client's
111  // metadata document may name several and the approval covers only the requested
112  // one, so listing the rest is what shows the admin that a client with a familiar
113  // name also carries an attacker's redirect.
114  const others = (registeredUris ?? []).filter((u) => u !== oauthReq.redirectUri);
115  const othersHtml = others.length
116    ? `<p>This client also has these registered redirect URIs (not covered by this approval):</p><ul>${others
117        .map((u) => `<li><code>${escapeHtml(u)}</code></li>`)
118        .join("")}</ul>`
119    : "";
120  const html = `<!doctype html>
121<html lang="en">
122<head>
123<meta charset="utf-8">
124<meta name="viewport" content="width=device-width, initial-scale=1">
125<title>Authorize ${name}</title>
126<style>
127body { font-family: system-ui, sans-serif; max-width: 32rem; margin: 4rem auto; padding: 0 1rem; color: #1a1a1a; }
128.card { border: 1px solid #ddd; border-radius: 8px; padding: 1.5rem; }
129code { background: #f4f4f4; padding: 0.1rem 0.3rem; border-radius: 4px; word-break: break-all; }
130button { background: #1a7f37; color: #fff; border: 0; border-radius: 6px; padding: 0.6rem 1.4rem; font-size: 1rem; cursor: pointer; }
131</style>
132</head>
133<body>
134<div class="card">
135<h1>Capsid access request</h1>
136<p><strong>${name}</strong> is asking to connect to this MCP server.</p>
137<p>Requested redirect URI: <code>${redirect}</code></p>
138${othersHtml}
139<p>Approving will send you to GitHub to sign in. Only the configured admin account is admitted.</p>
140<form method="post" action="/authorize">
141<input type="hidden" name="csrf" value="${csrf}">
142<input type="hidden" name="req" value="${req}">
143<button type="submit">Approve and continue to GitHub</button>
144</form>
145</div>
146</body>
147</html>`;
148  return new Response(html, {
149    status: 200,
150    headers: {
151      // The static headers, and why form-action is absent from the CSP: see
152      // CONSENT_DIALOG_HEADERS in ./security-headers.
153      ...CONSENT_DIALOG_HEADERS,
154      "Set-Cookie": `${CSRF_COOKIE}=${csrf}; HttpOnly; Secure; SameSite=Lax; Path=/authorize; Max-Age=${STATE_TTL_SECONDS}`,
155    },
156  });
157}
158
159async function startSignIn(
160  request: Request,
161  env: Env,
162  oauthReq: AuthRequest,
163  extraCookies: string[] = []
164): Promise<Response> {
165  return startAccessLogin(request, env, MCP_LOGIN, JSON.stringify(oauthReq), extraCookies);
166}
167
168async function handleAuthorizeGet(request: Request, env: Env): Promise<Response> {
169  let oauthReq: AuthRequest;
170  try {
171    oauthReq = await env.OAUTH_PROVIDER.parseAuthRequest(request);
172  } catch (err) {
173    return textResponse(`invalid authorization request: ${err instanceof Error ? err.message : String(err)}`, 400);
174  }
175  if (!oauthReq.clientId) return textResponse("invalid authorization request: missing client_id", 400);
176  // The lookup runs before the cookie check: the approval is bound to this client's
177  // redirect set, and reading the client is the only way to check it. A client id
178  // that no longer resolves cannot ride an old cookie past the dialog.
179  const client = await env.OAUTH_PROVIDER.lookupClient(oauthReq.clientId);
180  if (!client) return textResponse("unknown client", 400);
181  const approved = await approvedClients(request, env.COOKIE_ENCRYPTION_KEY);
182  if (approved.includes(await approvalTag(oauthReq.clientId, oauthReq.redirectUri))) {
183    return startSignIn(request, env, oauthReq);
184  }
185  return renderApprovalDialog(oauthReq, client.clientName ?? oauthReq.clientId, crypto.randomUUID(), client.redirectUris);
186}
187
188// The consent form's body cap. `req` is a base64url AuthRequest and `csrf` a uuid, so
189// a real submission is well under a kilobyte; 64KB leaves headroom and still refuses
190// a body that is trying to be something else.
191const AUTHORIZE_FORM_MAX_BYTES = 65_536;
192
193async function handleAuthorizePost(request: Request, env: Env): Promise<Response> {
194  // Bounded at the stream, before the parse. request.formData() buffers and parses
195  // the whole body before any check here runs, on a path reachable without
196  // credentials: the CSRF cookie is checked after the parse, and a caller can fetch
197  // the form to obtain one.
198  const bounded = await readBoundedText(request, AUTHORIZE_FORM_MAX_BYTES);
199  if (!bounded.ok) return new Response(null, { status: 413 });
200  // URLSearchParams, not formData(): the dialog is a plain `<form method="post">` with
201  // no enctype, so the browser sends urlencoded, and so does the live gate.
202  const form = new URLSearchParams(bounded.text);
203  const csrf = form.get("csrf");
204  const req = form.get("req");
205  if (typeof csrf !== "string" || typeof req !== "string") return textResponse("bad request", 400);
206  const csrfCookie = getCookie(request, CSRF_COOKIE);
207  if (!csrfCookie || !await safeEqual(csrfCookie, csrf)) return textResponse("csrf validation failed: restart the flow", 403);
208  let oauthReq: AuthRequest;
209  try {
210    oauthReq = JSON.parse(b64urlDecode(req)) as AuthRequest;
211  } catch {
212    return textResponse("bad request", 400);
213  }
214  const client = oauthReq.clientId ? await env.OAUTH_PROVIDER.lookupClient(oauthReq.clientId) : null;
215  if (!client) return textResponse("unknown client", 400);
216  const approved = await approvedClients(request, env.COOKIE_ENCRYPTION_KEY);
217  const tag = await approvalTag(oauthReq.clientId, oauthReq.redirectUri);
218  if (!approved.includes(tag)) approved.push(tag);
219  const cookies = [
220    await approvalCookie(approved, env.COOKIE_ENCRYPTION_KEY),
221    `${CSRF_COOKIE}=; HttpOnly; Secure; SameSite=Lax; Path=/authorize; Max-Age=0`,
222  ];
223  return startSignIn(request, env, oauthReq, cookies);
224}
225
226async function handleCallback(request: Request, env: Env): Promise<Response> {
227  const login = await completeAccessLogin(request, env, MCP_LOGIN, (stored) => JSON.parse(stored) as AuthRequest);
228  if (!login.ok) return login.response;
229  const { email, state: oauthReq } = login;
230
231  const props: Props = { email, signed_in_at: Date.now() };
232  const { redirectTo } = await env.OAUTH_PROVIDER.completeAuthorization({
233    request: oauthReq,
234    userId: email,
235    metadata: { email },
236    scope: oauthReq.scope,
237    props,
238    // Claude identifies both connectors, Capsid on /mcp and Capsid Admin on /mcp/admin,
239    // with one client id (its CIMD document). The provider's default revokes every
240    // earlier grant for the same user and client on each authorization, so signing into
241    // one connector signed the other out. Each grant still expires on its own.
242    revokeExistingGrants: false,
243  });
244
245  const headers = new Headers({ Location: redirectTo });
246  headers.append("Set-Cookie", clearStateCookie(MCP_LOGIN));
247  return new Response(null, { status: 302, headers });
248}
249
250async function handleOperatorMcp(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
251  // The bearer is resolved to a caller once, here, and every tool in this request is
252  // checked against it. A minted agent carries the scopes its row says; a legacy
253  // operator key resolves to the unrestricted caller until it is revoked by hand.
254  const resolved = await resolveAgent(request, env);
255  if (!resolved) {
256    return new Response("unauthorized: valid operator key or agent key required", {
257      status: 401,
258      headers: { "WWW-Authenticate": 'Bearer realm="capsid-operator"' },
259    });
260  }
261  // last_seen is not part of authorizing, so a slow or failing write rides on
262  // waitUntil rather than slowing the tool call.
263  ctx.waitUntil(resolved.touch());
264  return serveMcp(request, env, ctx, "/ops/mcp", () => buildServer(env, resolved.agent));
265}
266
267// Capsid Admin for a key (src/mcp-handler.ts ADMIN_OPS_MCP_ROUTE): the seat's scripts
268// (scripts/mint-agents.ts) reach the administrator tools with its operator key. Only
269// the admin identity is served; any other key is refused here, before a server is
270// built, and every tool on it is admin only in the registrar as well.
271async function handleOperatorAdminMcp(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
272  const resolved = await resolveAgent(request, env);
273  if (!resolved) {
274    return new Response("unauthorized: an admin operator key is required", {
275      status: 401,
276      headers: { "WWW-Authenticate": 'Bearer realm="capsid-operator"' },
277    });
278  }
279  if (!resolved.agent.admin) {
280    return new Response(`forbidden: ${resolved.agent.actor} is not the admin. Capsid Admin serves the administrator alone.`, { status: 403 });
281  }
282  ctx.waitUntil(resolved.touch());
283  return serveMcp(request, env, ctx, ADMIN_OPS_MCP_ROUTE, () => buildAdminServer(env, resolved.agent));
284}
285
286async function handleBackup(request: Request, env: Env): Promise<Response> {
287  // No credential, or one that resolves to nobody: 401, so a client knows to send one.
288  const caller = await resolveAgent(request, env);
289  if (!caller) {
290    return new Response("unauthorized: admin operator key required", {
291      status: 401,
292      headers: { "WWW-Authenticate": 'Bearer realm="capsid-operator"' },
293    });
294  }
295  // A caller that resolved but may not run this: 403. A backup and its prune cover
296  // every namespace, so ROUTE_GRANTS in src/scope.ts requires the admin, through the
297  // same checkScope the tools use. The write grant alone is held by every
298  // namespace-scoped driver.
299  const refusal = routeRefusal("/ops/backup", caller.agent);
300  if (refusal) return new Response(refusal, { status: 403 });
301  const result = await runBackup(env);
302  return Response.json(result, { status: backupHttpStatus(result) });
303}
304
305// What needs Dustin, per app (src/inbox.ts), for the admin shell's app strip. It is read
306// by each app's SERVER with a key, never by a browser: a browser on another admin host
307// would need either a Portal session it does not hold or a secret in the page, and
308// Cloudflare Access would stop the CORS preflight anyway. A key scoped to one namespace
309// sees that app alone. The shell renders without badges when this fails, so a failure
310// here is a plain error and never retried into a block.
311async function handleInbox(request: Request, env: Env): Promise<Response> {
312  const caller = await resolveAgent(request, env);
313  if (!caller) {
314    return new Response("unauthorized: an agent key or the operator key is required", {
315      status: 401,
316      headers: { "WWW-Authenticate": 'Bearer realm="capsid-operator"' },
317    });
318  }
319  const everything = await gatherInbox(env, new Date(), null);
320  const readable = (namespace: string) => checkScope(caller.agent, { tool: "capsid_run_improve", action: "status", namespace, grant: "read" }) === null;
321  return Response.json(restrictInbox(everything, readable), { headers: { "Cache-Control": "private, max-age=30", "X-Content-Type-Options": "nosniff" } });
322}
323
324// What an app reports about itself to the inbox (src/inbox-report.ts): the app's own
325// key, the write grant on the namespace it names, one report per minute, the 6 hour
326// expiry. The order is the gate's: who, then what, then the rate, then the write, so a
327// refused report spends nothing.
328async function handleInboxReport(request: Request, env: Env): Promise<Response> {
329  const caller = await resolveAgent(request, env);
330  if (!caller) return textResponse("unauthorized: the app's own agent key is required", 401, { "WWW-Authenticate": 'Bearer realm="capsid-operator"' });
331  const bounded = await readBoundedText(request, MAX_INBOX_REPORT_BYTES);
332  if (!bounded.ok) return textResponse(`request too large: exceeds ${MAX_INBOX_REPORT_BYTES} bytes`, 413);
333  let body: unknown;
334  try {
335    body = JSON.parse(bounded.text);
336  } catch {
337    return textResponse("the body must be JSON", 400);
338  }
339  const namespace = (body as { namespace?: unknown } | null)?.namespace;
340  if (typeof namespace !== "string" || namespace === "") return textResponse("namespace is required", 400);
341  const refusal = reportCallerRefusal(caller.agent, namespace);
342  if (refusal) return textResponse(refusal, 403);
343  const now = new Date();
344  const config = await readSiteConfig(env.DB);
345  const origin = config.find((c) => c.namespace === namespace)?.origin ?? null;
346  const parsed = parseReport(body, origin, now);
347  if (!parsed.ok) return textResponse(parsed.refusal, 400);
348  const rate = await spendReportRate(env.APP_KV, caller.agent.actor);
349  if (!rate.ok) return textResponse(rate.refusal, rate.status, { "Retry-After": "60" });
350  await storeReport(env.APP_KV, { namespace, reported_at: now.toISOString(), reported_by: caller.agent.actor, items: parsed.value.items });
351  return Response.json({ ok: true, namespace, items: parsed.value.items.length, expires_in_seconds: REPORT_TTL_SECONDS }, { headers: { "Cache-Control": "no-store" } });
352}
353
354// The family's one receiver (@dustinedwards/site-runtime/csp-report): a POST always
355// gets 204, the body is read to 16 KB and no further, at most ten violations are
356// logged one line each with every URL cut to origin and path, and nothing is stored.
357// The limiter is asked first, and a refusal is a dropped report rather than a 429. Every method
358// comes here, so a GET is the receiver's 405 as on the other sites, and the Portal's
359// pages, which report here from their own host, get the preflight the Reporting API sends.
360async function handleCspReport(request: Request, env: Env): Promise<Response> {
361  return receiveCspReport(request, {
362    allowOrigin: `https://${PORTAL_HOST}`,
363    headers: securityHeadersFor("other"),
364    allow: async (r) => {
365      const ip = callerIp(r);
366      const rate = await checkRate(env.APP_KV, ip, new Date(), CSP_REPORT_LIMIT);
367      // The unavailable refusal has already logged itself.
368      if (!rate.allowed && rate.window !== "unavailable") {
369        logEvent("error", "CSP_REPORT_RATE_LIMITED", { message: `CSP_REPORT_RATE_LIMITED ${ip} hit the ${rate.window} limit (${rate.count} of ${rate.limit})` });
370      }
371      return rate.allowed;
372    },
373  });
374}
375
376// /health lives in src/health.ts: routes.ts pulls cloudflare:workers via the Agents
377// SDK and cannot load under node --test.
378
379async function readSignedBody(request: Request, tooLarge: string): Promise<{ ok: true; body: string } | { ok: false; response: Response }> {
380  const bounded = await readBoundedText(request, MAX_REPORT_BYTES);
381  if (!bounded.ok) return { ok: false, response: textResponse(tooLarge, 413) };
382  return { ok: true, body: bounded.text };
383}
384
385// The backup-credential mint: an HMAC over timestamp.body with the backup-specific
386// derived key, a bounded body and the jti replay cache, then one hour of
387// object-read-only on backups/json/. The jti cache runs under the literal scope
388// "backup", which is not in ROSTER.
389async function handleBackupCredential(request: Request, env: Env): Promise<Response> {
390  const timestamp = request.headers.get("X-Backup-Timestamp") ?? "";
391  const signature = request.headers.get("X-Backup-Signature") ?? "";
392
393  const bounded = await readSignedBody(request, `request too large: exceeds ${MAX_REPORT_BYTES} bytes`);
394  if (!bounded.ok) return bounded.response;
395  const body = bounded.body;
396
397  const verdict = await verifyBackupCredentialRequest(env, { timestamp, signature, body }, new Date());
398  if (!verdict.ok) {
399    logEvent("error", "BACKUP_CREDENTIAL_REJECTED", { message: `BACKUP_CREDENTIAL_REJECTED ${verdict.refusal}` });
400    return textResponse(verdict.refusal, verdict.status);
401  }
402
403  const parsed = parseBackupCredentialRequest(body);
404  if (!parsed.ok) return textResponse(parsed.refusal, 400);
405
406  const claim = await claimJti(env.DB, "backup", parsed.jti);
407  if (!claim.ok) return textResponse(claim.refusal, claim.status);
408
409  const minted = await mintBackupCredential(env, parsed.site);
410  if (!minted.ok) {
411    logEvent("error", "BACKUP_CREDENTIAL_FAILED", { message: `BACKUP_CREDENTIAL_FAILED site=${parsed.site} ${minted.refusal}` });
412    return textResponse(minted.refusal, minted.status);
413  }
414  logEvent("log", "BACKUP_CREDENTIAL_MINTED", { message: `BACKUP_CREDENTIAL_MINTED site=${parsed.site} ttl=${minted.credential.expires_in}s` });
415  return new Response(JSON.stringify(minted.credential), { status: 200, headers: { "Content-Type": "application/json" } });
416}
417
418export const defaultHandler = {
419  async fetch(original: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
420    // The Portal host's rewrite has already run, in src/index.ts, before the OAuth
421    // provider: a request here for portal.dustinedwards.info is already a /portal path.
422    const request = original;
423    const url = new URL(request.url);
424    if (url.pathname === "/health") return handleHealth(env);
425    if (url.pathname === PUBLIC_MODEL_PATH && request.method === "GET") return handlePublicDocument(request, env, ctx, PUBLIC_DOCS.model);
426    if (url.pathname === PUBLIC_STATS_PATH && request.method === "GET") return handlePublicDocument(request, env, ctx, PUBLIC_DOCS.stats);
427    if (url.pathname === PUBLIC_CODE_PATH && request.method === "GET") return handlePublicDocument(request, env, ctx, PUBLIC_DOCS.code);
428    if (url.pathname === VERIFY_LIVE_CLIENT_PATH && request.method === "GET") return handleClientDocument(request);
429    if (url.pathname === REPORT_PATH) return handleCspReport(request, env);
430    if (url.pathname === "/ops/mcp") return handleOperatorMcp(request, env, ctx);
431    if (url.pathname === ADMIN_OPS_MCP_ROUTE) return handleOperatorAdminMcp(request, env, ctx);
432    if (url.pathname === "/ops/backup" && request.method === "POST") return handleBackup(request, env);
433    if (url.pathname === "/ops/inbox" && request.method === "GET") return handleInbox(request, env);
434    if (url.pathname === "/ops/inbox/report" && request.method === "POST") return handleInboxReport(request, env);
435    if (url.pathname === ACCESS_SYNC_PATH && request.method === "POST") return handleAccessSync(request, env);
436    if (url.pathname === OPS_HOOKS_PATH && request.method === "POST") return handleOpsHooks(request, env, ctx);
437    if (url.pathname === OTLP_METRICS_PATH && request.method === "POST") return handleOtlpMetrics(request, env);
438    if (url.pathname === OTLP_LOGS_PATH && request.method === "POST") return handleOtlpLogs(request, env);
439    if (url.pathname === BACKUP_CREDENTIAL_PATH && request.method === "POST") return handleBackupCredential(request, env);
440    if (url.pathname === BENCH_TASKS_PATH && request.method === "POST") return handleBenchTasks(request, env);
441    if (url.pathname === BENCH_DRAW_PATH && request.method === "POST") return handleBenchDraw(request, env);
442    if (url.pathname === BENCH_START_PATH && request.method === "POST") return handleBenchStart(request, env);
443    if (url.pathname === BENCH_REPRO_PATH && request.method === "POST") return handleBenchRepro(request, env);
444    if (url.pathname === BENCH_SCORE_PATH && request.method === "POST") return handleBenchScore(request, env);
445    if (url.pathname === SHADOW_JOB_PATH && request.method === "GET") return handleShadowJob(request, env);
446    if (url.pathname === SHADOW_RESULT_PATH && request.method === "POST") return handleShadowResult(request, env);
447    if (url.pathname === "/authorize" && request.method === "GET") return handleAuthorizeGet(request, env);
448    if (url.pathname === "/authorize" && request.method === "POST") return handleAuthorizePost(request, env);
449    if (url.pathname === "/callback") return handleCallback(request, env);
450    // Capsid Portal. The callback and every /portal/api/ route are matched before the
451    // app's catch-all, and an unknown /portal/api/ path is a 404, never the app's page.
452    // Nothing answers under /console: the Portal moved without redirects
453    // (capsid/research/design-portal-unify.md), so an old address reaches the 404 below.
454    if (url.pathname === PORTAL_CALLBACK_PATH) return handlePortalCallback(request, env, new Date());
455    if (url.pathname === OPS_FEED_PATH && request.method === "GET") return handleOpsFeed(request, env);
456    if (url.pathname === OPS_REFRESH_PATH && request.method === "POST") return handleOpsRefresh(request, env);
457    if (url.pathname === PORTAL_PREVIEW_PATH && request.method === "POST") return handlePortalPreview(request, env);
458    if (url.pathname === PORTAL_PERFORM_PATH && request.method === "POST") return handlePortalPerform(request, env);
459    if (url.pathname === PORTAL_NAMESPACES_PATH && request.method === "GET") return handlePortalNamespaces(request, env);
460    if (url.pathname === PORTAL_ACTIVITY_PATH && request.method === "GET") return handlePortalActivity(request, env);
461    if (url.pathname === PORTAL_CLAIMS_PATH && request.method === "GET") return handlePortalClaims(request, env);
462    if (url.pathname === PORTAL_STALE_PATH && request.method === "GET") return handlePortalStale(request, env);
463    if (url.pathname === PORTAL_PLAN_PATH && request.method === "GET") return handlePortalPlan(request, env);
464    if (url.pathname === PORTAL_DIGEST_PATH && request.method === "GET") return handlePortalDigest(request, env);
465    if (url.pathname === PORTAL_MAINTENANCE_PATH && request.method === "GET") return handlePortalMaintenance(request, env);
466    if (url.pathname === PORTAL_CONVERGENCE_PATH && request.method === "GET") return handlePortalConvergence(request, env);
467    if (url.pathname === PORTAL_PACKAGE_HISTORY_PATH && request.method === "GET") return handlePortalPackageHistory(request, env);
468    if (url.pathname === PORTAL_SHARED_CODE_PATH && request.method === "GET") return handlePortalSharedCode(request, env);
469    if (url.pathname === PORTAL_LIBRARY_PATH && request.method === "GET") return handlePortalLibrary(request, env);
470    if (url.pathname === PORTAL_TRENDS_PATH && request.method === "GET") return handlePortalTrends(request, env);
471    if (url.pathname === PORTAL_PUSH_PATH && request.method === "GET") return handlePortalPushGet(request, env);
472    if (url.pathname === PORTAL_PUSH_PATH && request.method === "POST") return handlePortalPushPost(request, env);
473    if (url.pathname === PORTAL_SIGN_OUT_PATH && request.method === "POST") return handlePortalSignOut(request, env);
474    if (url.pathname.startsWith(PORTAL_API_PREFIX)) return handlePortalApiNotFound(request, env);
475    // The app and everything under it, every method: the handler gates first.
476    if (url.pathname === PORTAL_PATH || url.pathname.startsWith(PORTAL_PREFIX)) return handlePortalApp(request, env);
477
478    return new Response("not found", { status: 404 });
479  },
480};