// ---------------------------------------------------------------------------// Cloud MCP front — the MCP-path predicate + org-scope rewrite shared by// `server.ts`'s request dispatch.// ---------------------------------------------------------------------------//// PRODUCTION serves /mcp through `server.ts`'s hibernatable Agent bridge.// Discovery docs flow through `app.ts`'s unified `ExecutorApp.make` handler// (the `auth` seam's discovery routes). This module exposes://   - `classifyMcpPath`   — the "is this an MCP path?" predicate (`/mcp` + the//     two discovery docs, plus their org-scoped variants).//   - `prepareMcpOrgScope` — rewrite an org-scoped MCP request to the bare path//     the handler routes, carrying the URL-pinned org in an internal header.// --------------------------------------------------------------------------- import { isValidOrgSlug } from "@executor-js/api"; import { MCP_ORGANIZATION_HEADER, PROTECTED_RESOURCE_METADATA_PATH } from "./auth"; const MCP_PATH = "/mcp";const AUTHORIZATION_SERVER_METADATA_PATH = "/.well-known/oauth-authorization-server"; type McpRouteKind = "mcp" | "oauth-protected-resource" | "oauth-authorization-server"; type McpRoute = {  readonly kind: McpRouteKind;  /** Org selector pinned in the URL (`/acme/mcp` slug or legacy `/org_xxx/mcp`   *  id), or `null` for the bare path. Resolved to an org id — and re-checked   *  against live membership — in the auth provider. */  readonly organizationId: string | null;  readonly toolkitSlug?: string;} | null; // A path segment counts as an org selector when it's the org's URL slug (the// canonical form the install card prints) or has the WorkOS org-id shape// (`org_…`, the legacy form already in agents' configs). The slug grammar// reserves every routable root segment (`integrations`, `api-keys`, …), so an// unrelated `/<seg>/mcp` still falls through to routing.const orgSelectorSegment = (segment: string | undefined): string | null =>  segment && (segment.startsWith("org_") || isValidOrgSlug(segment)) ? segment : null; type MatchedMcpSuffix = {  readonly organizationId: string | null;  readonly toolkitSlug?: string;}; // Matches a trailing MCP endpoint: `mcp`, `mcp/toolkits/<slug>`, or either with// a leading org selector. Returns undefined when the segments are not MCP.const matchMcpSuffix = (segments: readonly string[]): MatchedMcpSuffix | undefined => {  if (segments.length === 1 && segments[0] === "mcp") return { organizationId: null };  if (segments.length === 3 && segments[0] === "mcp" && segments[1] === "toolkits") {    const toolkitSlug = segments[2];    return toolkitSlug ? { organizationId: null, toolkitSlug } : undefined;  }  if (segments.length === 2 && segments[1] === "mcp") {    const organizationId = orgSelectorSegment(segments[0]);    return organizationId ? { organizationId } : undefined;  }  if (segments.length === 4 && segments[1] === "mcp" && segments[2] === "toolkits") {    const organizationId = orgSelectorSegment(segments[0]);    const toolkitSlug = segments[3];    return organizationId && toolkitSlug ? { organizationId, toolkitSlug } : undefined;  }  return undefined;}; /** * Returns the MCP route (kind + optional URL-pinned org) for a pathname, or * `null` if the path isn't owned by the MCP handler. * * Exported so the test worker and start.ts's middleware share the exact same * "is this an MCP path?" predicate — under the envelope `HttpRouter.toWebHandler` * 404s unknown paths rather than returning `null`, so this gate decides whether * to even invoke the envelope handler (null -> fall through to Start routing). * Recognizes the bare `/mcp` + the two discovery docs AND their org-scoped * variants (`/org_xxx/mcp`, `/.well-known/oauth-protected-resource/org_xxx/mcp`); * only `org_…`-shaped segments are claimed. `prepareMcpOrgScope` then rewrites an * org-scoped path to the bare path the shared envelope actually routes. */export const classifyMcpPath = (pathname: string): McpRoute => {  if (pathname === AUTHORIZATION_SERVER_METADATA_PATH) {    return { kind: "oauth-authorization-server", organizationId: null };  }  const segments = pathname.split("/").filter((segment) => segment.length > 0);   // Protected-resource metadata: `${prefix}/mcp` or `${prefix}/<org>/mcp`. The  // org sits after the well-known prefix (RFC 9728), not at the path root.  const prmPrefix = "/.well-known/oauth-protected-resource";  if (pathname.startsWith(`${prmPrefix}/`)) {    const matched = matchMcpSuffix(segments.slice(2));    return matched === undefined ? null : { kind: "oauth-protected-resource", ...matched };  }   // MCP transport: `/mcp` or `/<org>/mcp`.  const matched = matchMcpSuffix(segments);  return matched === undefined ? null : { kind: "mcp", ...matched };}; const bareMcpPath = (route: Exclude<McpRoute, null>): string =>  route.kind === "mcp"    ? route.toolkitSlug      ? `${MCP_PATH}/toolkits/${route.toolkitSlug}`      : MCP_PATH    : route.kind === "oauth-protected-resource"      ? route.toolkitSlug        ? `${PROTECTED_RESOURCE_METADATA_PATH}/toolkits/${route.toolkitSlug}`        : PROTECTED_RESOURCE_METADATA_PATH      : AUTHORIZATION_SERVER_METADATA_PATH; /** * Normalize an org-scoped MCP request for the shared envelope, which routes ONLY * the bare `/mcp` + bare discovery paths. Rewrites `/org_xxx/mcp` (and the * org-scoped discovery doc) to its bare path and carries the URL-pinned org in * the internal `MCP_ORGANIZATION_HEADER` the cloud provider reads. A bare path is * left untouched, except any client-supplied org header is stripped — the org may * come ONLY from the URL (membership is still re-checked per request, so this is * a selector, not a trust boundary). Shared by start.ts (production) and the test * worker so both classify + rewrite identically; a no-op for non-MCP paths. */export const prepareMcpOrgScope = (request: Request): Request => {  const url = new URL(request.url);  const route = classifyMcpPath(url.pathname);  if (route === null) return request;  const bare = bareMcpPath(route);  if (url.pathname === bare && !request.headers.has(MCP_ORGANIZATION_HEADER)) return request;  url.pathname = bare;  const rewritten = new Request(url, request);  if (route.organizationId) rewritten.headers.set(MCP_ORGANIZATION_HEADER, route.organizationId);  else rewritten.headers.delete(MCP_ORGANIZATION_HEADER);  return rewritten;}; // Production no longer mounts the /mcp transport here. `server.ts` intercepts MCP// transport requests for the hibernatable Agent bridge, while `ExecutorApp.make`// serves the OAuth discovery docs through the `auth` seam's discovery routes.// `classifyMcpPath` + `prepareMcpOrgScope` remain because `server.ts`'s request// dispatch uses them to recognize and normalize MCP paths.