@softure-ai/mcp-access 0.1.6 → 0.1.8

package/src/next/pages.tsx

@@ -7,14 +7,15 @@ import { requireUser } from "@softure-ai/auth/next";
 import { formatMessage, type SoftureConfig } from "@softure-ai/core";
 import { getSoftureConfig } from "@softure-ai/core/next";
 import { Card } from "@softure-ai/ui";
-import type { AccessTokenStatus, AccessTokenView } from "../contract.js";
+import type { AccessTokenStatus, AccessTokenView, OAuthGrantView } from "../contract.js";
 import type { McpAccessMessages } from "../messages/index.js";
 import type { McpAccessOptions } from "../options.js";
 import { getLocalizedText, getMcpAccessMessages, getMcpAccessOptions, getMcpAccessRoutes } from "../server/options.js";
+import { listOAuthGrants } from "../server/oauth.js";
 import { listAccessTokens } from "../server/tokens.js";
 import { getAccessTokenStatus } from "../token-status.js";
-import { TokenManager, type TokenManagerRow, type TokenManagerTool } from "../ui/token-manager.js";
-import { issueTokenAction, revokeTokenAction } from "./actions.js";
+import { TokenManager, type TokenManagerGrant, type TokenManagerRow, type TokenManagerTool } from "../ui/token-manager.js";
+import { issueTokenAction, revokeGrantAction, revokeTokenAction } from "./actions.js";
 import { getMcpAccessContext } from "./context.js";
 import { formatDate, formatDateTime } from "./format.js";
 
@@ -48,6 +49,16 @@ function toRow(token: AccessTokenView, now: Date, config: SoftureConfig, options
   };
 }
 
+function toGrant(grant: OAuthGrantView, config: SoftureConfig, options: McpAccessOptions, messages: McpAccessMessages): TokenManagerGrant {
+  const lastUse = grant.lastUsedAt === null ? messages.list.neverUsed : formatMessage(messages.list.lastUsed, { date: formatDateTime(config, grant.lastUsedAt) });
+  return {
+    id: grant.id,
+    clientName: grant.clientName,
+    scopeText: grant.canWrite && options.allowWrites ? messages.list.readWrite : messages.list.readOnly,
+    details: [formatMessage(messages.grants.connectedOn, { date: formatDate(config, grant.createdAt) }), lastUse],
+  };
+}
+
 function toTool(tool: McpAccessOptions["tools"][number], config: SoftureConfig, options: McpAccessOptions, messages: McpAccessMessages): TokenManagerTool {
   const accessText = tool.access === "read" ? messages.tools.read : options.allowWrites ? messages.tools.write : messages.tools.writeUnavailable;
   return { name: tool.name, description: getLocalizedText(tool.description, config.locale), accessText };
@@ -61,6 +72,7 @@ export async function McpAccessPage() {
   const ctx = await getMcpAccessContext(config);
   const now = ctx.clock.now();
   const tokens = await listAccessTokens(ctx, user.id);
+  const grants = options.oauth.enabled ? await listOAuthGrants(ctx, user.id) : null;
   return (
     <main className={LAYOUT_CLASS}>
       <Card title={messages.page.title} subtitle={messages.page.lead}>
@@ -71,6 +83,7 @@ export async function McpAccessPage() {
           maxTokens={options.maxTokensPerUser}
           issueAction={issueTokenAction}
           revokeAction={revokeTokenAction}
+          {...(grants === null ? {} : { grants: grants.map((grant) => toGrant(grant, config, options, messages)), revokeGrantAction })}
           messages={messages}
           locale={config.locale}
         />

package/src/options.ts

@@ -1,6 +1,7 @@
 // The options an app passes to `mcpAccess({ ... })` in softure.config.ts, parsed at startup.
 import { LOCALES } from "@softure-ai/core";
 import { z } from "zod";
+import type { McpOriginRequest, McpOrigins } from "./origins.js";
 
 /** The name an MCP client lists the server under: no spaces, so a shell command needs no quotes. */
 export const SERVER_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
@@ -11,6 +12,9 @@ export const TOOL_NAME_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
 /** The longest token name the table takes (`access_tokens.name`). */
 export const MAX_TOKEN_NAME_LENGTH = 60;
 
+/** The longest value the token check looks at: a longer header is refused before any pattern runs. */
+export const MAX_PRESENTED_TOKEN_LENGTH = 512;
+
 /** Copy per locale; a locale without its own text falls back to `en`. */
 const localizedTextSchema = z.partialRecord(z.enum(LOCALES), z.string().trim().min(1).max(500));
 
@@ -26,6 +30,88 @@ const toolSchema = z.strictObject({
   description: localizedTextSchema.refine((text) => text.en !== undefined, "needs at least an en text"),
 });
 
+/**
+ * Keys of the authorization server metadata the package generates. An extension cannot set them:
+ * they decide where a client sends a person and its secrets.
+ */
+export const GENERATED_AUTHORIZATION_SERVER_KEYS = [
+  "issuer",
+  "authorization_endpoint",
+  "token_endpoint",
+  "registration_endpoint",
+  "scopes_supported",
+  "response_types_supported",
+  "response_modes_supported",
+  "grant_types_supported",
+  "token_endpoint_auth_methods_supported",
+  "code_challenge_methods_supported",
+  "authorization_response_iss_parameter_supported",
+] as const;
+
+/** Keys of the protected resource metadata the package generates; `resource_name` is the app's to replace. */
+export const GENERATED_PROTECTED_RESOURCE_KEYS = ["resource", "authorization_servers", "scopes_supported", "bearer_methods_supported"] as const;
+
+/** Extra keys of a discovery document: a JSON object, or computed from the request's origins. */
+export type McpMetadataExtension = Readonly<Record<string, unknown>> | ((origins: McpOrigins) => Readonly<Record<string, unknown>>);
+
+/** The app origin of one request, or null for `appOrigin`. */
+export type McpAppOriginResolver = (request: McpOriginRequest) => string | null;
+
+function metadataExtensionSchema(generated: readonly string[]) {
+  return z.union([
+    z.custom<(origins: McpOrigins) => Readonly<Record<string, unknown>>>((value) => typeof value === "function"),
+    z.record(z.string(), z.unknown()).superRefine((record, context) => {
+      for (const key of generated) {
+        if (Object.hasOwn(record, key)) context.addIssue({ code: "custom", path: [key], message: `"${key}" is generated by the module and cannot be set` });
+      }
+    }),
+  ], { error: "must be an object of extra keys or a function (origins) => object" });
+}
+
+/** A bare http(s) origin (no path, query, fragment or credentials), reduced to its origin. */
+export function isBareOrigin(value: string): boolean {
+  if (!URL.canParse(value)) return false;
+  const url = new URL(value);
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  return url.username === "" && url.password === "" && (url.pathname === "/" || url.pathname === "") && !value.includes("?") && !value.includes("#");
+}
+
+const originSchema = z
+  .string()
+  .refine((value) => isBareOrigin(value), "must be an http(s) origin such as https://example.com, without a path, query or credentials")
+  .transform((value) => new URL(value).origin);
+
+const oauthSchema = z.strictObject({
+  /**
+   * Makes the module an OAuth 2.1 authorization server for its endpoint: discovery metadata,
+   * dynamic client registration, a consent page and a token endpoint. The app mounts those routes.
+   */
+  enabled: z.boolean().default(false),
+  /** How long an access token issued through OAuth works. Clients refresh it themselves. */
+  accessTokenLifetimeMinutes: z.int().min(5).max(1440).default(60),
+  /** How long a refresh token works, counted from the last refresh: a grant in use never expires. */
+  refreshTokenLifetimeDays: z.int().min(1).max(365).default(90),
+  /** How long an authorization code works; RFC 6749 §4.1.2 recommends at most ten minutes. */
+  authorizationCodeLifetimeMinutes: z.int().min(1).max(10).default(10),
+  /**
+   * Extra keys of the discovery documents (e.g. `jwks_uri`, `service_documentation`,
+   * `resource_documentation`, `agent_auth`). Generated keys win; the protected resource document
+   * takes the app's `resource_name`.
+   */
+  metadata: z
+    .strictObject({
+      authorizationServer: metadataExtensionSchema(GENERATED_AUTHORIZATION_SERVER_KEYS).optional(),
+      protectedResource: metadataExtensionSchema(GENERATED_PROTECTED_RESOURCE_KEYS).optional(),
+    })
+    .prefault({}),
+});
+
+/** A pattern for tokens an app issued before adopting the module: anchored, and stateless. */
+const legacyTokenPatternSchema = z
+  .instanceof(RegExp, { message: "must be a RegExp" })
+  .refine((pattern) => pattern.source.startsWith("^") && pattern.source.endsWith("$"), "must be anchored with ^ and $")
+  .refine((pattern) => !pattern.global && !pattern.sticky, "must not use the g or y flag");
+
 export const mcpAccessOptionsSchema = z
   .strictObject({
     /** The name MCP clients list the server under, e.g. "acme". Used in the setup instructions. */
@@ -34,12 +120,31 @@ export const mcpAccessOptionsSchema = z
     tools: z.array(toolSchema).default([]),
     /** Lets write tokens be issued and used. Off, every token reads only, write tokens included. */
     allowWrites: z.boolean().default(false),
-    /** How long a token works. A choice: longer than a session, never forever. */
+    /** How long a token issued on the token page works. A choice: longer than a session, never forever. */
     tokenLifetimeDays: z.int().min(1).max(365).default(90),
     /** How many unexpired tokens one account may hold. */
     maxTokensPerUser: z.int().min(1).max(100).default(20),
     /** From how many calendar days before its expiry the page warns about a token. */
     expiryWarningDays: z.int().min(0).max(60).default(14),
+    /**
+     * Tokens an app issued before it adopted the module, e.g. `/^[0-9a-f]{64}$/`. Such a value is
+     * looked up by its sha256 like a token of the module's own shape; new tokens keep the prefix.
+     */
+    legacyTokenPattern: legacyTokenPatternSchema.optional(),
+    /**
+     * The app origin of a request, when it is not the fixed `appOrigin`: an image built once and
+     * served under another origin, or a proxy whose `request.url` does not carry the public host.
+     * `readRequestOrigin` (`/server`) reads it from `Host`. Null keeps `appOrigin`.
+     */
+    resolveAppOrigin: z.custom<McpAppOriginResolver>((value) => typeof value === "function", "must be a function (request) => string | null").optional(),
+    /**
+     * Other public hosts of the app, e.g. the apex when the product runs on `app.`: their root
+     * protected resource metadata names that host as `resource` (RFC 9728 §3.3), and the
+     * authorization and token endpoints accept it as `resource`.
+     */
+    resourceOrigins: z.array(originSchema).max(16, "takes at most 16 origins").default([]),
+    /** OAuth 2.1 for MCP clients that connect without a pasted token (claude.ai, ChatGPT). */
+    oauth: oauthSchema.prefault({}),
   })
   .superRefine((options, context) => {
     const names = new Set<string>();
@@ -56,3 +161,4 @@ export type McpAccessOptions = z.output<typeof mcpAccessOptionsSchema>;
 export type McpToolDefinitionInput = z.input<typeof toolSchema>;
 export type McpToolDefinition = z.output<typeof toolSchema>;
 export type McpToolAccess = McpToolDefinition["access"];
+export type McpOAuthOptions = z.output<typeof oauthSchema>;

package/src/origins.ts

@@ -0,0 +1,48 @@
+// The origins one request is served under: the app origin every OAuth URL is built from, and the
+// other public hosts whose root may be named as a protected resource. Pure: no config, no database.
+
+/** What the origin helpers read from a request: a Web `Request`, or Next's `headers()` with a URL. */
+export interface McpOriginRequest {
+  readonly url: string;
+  readonly headers: { get(name: string): string | null };
+}
+
+export interface McpOrigins {
+  /** The issuer, and the origin of every endpoint, of `resource_metadata` and of the consent form. */
+  readonly appOrigin: string;
+  /** Other public hosts (`resourceOrigins`), each a bare origin. */
+  readonly resourceOrigins: readonly string[];
+}
+
+function firstValue(header: string | null): string | null {
+  const value = header?.split(",")[0]?.trim().toLowerCase();
+  return value === undefined || value === "" ? null : value;
+}
+
+/** The host the request was sent to: `Host`, else the URL's host. Behind a proxy the URL names the server's own. */
+export function readRequestHost(request: McpOriginRequest): string {
+  return firstValue(request.headers.get("host")) ?? new URL(request.url).host;
+}
+
+/**
+ * The origin the request was sent to: the first `X-Forwarded-Proto` value when it is http or https
+ * (else the URL's scheme) and `Host` (else the URL's host). For `resolveAppOrigin` in an app whose
+ * proxy passes `Host` through and refuses hosts it does not serve.
+ */
+export function readRequestOrigin(request: McpOriginRequest): string {
+  const url = new URL(request.url);
+  const proto = firstValue(request.headers.get("x-forwarded-proto"));
+  const scheme = proto === "http" || proto === "https" ? proto : url.protocol.replace(/:$/, "");
+  return new URL(`${scheme}://${readRequestHost(request)}`).origin;
+}
+
+/**
+ * The resource origin the request was sent to, when its host is one of `resourceOrigins`; when two
+ * share the host, the one whose scheme `X-Forwarded-Proto` names wins, else the first. Null otherwise.
+ */
+export function findServedResourceOrigin(origins: McpOrigins, request: McpOriginRequest): string | null {
+  const host = readRequestHost(request);
+  const candidates = origins.resourceOrigins.filter((origin) => new URL(origin).host === host);
+  const proto = firstValue(request.headers.get("x-forwarded-proto"));
+  return candidates.find((origin) => new URL(origin).protocol === `${proto ?? ""}:`) ?? candidates[0] ?? null;
+}

package/src/schema.ts

@@ -1,10 +1,54 @@
-// Drizzle view of the module's table (migrations/0001_create_access_tokens.sql). The migration is
-// the source of truth; this file only types the queries.
+// Drizzle view of the module's tables (migrations/0001_create_access_tokens.sql and
+// 0002_create_oauth_grants.sql). The migrations are the source of truth; this file only types the
+// queries.
 import { users } from "@softure-ai/auth";
-import { boolean, pgSchema, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { boolean, jsonb, pgSchema, text, timestamp, uuid, type AnyPgColumn } from "drizzle-orm/pg-core";
 
 export const mcpSchema = pgSchema("mcp");
 
+export const oauthClients = mcpSchema.table("oauth_clients", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  clientId: text("client_id").notNull().unique("oauth_clients_client_id_key"),
+  clientName: text("client_name").notNull(),
+  redirectUris: jsonb("redirect_uris").$type<string[]>().notNull(),
+  tokenEndpointAuthMethod: text("token_endpoint_auth_method").$type<"none" | "client_secret_post" | "client_secret_basic">().notNull(),
+  clientSecretHash: text("client_secret_hash"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+});
+
+export const oauthAuthorizationCodes = mcpSchema.table("oauth_authorization_codes", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  codeHash: text("code_hash").notNull().unique("oauth_authorization_codes_code_hash_key"),
+  clientId: uuid("client_id")
+    .notNull()
+    .references(() => oauthClients.id, { onDelete: "cascade" }),
+  userId: uuid("user_id")
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  redirectUri: text("redirect_uri").notNull(),
+  codeChallenge: text("code_challenge").notNull(),
+  canWrite: boolean("can_write").notNull(),
+  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+  usedAt: timestamp("used_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+});
+
+export const oauthGrants = mcpSchema.table("oauth_grants", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  userId: uuid("user_id")
+    .notNull()
+    .references(() => users.id, { onDelete: "cascade" }),
+  clientId: uuid("client_id")
+    .notNull()
+    .references(() => oauthClients.id, { onDelete: "cascade" }),
+  canWrite: boolean("can_write").notNull(),
+  refreshTokenHash: text("refresh_token_hash").notNull().unique("oauth_grants_refresh_token_hash_key"),
+  previousRefreshTokenHash: text("previous_refresh_token_hash"),
+  refreshExpiresAt: timestamp("refresh_expires_at", { withTimezone: true }).notNull(),
+  lastUsedAt: timestamp("last_used_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+});
+
 export const accessTokens = mcpSchema.table("access_tokens", {
   id: uuid("id").primaryKey().defaultRandom(),
   userId: uuid("user_id")
@@ -16,4 +60,8 @@ export const accessTokens = mcpSchema.table("access_tokens", {
   createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
   expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
   lastUsedAt: timestamp("last_used_at", { withTimezone: true }),
+  grantId: uuid("grant_id").references((): AnyPgColumn => oauthGrants.id, { onDelete: "cascade" }),
 });
+
+export type OAuthClientRow = typeof oauthClients.$inferSelect;
+export type OAuthTokenEndpointAuthMethod = OAuthClientRow["tokenEndpointAuthMethod"];

package/src/server/context.ts

@@ -0,0 +1,14 @@
+// The module context (`{ db, clock, config }`) from the configuration: the process-wide database
+// handle and the wall clock. For apps that compose their own routes from `/server`; the `/next`
+// adapter builds its context with it.
+import { systemClock, type SoftureConfig } from "@softure-ai/core";
+import { getConfiguredDatabase } from "@softure-ai/db";
+import type { McpAccessContext } from "./tokens.js";
+
+export async function createMcpAccessContext(config: SoftureConfig): Promise<McpAccessContext> {
+  if (config.database === null) {
+    throw new Error("@softure-ai/mcp-access: softure.config.ts has no database; mcp-access needs one");
+  }
+  const { db } = await getConfiguredDatabase(config.database);
+  return { db, clock: systemClock, config };
+}

package/src/server/endpoint.ts

@@ -1,4 +1,4 @@
-// The MCP endpoint (FIRE_TRACKER `src/app/api/mcp/route.ts`, generalised). It takes a Web
+// The MCP endpoint (an adopting app's MCP route, generalised). It takes a Web
 // `Request` and returns a `Response`, so it runs under any fetch-shaped host; the Next adapter only
 // supplies the context. Order: identify the client, count the request, verify the Bearer token,
 // then hand the request to a fresh server from the app's factory. Each refusal happens before the
@@ -15,12 +15,12 @@ import {
 import { errorLogLabel, getModule } from "@softure-ai/core";
 import { consumeRateLimit, identifyClient } from "@softure-ai/security/server";
 import type { McpServerIdentity } from "../contract.js";
+import { getProtectedResourceMetadataUrl, isOAuthEnabled } from "./oauth-http.js";
+import { resolveMcpOrigins } from "./origins.js";
+import { MCP_READ_SCOPE, MCP_WRITE_SCOPE } from "./scopes.js";
 import { verifyAccessToken, type McpAccessContext } from "./tokens.js";
 
-/** Every valid token reads. */
-export const MCP_READ_SCOPE = "mcp:read";
-/** A token that may write: issued for writes, and the app allows them. */
-export const MCP_WRITE_SCOPE = "mcp:write";
+export { MCP_READ_SCOPE, MCP_WRITE_SCOPE };
 
 /** The security bucket the endpoint counts in; `MCP_RATE_LIMIT_BUCKETS` holds its default. */
 export const MCP_RATE_LIMIT_BUCKET = "mcp";
@@ -80,7 +80,7 @@ export function createMcpEndpoint({ createServer }: McpEndpointOptions): McpEndp
       );
     }
 
-    const authInfo = await authenticate(ctx, request.headers.get("authorization"));
+    const authInfo = await authenticate(ctx, request);
     if (authInfo instanceof Response) return authInfo;
     return handler.fetch(request, { authInfo });
   };
@@ -89,10 +89,15 @@ export function createMcpEndpoint({ createServer }: McpEndpointOptions): McpEndp
 /**
  * The verified identity as the SDK's `AuthInfo`, or the challenge response. Unknown, revoked,
  * expired and malformed tokens get the same `401 invalid_token`. Expiry is decided by the query on
- * the module's clock, not by the SDK's own check on the wall clock.
+ * the module's clock, not by the SDK's own check on the wall clock. With OAuth on, the challenge
+ * names the protected resource metadata (RFC 9728 §5.1): that is how claude.ai and ChatGPT find
+ * the authorization server.
  */
-async function authenticate(ctx: McpAccessContext, header: string | null): Promise<AuthInfo | Response> {
-  const challenge = { requiredScopes: [MCP_READ_SCOPE] };
+async function authenticate(ctx: McpAccessContext, request: Request): Promise<AuthInfo | Response> {
+  const header = request.headers.get("authorization");
+  const challenge = isOAuthEnabled(ctx.config)
+    ? { requiredScopes: [MCP_READ_SCOPE], resourceMetadataUrl: getProtectedResourceMetadataUrl(ctx.config, resolveMcpOrigins(ctx.config, request)) }
+    : { requiredScopes: [MCP_READ_SCOPE] };
   if (header === null || !BEARER_PREFIX.test(header)) {
     return bearerAuthChallengeResponse(new OAuthError(OAuthErrorCode.InvalidToken, "Missing Bearer token"), challenge);
   }

package/src/server/health.ts

@@ -1,5 +1,6 @@
-// The module's readiness probe for `GET /api/health` of `@softure-ai/ops`: the tokens table exists
-// and answers, i.e. `softure migrate` ran. It reads no rows.
+// The module's readiness probe for `GET /api/health` of `@softure-ai/ops`: the tokens table (with
+// its grant column) and the grants table exist and answer, i.e. `softure migrate` ran every file.
+// It reads no rows.
 import { ok, type HealthCheck } from "@softure-ai/core";
 import type { Queryable } from "@softure-ai/db";
 import { sql } from "drizzle-orm";
@@ -7,6 +8,7 @@ import { sql } from "drizzle-orm";
 export const checkAccessTokensTable: HealthCheck = async (context) => {
   // Core types `db` as unknown; the health route passes the @softure-ai/db handle.
   const db = context.db as Queryable;
-  await db.execute(sql`select 1 from mcp.access_tokens limit 0`);
+  await db.execute(sql`select grant_id from mcp.access_tokens limit 0`);
+  await db.execute(sql`select 1 from mcp.oauth_grants join mcp.oauth_clients on oauth_clients.id = oauth_grants.client_id limit 0`);
   return ok();
 };

package/src/server/index.ts

@@ -10,7 +10,63 @@ export {
   type McpEndpointOptions,
   type McpServerFactory,
 } from "./endpoint.js";
+export { createMcpAccessContext } from "./context.js";
 export { checkAccessTokensTable } from "./health.js";
+export {
+  CONSENT_CODE_PREFIX,
+  CLIENT_SECRET_PREFIX,
+  createAuthorizationCode,
+  exchangeAuthorizationCode,
+  findOAuthClient,
+  isClientSecretValid,
+  listOAuthGrants,
+  pruneOAuthRecords,
+  REFRESH_TOKEN_PREFIX,
+  refreshMcpGrant,
+  registerMcpClient,
+  revokeOAuthGrant,
+  type CreateAuthorizationCodeInput,
+  type ExchangeAuthorizationCodeInput,
+  type IssuedOAuthTokens,
+  type OAuthClientRegistration,
+  type PrunedOAuthRecords,
+  type RefreshOAuthGrantInput,
+  type RegisteredOAuthClient,
+  type RevokeOAuthGrantInput,
+} from "./oauth.js";
+export {
+  answerOAuthPreflight,
+  AUTHORIZATION_PARAMS,
+  AUTHORIZATION_SERVER_METADATA_PATH,
+  buildClientRedirect,
+  getAuthorizationServerMetadata,
+  getConsentPath,
+  getOAuthIssuer,
+  getProtectedResourceMetadata,
+  getProtectedResourceMetadataUrl,
+  getRootProtectedResourceMetadata,
+  handleAuthorizationDecision,
+  handleClientRegistration,
+  handleTokenRequest,
+  isAcceptableResource,
+  isOAuthEnabled,
+  isWriteScopeRequested,
+  MCP_OAUTH_RATE_LIMIT_BUCKET,
+  OAUTH_SCOPES,
+  PROTECTED_RESOURCE_METADATA_PATH,
+  readAuthorizationParams,
+  serveDiscoveryDocument,
+  validateAuthorizationRequest,
+  type AuthorizationOutcome,
+  type AuthorizationPageError,
+  type AuthorizationRequest,
+  type DiscoveryDocument,
+} from "./oauth-http.js";
+export { findServedResourceOrigin, readRequestHost, readRequestOrigin, type McpOriginRequest, type McpOrigins } from "../origins.js";
+export { resolveMcpOrigins } from "./origins.js";
+export type { OAuthClientRow, OAuthTokenEndpointAuthMethod } from "../schema.js";
+export { describeRedirectUri, isAllowedRedirectUri, MAX_CLIENT_NAME_LENGTH, parseClientRegistration, type ClientRegistrationResult, type RegistrationError } from "./oauth-validation.js";
+export { getCodeChallenge, isPkceVerifierValid, isValidCodeChallenge, PKCE_METHOD } from "./pkce.js";
 export { getMcpAccessMessages, getMcpAccessOptions, getMcpAccessRoutes, getMcpEndpointUrl, type McpAccessRoutes } from "./options.js";
 export {
   deleteMcpAccessUserData,