better-supabase 0.5.1 → 0.6.0

package/dist/mcp/index.d.ts

@@ -1,8 +1,9 @@
-import { P as TableKey, n as AnyFunctions, r as AnyModels } from "../types-Dnf_wRDz.js";
-import { t as BetterSupabase } from "../define-Bp_BZa5h.js";
-import { f as ServerContext, n as GuardOptions, p as ServerOptions, u as BetterServer } from "../respond-BR1fJWOB.js";
-import { i as ResourceOperation } from "../index-C7f8cOBM.js";
-import { a as ResourceRouteOptions } from "../resource-DNRFP7KR.js";
+import { L as TableKey, a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
+import { t as BetterSupabase } from "../define-CJJkkr1-.js";
+import { i as ServerContext, o as ServerOptions, t as BetterServer } from "../server-CeVeeXwz.js";
+import { r as GuardOptions } from "../respond-DoBijysA.js";
+import { i as ResourceOperation } from "../index-Bxih3l0u.js";
+import { a as ResourceRouteOptions } from "../resource-D6Uc7Sk7.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/mcp/mcp.d.ts
 export declare const MCP_PROTOCOL_VERSION: string;
@@ -39,7 +40,7 @@ interface McpTool<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P
 /** What the `authorize` and `visible` hooks see of a tool. */
 interface ToolRef {
   readonly info: ToolInfo;
-  /** The tool's `meta`, e.g. a PermDock permission. For table tools, the resource's `meta` for that operation. */
+  /** The tool's `meta`, e.g. a permission. For table tools, the resource's `meta` for that operation. */
   readonly meta: unknown;
 }
 /** The outcome of `authorize`. `scopes` turns a refusal into an OAuth challenge. */
@@ -70,7 +71,7 @@ interface ToolDefinition<M extends AnyModels, F extends AnyFunctions, E, I, C =
 /** A table's tools: the REST resource options, plus `meta` per operation for `authorize` and `visible`. */
 type ToolResourceOptions<M extends AnyModels, T extends TableKey<M>> = ResourceRouteOptions<M, T> & {
   /**
-   * Opaque data per operation, e.g. a PermDock permission, passed to
+   * Opaque data per operation, e.g. a permission, passed to
    * `authorize` and `visible` as the table tool's `meta`. Never sent to
    * clients. An operation without an entry gets `undefined`.
    */
@@ -88,10 +89,14 @@ interface McpOptions<M extends AnyModels, F extends AnyFunctions, E, C = unknown
   readonly tools?: readonly McpTool<M, F, E, C, P>[];
   /**
    * Canonical URL of this MCP server (RFC 9728 `resource`). Defaults to the
-   * request URL without query.
+   * request URL without query; on Supabase Edge Functions, to the public
+   * `<origin>/functions/v1/<slug>` the gateway forwards.
    */
   readonly resource?: string | ((request: Request) => string);
-  /** Defaults to Supabase Auth of `env.url` (`<url>/auth/v1`). */
+  /**
+   * Defaults to Supabase Auth of `env.url` (`<url>/auth/v1`); on Supabase Edge
+   * Functions, to Auth on the public origin.
+   */
   readonly authorizationServers?: readonly string[];
   /**
    * Scopes the tools need, published as RFC 9728 `scopes_supported` and in
@@ -99,15 +104,32 @@ interface McpOptions<M extends AnyModels, F extends AnyFunctions, E, C = unknown
    * tokens are between the client and the authorization server.
    */
   readonly advertisedScopes?: readonly string[];
-  /** @deprecated Use `advertisedScopes`; `requiredScopes` is what `guard` enforces. */
-  readonly scopes?: readonly string[];
   /**
    * Scopes a delegated token (an OAuth client or an `act` chain) needs to call
    * the server at all. A missing one answers 403 `insufficient_scope`.
    */
   readonly requiredScopes?: readonly string[];
+  /**
+   * Roles a signed-in user needs to call the server at all, read from a
+   * claim (`app_metadata.role` by default; a string or an array of
+   * strings). Users without one get 403; service-role callers pass.
+   *
+   * ```ts
+   * requiredRoles: { roles: ['admin', 'support'], claim: 'app_metadata.roles' }
+   * ```
+   */
+  readonly requiredRoles?: readonly string[] | {
+    readonly roles: readonly string[];
+    readonly claim?: string;
+  };
   /** Origins allowed to call the server (DNS rebinding protection). Defaults to any. */
   readonly allowedOrigins?: readonly string[];
+  /**
+   * Answers CORS preflights and adds `Access-Control-*` headers, so browser
+   * MCP clients can call the server. The allowed origin is `allowedOrigins`
+   * when set, any origin otherwise. Defaults to true.
+   */
+  readonly cors?: boolean;
   /**
    * Hostnames the `Host` header may name, without the port (DNS rebinding
    * protection). List the production, preview and local hosts. Defaults to any.
@@ -119,6 +141,11 @@ interface McpOptions<M extends AnyModels, F extends AnyFunctions, E, C = unknown
   readonly json?: Readonly<Record<string, unknown>>;
   /** Include internal error messages in tool results. Defaults to `NODE_ENV === 'development'`. */
   readonly exposeErrors?: boolean;
+  /**
+   * Keeps the invocation alive for event sink sends a tool started, e.g.
+   * `EdgeRuntime.waitUntil` or Next's `after`.
+   */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
   /**
    * Decides each `tools/call` after the arguments are validated and before
    * `run`. `args` are the validated arguments (raw for table tools, which

package/dist/mcp/index.js

@@ -1,15 +1,18 @@
-import { n as dbError } from "../errors-DtwXa6b8.js";
+import { n as dbError } from "../errors-B11Duf73.js";
 import { t as base64ToText } from "../base64-D2gsioCY.js";
-import { t as validate } from "../standard-D7r6dMUu.js";
-import { a as problemResponse, o as toProblem } from "../problem-BW1KhzSG.js";
-import { t as SPEC_PINS } from "../spec-pins-C3oc-Tdp.js";
-import { t as buildJsonSchema } from "../json-schema-m1fiwKgN.js";
-import { a as withExtra, d as guard, g as jsonResponse, h as jsonReplacer, m as settle, n as createServer, r as extendServer, u as defaultExpose } from "../server-B1mZ7CgQ.js";
-import { t as defineResource } from "../resource-mqfJW4YF.js";
-import { fromSupabaseUrl, unauthorizedResponse } from "@supabase/server/oauth-protected-resource";
+import { n as validate } from "../standard-BK0cqJ7y.js";
+import { a as problemResponse, o as toProblem } from "../problem-BreOl8b8.js";
+import { t as SPEC_PINS } from "../spec-pins--j6mTok4.js";
+import { t as buildJsonSchema } from "../json-schema-CvER4kgT.js";
+import { c as extendServer, l as withExtra, n as flushEvents, s as createServer } from "../adapter-Bc1o3zyy.js";
+import { n as jsonResponse, t as jsonReplacer } from "../json-CEnpTHlZ.js";
+import { o as settle, r as guard, t as defaultExpose } from "../respond-BUgsXNgk.js";
+import { t as defineResource } from "../resource-BsvzCMlX.js";
+import { r as hasRole } from "../kit-Fm-Fv7q5.js";
+import { a as withCors, i as metadataPreflight, n as endpointPreflight, r as isMetadataRequest, t as discovery } from "../http-DdYadv-o.js";
+import { resourceMetadataResponse, unauthorizedResponse } from "@supabase/server/oauth-protected-resource";
 //#region src/mcp/mcp.ts
 const MCP_PROTOCOL_VERSION = SPEC_PINS.mcp;
-const WELL_KNOWN = "/.well-known/oauth-protected-resource";
 /** Revisions before 2026-07-28 open with an `initialize` handshake. */
 const LEGACY_VERSIONS = [
 	"2025-11-25",
@@ -17,9 +20,8 @@ const LEGACY_VERSIONS = [
 	"2025-03-26"
 ];
 const SUPPORTED_VERSIONS = [MCP_PROTOCOL_VERSION, ...LEGACY_VERSIONS];
-/** The `Host` header's hostname is in the list; a missing or malformed header is not. */
-function hostAllowed(request, allowed) {
-	const host = request.headers.get("host");
+/** The host's hostname is in the list; a missing or malformed host is not. */
+function hostAllowed(host, allowed) {
 	if (!host) return false;
 	try {
 		return allowed.includes(new URL(`http://${host}`).hostname);
@@ -27,6 +29,16 @@ function hostAllowed(request, allowed) {
 		return false;
 	}
 }
+/** The refusal for a caller without one of `required`'s roles. */
+function missingRole(auth, required) {
+	if (!required || auth.kind === "service") return void 0;
+	const { roles, claim } = "roles" in required ? required : {
+		roles: required,
+		claim: void 0
+	};
+	if (roles.length === 0 || hasRole(auth, roles, claim)) return void 0;
+	return dbError("forbidden", `This server needs the role ${roles.join(" or ")}`, { code: "MISSING_ROLE" });
+}
 /** A custom tool. Pass it in `createMcp({ tools: [...] })`. */
 function defineTool(definition) {
 	if (!/^[A-Za-z0-9_.-]{1,64}$/.test(definition.name)) throw new TypeError(`Invalid tool name "${definition.name}": use 1-64 letters, digits, "_", "-" or "."`);
@@ -184,6 +196,8 @@ const META_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
 const META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
 /** How long clients may cache `tools/list` and `server/discover` (per token). */
 const LIST_TTL_MS = 3e5;
+/** Callers whose visible tool lists are kept; the oldest goes first. */
+const VISIBLE_LISTS_MAX = 1e3;
 function rpcError(id, code, message, status = 200, data) {
 	return Response.json({
 		jsonrpc: "2.0",
@@ -221,10 +235,6 @@ function textResult(value, isError = false) {
 		...isError ? { isError: true } : {}
 	};
 }
-function canonical(request) {
-	const url = new URL(request.url);
-	return `${url.origin}${url.pathname.replace(/\/$/, "")}`;
-}
 /**
 * An MCP server (Streamable HTTP, stateless) whose tools run as the caller:
 * the Bearer token from the MCP client is verified and every query goes
@@ -240,10 +250,13 @@ function createMcp(betterSupabase, options) {
 	})["$defs"];
 	const registry = /* @__PURE__ */ new Map();
 	let allTools;
+	/** Bumped on every registration, so cached visible lists built before it miss. */
+	let generation = 0;
 	const register = (entry) => {
 		if (registry.has(entry.info.name)) throw new TypeError(`Duplicate MCP tool "${entry.info.name}"`);
 		registry.set(entry.info.name, entry);
 		allTools = void 0;
+		generation++;
 	};
 	const failure = (error) => textResult(toProblem(error, { expose }), true);
 	const refused = async (tool, args, ctx) => {
@@ -308,25 +321,38 @@ function createMcp(betterSupabase, options) {
 	};
 	for (const tool of options.tools ?? []) addTool(tool);
 	const listTools = () => allTools ??= [...registry.values()].map((entry) => entry.info);
+	/**
+	* A user's visible list per token, for as long as clients may cache it
+	* (`ttlMs`). `tools/call` still checks `visible` on every call.
+	*/
+	const visibleLists = /* @__PURE__ */ new Map();
 	/** Without a `visible` hook every caller sees the same list, built once. */
 	const visibleTools = async (context) => {
 		if (!options.visible) return listTools();
 		const ctx = context();
+		const token = ctx.auth.kind === "user" ? ctx.auth.token : void 0;
+		const now = Date.now();
+		const cached = token === void 0 ? void 0 : visibleLists.get(token);
+		if (cached && cached.until > now && cached.generation === generation) return cached.tools;
 		const entries = [...registry.values()];
 		const shown = await Promise.all(entries.map((entry) => isVisible(entry, ctx)));
-		return entries.filter((_, index) => shown[index]).map((e) => e.info);
-	};
-	const authorizationServers = () => options.authorizationServers ?? [fromSupabaseUrl(server.env.url)];
-	const resourceOf = (request) => {
-		if (typeof options.resource === "function") return options.resource(request);
-		if (options.resource) return options.resource;
-		const url = new URL(canonical(request));
-		return url.pathname.startsWith(WELL_KNOWN) ? `${url.origin}${url.pathname.slice(37)}` : url.href.replace(/\/$/, "");
-	};
-	const metadataUrl = (request) => {
-		const resource = new URL(resourceOf(request));
-		return `${resource.origin}${WELL_KNOWN}${resource.pathname.replace(/\/$/, "")}`;
+		const tools = entries.filter((_, index) => shown[index]).map((e) => e.info);
+		if (token !== void 0) {
+			visibleLists.delete(token);
+			if (visibleLists.size >= VISIBLE_LISTS_MAX) {
+				const oldest = visibleLists.keys().next();
+				if (!oldest.done) visibleLists.delete(oldest.value);
+			}
+			visibleLists.set(token, {
+				tools,
+				until: now + LIST_TTL_MS,
+				generation
+			});
+		}
+		return tools;
 	};
+	const urls = discovery(options, () => server.env.url);
+	const { metadataUrl } = urls;
 	const invoke = async (name, args, ctx, checkVisible = true) => {
 		const entry = registry.get(name);
 		try {
@@ -341,7 +367,7 @@ function createMcp(betterSupabase, options) {
 		const outcome = await invoke(name, args, ctx);
 		return isRefusal(outcome) ? failure(dbError("forbidden", outcome.refusal)) : outcome;
 	};
-	const scopes = (options.advertisedScopes ?? options.scopes ?? []).filter((scope) => scope !== "offline_access");
+	const scopes = (options.advertisedScopes ?? []).filter((scope) => scope !== "offline_access");
 	const serverInfo = {
 		name: options.name,
 		version: options.version,
@@ -390,19 +416,28 @@ function createMcp(betterSupabase, options) {
 			if (sent === null || headerName(sent) !== name) return mismatch(`Mcp-Name must be ${name}`);
 		}
 	};
+	const cors = options.cors ?? true;
 	const endpoint = async (request) => {
+		const response = await answer(request);
+		flushEvents(server, options.waitUntil);
+		return cors ? withCors(response, request, options.allowedOrigins) : response;
+	};
+	const answer = async (request) => {
 		const origin = request.headers.get("origin");
 		if (origin && options.allowedOrigins && !options.allowedOrigins.includes(origin)) return rpcError(null, INVALID_REQUEST, "Origin not allowed", 403);
-		if (options.allowedHosts && !hostAllowed(request, options.allowedHosts)) return rpcError(null, INVALID_REQUEST, "Host not allowed", 403);
+		if (options.allowedHosts && !hostAllowed(urls.host(request), options.allowedHosts)) return rpcError(null, INVALID_REQUEST, "Host not allowed", 403);
+		if (request.method === "OPTIONS" && cors) return endpointPreflight(request, options.allowedOrigins);
 		if (request.method !== "POST") return new Response(null, {
 			status: 405,
-			headers: { allow: "POST" }
+			headers: { allow: cors ? "POST, OPTIONS" : "POST" }
 		});
 		const header = request.headers.get("mcp-protocol-version");
 		if (header && !SUPPORTED_VERSIONS.includes(header)) return unsupportedVersion(null, header);
 		const ctx = await server.context(request, { cookies: false });
 		const denied = guard(ctx.auth, options.allow, options.aal, options.requiredScopes);
 		if (denied) return refuse(request, denied);
+		const roleDenied = missingRole(ctx.auth, options.requiredRoles);
+		if (roleDenied) return refuse(request, roleDenied);
 		let message;
 		try {
 			message = await request.json();
@@ -470,13 +505,21 @@ function createMcp(betterSupabase, options) {
 			default: return notFound();
 		}
 	};
-	const metadata = (request) => Response.json({
-		resource: resourceOf(request),
-		authorization_servers: [...authorizationServers()],
-		bearer_methods_supported: ["header"],
-		...scopes.length > 0 ? { scopes_supported: scopes } : {},
-		...options.resourceDocumentation === void 0 ? {} : { resource_documentation: options.resourceDocumentation }
-	}, { headers: { "access-control-allow-origin": "*" } });
+	const metadata = (request) => {
+		const resource = urls.resource(request);
+		const authorizationServers = [...urls.authorizationServers(request)];
+		if (scopes.length === 0 && options.resourceDocumentation === void 0) return resourceMetadataResponse(request, {
+			resource,
+			authorizationServers
+		});
+		return Response.json({
+			resource,
+			authorization_servers: authorizationServers,
+			bearer_methods_supported: ["header"],
+			...scopes.length > 0 ? { scopes_supported: scopes } : {},
+			...options.resourceDocumentation === void 0 ? {} : { resource_documentation: options.resourceDocumentation }
+		}, { headers: { "access-control-allow-origin": "*" } });
+	};
 	const mcp = extendServer(server, {
 		get tools() {
 			return [...listTools()];
@@ -489,14 +532,7 @@ function createMcp(betterSupabase, options) {
 		endpoint,
 		metadata,
 		fetch(request) {
-			const { pathname } = new URL(request.url);
-			if (pathname.startsWith(WELL_KNOWN)) return Promise.resolve(request.method === "OPTIONS" ? new Response(null, {
-				status: 204,
-				headers: {
-					"access-control-allow-origin": "*",
-					"access-control-allow-methods": "GET"
-				}
-			}) : metadata(request));
+			if (isMetadataRequest(request)) return Promise.resolve(request.method === "OPTIONS" ? metadataPreflight() : metadata(request));
 			return endpoint(request);
 		}
 	});

package/dist/mcp/sdk/index.d.ts

@@ -0,0 +1,105 @@
+import { a as AnyModels, i as AnyFunctions } from "../../types-6BdhkmZe.js";
+import { r as AuthState } from "../../resolve-KW8nCeL6.js";
+import { t as BetterSupabase } from "../../define-CJJkkr1-.js";
+import { i as ServerContext$1, o as ServerOptions, t as BetterServer } from "../../server-CeVeeXwz.js";
+import { r as GuardOptions, t as AllowedCaller } from "../../respond-DoBijysA.js";
+import { AuthInfo, CallToolResult, Icon, InputRequiredResult, OAuthTokenVerifier, RegisteredTool, ScopeChallengeHandler, ServerContext, StandardSchemaWithJSON, ToolAnnotations } from "@modelcontextprotocol/server";
+//#region src/mcp/sdk/sdk.d.ts
+interface McpAuthOptions extends ServerOptions, Omit<GuardOptions, "scopes"> {
+  /**
+   * The MCP endpoint's public URL, the RFC 9728 `resource`. Defaults to the
+   * request URL without a trailing slash, and on Supabase Edge Functions to
+   * the public `<origin>/functions/v1/<slug>`; pass it when a proxy rewrites
+   * the host or path.
+   */
+  readonly resource?: string | ((request: Request) => string);
+  /** Defaults to the project's Supabase Auth issuer. */
+  readonly authorizationServers?: readonly string[];
+  /**
+   * Answers CORS preflights in `serve` and adds `Access-Control-*` headers
+   * (any origin), so browser MCP clients can call the server. Defaults to true.
+   */
+  readonly cors?: boolean;
+  /** Scopes published as `scopes_supported`; `offline_access` is never listed. */
+  readonly advertisedScopes?: readonly string[];
+  /**
+   * Scopes a delegated token (an OAuth client) needs; one without them gets a
+   * 403 `insufficient_scope` challenge. The user's own session is not limited.
+   */
+  readonly requiredScopes?: readonly string[];
+  /** Published as `resource_documentation`. */
+  readonly resourceDocumentation?: string;
+  /**
+   * Keeps the invocation alive for event sink sends a tool started, e.g.
+   * `EdgeRuntime.waitUntil` or Next's `after`.
+   */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
+}
+/** A fetch handler that takes verified auth, like the SDK's `createMcpHandler(...)`. */
+interface McpFetchHandler {
+  fetch(request: Request, options?: {
+    readonly authInfo?: AuthInfo;
+  }): Promise<Response>;
+}
+interface BetterMcpAuth<M extends AnyModels = AnyModels, F extends AnyFunctions = AnyFunctions, E = unknown, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
+  /** An `OAuthTokenVerifier` for the SDK's bearer helpers; it verifies the token locally. */
+  readonly verifier: OAuthTokenVerifier;
+  /** The RFC 9728 Protected Resource Metadata document. */
+  metadata(request: Request): Response;
+  /** Where the metadata is served, for `WWW-Authenticate` challenges. */
+  metadataUrl(request: Request): string;
+  /**
+   * A fetch handler that serves the metadata, refuses callers without a
+   * valid bearer token (401 or 403 with an RFC 9728 challenge), then calls
+   * `handler.fetch(request, { authInfo })`.
+   */
+  serve(handler: McpFetchHandler): (request: Request) => Promise<Response>;
+  /** The caller's context for a tool call, from `ctx.http.authInfo`. */
+  contextOf(ctx: ServerContext): Promise<ServerContext$1<M, F, E, C, P>>;
+}
+/** What `withBetterSupabaseMcp` adds to the SDK's tool context. */
+interface BetterToolExtra<M extends AnyModels = AnyModels, F extends AnyFunctions = AnyFunctions, E = unknown, C = unknown, P = unknown> {
+  /** Repositories bound to the verified caller, with RLS. */
+  readonly db: ServerContext$1<M, F, E, C, P>["db"];
+  readonly auth: AuthState<C, P>;
+  /** The full server context: `db`, `auth`, `supabase` and the rest. */
+  readonly bs: ServerContext$1<M, F, E, C, P>;
+}
+type BetterToolContext<M extends AnyModels = AnyModels, F extends AnyFunctions = AnyFunctions, E = unknown, C = unknown, P = unknown> = ServerContext & BetterToolExtra<M, F, E, C, P>;
+interface BetterToolConfig<InputArgs extends StandardSchemaWithJSON | undefined, OutputArgs extends StandardSchemaWithJSON | undefined> {
+  readonly title?: string;
+  readonly description?: string;
+  readonly inputSchema?: InputArgs;
+  readonly outputSchema?: OutputArgs;
+  readonly annotations?: ToolAnnotations;
+  readonly icons?: Icon[];
+  readonly scopeChallenge?: ScopeChallengeHandler;
+  readonly _meta?: Record<string, unknown>;
+  /** Extra keys for wrappers registered in between, such as an authorization library's `permission`. */
+  readonly [key: string]: unknown;
+}
+type ToolReturn = CallToolResult | InputRequiredResult | Promise<CallToolResult | InputRequiredResult>;
+type BetterToolCallback<InputArgs extends StandardSchemaWithJSON | undefined, Ctx> = InputArgs extends StandardSchemaWithJSON ? (args: StandardSchemaWithJSON.InferOutput<InputArgs>, ctx: Ctx) => ToolReturn : (ctx: Ctx) => ToolReturn;
+/** An SDK server whose tool callbacks also get `db`, `auth` and `bs`. */
+type BetterMcpServer<S, M extends AnyModels = AnyModels, F extends AnyFunctions = AnyFunctions, E = unknown, C = unknown, P = unknown> = Omit<S, "registerTool"> & {
+  registerTool<OutputArgs extends StandardSchemaWithJSON | undefined = undefined, InputArgs extends StandardSchemaWithJSON | undefined = undefined>(name: string, config: BetterToolConfig<InputArgs, OutputArgs>, cb: BetterToolCallback<InputArgs, BetterToolContext<M, F, E, C, P>>): RegisteredTool;
+};
+/** The structural part of `McpServer` (or a wrapper of it) that `withBetterSupabaseMcp` needs. */
+interface ToolRegistrar {
+  registerTool(name: string, config: never, cb: (...params: never[]) => unknown): unknown;
+}
+/**
+ * Bearer auth for an MCP server built on the official SDK
+ * (`@modelcontextprotocol/server` 2.3 or later). Verifies Supabase access
+ * tokens locally, serves the RFC 9728 metadata, and binds repositories to
+ * the caller. Pair it with `withBetterSupabaseMcp` and `createMcpHandler`.
+ */
+export declare function createMcpAuth<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: McpAuthOptions): BetterMcpAuth<M, F, E, C, P>;
+/**
+ * Wraps `server.registerTool` so every tool callback gets `db`, `auth` and
+ * `bs` for the caller on its context. Wrap after an authorization wrapper
+ * so permissions are checked before the context is built.
+ */
+export declare function withBetterSupabaseMcp<S extends ToolRegistrar, M extends AnyModels, F extends AnyFunctions, E, C, P>(server: S, auth: Pick<BetterMcpAuth<M, F, E, C, P>, "contextOf">): BetterMcpServer<S, M, F, E, C, P>;
+//#endregion
+export type { AllowedCaller, BetterMcpAuth, BetterMcpServer, BetterToolCallback, BetterToolConfig, BetterToolContext, BetterToolExtra, GuardOptions, McpAuthOptions, McpFetchHandler, ToolRegistrar };

package/dist/mcp/sdk/index.js

@@ -0,0 +1,126 @@
+import { o as delegationOf } from "../../impersonation-DcqaTBHx.js";
+import { c as extendServer, i as resolveToken, l as withExtra, n as flushEvents, s as createServer } from "../../adapter-Bc1o3zyy.js";
+import { r as guard } from "../../respond-BUgsXNgk.js";
+import { a as withCors, i as metadataPreflight, n as endpointPreflight, r as isMetadataRequest, t as discovery } from "../../http-DdYadv-o.js";
+import { OAuthError, bearerAuthChallengeResponse, verifyBearerToken } from "@modelcontextprotocol/server";
+//#region src/mcp/sdk/sdk.ts
+const STATE_KEY = "betterSupabase";
+function claimString(claims, key) {
+	const value = claims[key];
+	return typeof value === "string" ? value : void 0;
+}
+function isUserState(value, verified) {
+	return typeof value === "object" && value !== null && verified.has(value) && "kind" in value && value.kind === "user";
+}
+/**
+* Bearer auth for an MCP server built on the official SDK
+* (`@modelcontextprotocol/server` 2.3 or later). Verifies Supabase access
+* tokens locally, serves the RFC 9728 metadata, and binds repositories to
+* the caller. Pair it with `withBetterSupabaseMcp` and `createMcpHandler`.
+*/
+function createMcpAuth(betterSupabase, options = {}) {
+	const server = createServer(betterSupabase, options);
+	/** Auth states this instance verified and guarded; any other `AuthInfo.extra` is ignored. */
+	const verified = /* @__PURE__ */ new WeakSet();
+	const allow = options.allow ?? ["user"];
+	const scopes = options.requiredScopes ?? [];
+	const advertised = (options.advertisedScopes ?? []).filter((scope) => scope !== "offline_access");
+	const urls = discovery(options, () => server.env.url);
+	const { metadataUrl } = urls;
+	const cors = options.cors ?? true;
+	const metadata = (request) => Response.json({
+		resource: urls.resource(request),
+		authorization_servers: [...urls.authorizationServers(request)],
+		bearer_methods_supported: ["header"],
+		...advertised.length > 0 ? { scopes_supported: advertised } : {},
+		...options.resourceDocumentation === void 0 ? {} : { resource_documentation: options.resourceDocumentation }
+	}, { headers: { "access-control-allow-origin": "*" } });
+	const verifier = { async verifyAccessToken(token) {
+		const auth = await resolveToken(server, token);
+		if (auth.kind !== "user") throw new OAuthError("invalid_token", "The access token is not valid");
+		const denied = guard(auth, allow, options.aal, scopes);
+		if (denied) throw new OAuthError(denied.kind === "unauthorized" ? "invalid_token" : "insufficient_scope", denied.message);
+		verified.add(auth);
+		const exp = auth.claims.exp;
+		return {
+			token,
+			clientId: claimString(auth.claims, "client_id") ?? claimString(auth.claims, "azp") ?? "",
+			scopes: [...delegationOf(auth.claims)?.scopes ?? []],
+			...auth.expiresAt === null ? typeof exp === "number" ? { expiresAt: exp } : {} : { expiresAt: auth.expiresAt },
+			extra: { [STATE_KEY]: auth }
+		};
+	} };
+	const anon = {
+		kind: "anon",
+		reason: "none"
+	};
+	const contextOf = async (ctx) => {
+		const info = ctx.http?.authInfo;
+		const state = info?.extra?.[STATE_KEY];
+		if (isUserState(state, verified)) return server.contextFor(state);
+		if (info?.token) {
+			const auth = await resolveToken(server, info.token);
+			const allowed = auth.kind === "user" && guard(auth, allow, options.aal, scopes) === void 0;
+			return server.contextFor(allowed ? auth : anon);
+		}
+		return server.contextFor(anon);
+	};
+	const serve = (handler) => async (request) => {
+		if (isMetadataRequest(request)) return request.method === "OPTIONS" ? metadataPreflight() : metadata(request);
+		if (cors && request.method === "OPTIONS") return endpointPreflight(request);
+		const response = await answer(handler, request);
+		flushEvents(server, options.waitUntil);
+		return cors ? withCors(response, request) : response;
+	};
+	const answer = async (handler, request) => {
+		const header = request.headers.get("authorization");
+		if (!header && allow.includes("anon")) return handler.fetch(request);
+		const resourceMetadataUrl = metadataUrl(request);
+		try {
+			const authInfo = await verifyBearerToken(header, {
+				verifier,
+				resourceMetadataUrl
+			});
+			return await handler.fetch(request, { authInfo });
+		} catch (error) {
+			if (!(error instanceof OAuthError)) throw error;
+			return bearerAuthChallengeResponse(error, {
+				resourceMetadataUrl,
+				...scopes.length > 0 || advertised.length > 0 ? { requiredScopes: [.../* @__PURE__ */ new Set([...advertised, ...scopes])] } : {}
+			});
+		}
+	};
+	return extendServer(server, {
+		verifier,
+		metadata,
+		metadataUrl,
+		serve,
+		contextOf
+	});
+}
+/**
+* Wraps `server.registerTool` so every tool callback gets `db`, `auth` and
+* `bs` for the caller on its context. Wrap after an authorization wrapper
+* so permissions are checked before the context is built.
+*/
+function withBetterSupabaseMcp(server, auth) {
+	const register = server.registerTool.bind(server);
+	const registerTool = (name, config, cb) => register(name, config, async (...params) => {
+		const ctx = params.at(-1);
+		const bs = await auth.contextOf(ctx);
+		const extended = withExtra(ctx, {
+			db: bs.db,
+			auth: bs.auth,
+			bs
+		});
+		return cb(...params.slice(0, -1), extended);
+	});
+	Object.defineProperty(server, "registerTool", {
+		value: registerTool,
+		configurable: true,
+		writable: true
+	});
+	return server;
+}
+//#endregion
+export { createMcpAuth, withBetterSupabaseMcp };