better-supabase 0.0.0 → 0.2.0

package/dist/mcp/index.js

@@ -0,0 +1,463 @@
+import { n as dbError } from "../errors-Bl3rkOzo.js";
+import { t as validate } from "../standard-FUi3Z3-7.js";
+import { o as toProblem } from "../problem-BTkTtRV9.js";
+import { t as SPEC_PINS } from "../spec-pins-C3oc-Tdp.js";
+import { t as buildJsonSchema } from "../json-schema-BpYqkCKf.js";
+import { a as settle, c as withExtra, n as guard, o as createServer, s as extendServer, t as defaultExpose } from "../respond-DMcbQwfN.js";
+import { t as defineResource } from "../resource-BHEWmQJK.js";
+import { fromSupabaseUrl, unauthorizedResponse } from "@supabase/server/oauth-protected-resource";
+//#region src/mcp/index.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",
+	"2025-06-18",
+	"2025-03-26"
+];
+const SUPPORTED_VERSIONS = [MCP_PROTOCOL_VERSION, ...LEGACY_VERSIONS];
+/** 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 "."`);
+	const standard = definition.input?.["~standard"];
+	const inputSchema = definition.inputSchema ?? standard?.jsonSchema?.input({ target: "draft-2020-12" }) ?? (definition.input ? void 0 : {
+		type: "object",
+		properties: {}
+	});
+	if (!inputSchema) throw new TypeError(`Tool "${definition.name}": the input schema has no JSON Schema; pass inputSchema`);
+	const { $schema: _, ...schema } = inputSchema;
+	return {
+		info: {
+			name: definition.name,
+			...definition.title ? { title: definition.title } : {},
+			description: definition.description,
+			inputSchema: schema,
+			...definition.outputSchema ? { outputSchema: definition.outputSchema } : {},
+			...definition.annotations ? { annotations: definition.annotations } : {}
+		},
+		...definition.input ? { input: definition.input } : {},
+		...definition.meta === void 0 ? {} : { meta: definition.meta },
+		run: (args, ctx) => definition.run(args, ctx)
+	};
+}
+const ANNOTATIONS = {
+	list: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	get: {
+		readOnlyHint: true,
+		openWorldHint: false
+	},
+	create: {
+		readOnlyHint: false,
+		destructiveHint: false,
+		openWorldHint: false
+	},
+	update: {
+		readOnlyHint: false,
+		destructiveHint: true,
+		idempotentHint: true,
+		openWorldHint: false
+	},
+	delete: {
+		readOnlyHint: false,
+		destructiveHint: true,
+		idempotentHint: true,
+		openWorldHint: false
+	}
+};
+function pageSchema(max) {
+	return {
+		type: "object",
+		properties: {
+			page: {
+				type: "integer",
+				minimum: 1,
+				default: 1
+			},
+			size: {
+				type: "integer",
+				minimum: 1,
+				maximum: max,
+				default: 50
+			}
+		},
+		additionalProperties: false
+	};
+}
+function tableTools(resource, defs) {
+	const { table, keyParam } = resource;
+	const row = defs[`${table}Row`] ?? { type: "object" };
+	const key = keyParam ? row["properties"]?.[keyParam] ?? { type: "string" } : void 0;
+	const keyInput = (more = {}) => ({
+		type: "object",
+		properties: {
+			[keyParam]: key,
+			...more
+		},
+		required: [keyParam, ...Object.keys(more)],
+		additionalProperties: false
+	});
+	const page = {
+		type: "object",
+		properties: {
+			items: {
+				type: "array",
+				items: row
+			},
+			page: { type: "object" }
+		},
+		required: ["items", "page"]
+	};
+	const tools = [];
+	const add = (operation, description, inputSchema, outputSchema) => {
+		tools.push({
+			operation,
+			info: {
+				name: `${table}_${operation}`,
+				title: `${operation[0].toUpperCase()}${operation.slice(1)} ${table}`,
+				description,
+				inputSchema,
+				...outputSchema ? { outputSchema } : {},
+				annotations: ANNOTATIONS[operation]
+			}
+		});
+	};
+	for (const operation of resource.operations) switch (operation) {
+		case "list": {
+			const { $schema: _, ...listSchema } = resource.list?.jsonSchema ?? pageSchema(resource.maxPageSize);
+			add("list", `List ${table} rows visible to the caller, one page at a time.`, listSchema, page);
+			break;
+		}
+		case "get":
+			if (keyParam) add("get", `Get one ${table} row by ${keyParam}.`, keyInput(), row);
+			break;
+		case "create":
+			add("create", `Create a ${table} row. Returns the created row.`, defs[`${table}Insert`] ?? { type: "object" }, row);
+			break;
+		case "update":
+			if (keyParam) add("update", `Update the columns in "patch" on one ${table} row.`, keyInput({ patch: defs[`${table}Update`] ?? { type: "object" } }), row);
+			break;
+		case "delete":
+			if (keyParam) add("delete", `Delete one ${table} row by ${keyParam}.`, keyInput());
+			break;
+		default: throw new TypeError(`Unknown operation ${String(operation)}`);
+	}
+	return tools;
+}
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+const HEADER_MISMATCH = -32020;
+const UNSUPPORTED_PROTOCOL_VERSION = -32022;
+const META_VERSION = "io.modelcontextprotocol/protocolVersion";
+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;
+function rpcError(id, code, message, status = 200, data) {
+	return Response.json({
+		jsonrpc: "2.0",
+		id: id ?? null,
+		error: {
+			code,
+			message,
+			...data ? { data } : {}
+		}
+	}, { status });
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** An `Mcp-Name` value, decoding the `=?base64?...?=` sentinel. */
+function headerName(value) {
+	const encoded = /^=\?base64\?(.*)\?=$/.exec(value)?.[1];
+	if (encoded === void 0) return value;
+	try {
+		return new TextDecoder().decode(Uint8Array.from(atob(encoded), (char) => char.charCodeAt(0)));
+	} catch {
+		return value;
+	}
+}
+const quoted = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+function isRpcRequest(value) {
+	return isObject(value) && value["jsonrpc"] === "2.0" && typeof value["method"] === "string" && (value["params"] === void 0 || isObject(value["params"]));
+}
+function textResult(value, isError = false) {
+	const structured = typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+	return {
+		content: [{
+			type: "text",
+			text: typeof value === "string" ? value : JSON.stringify(value ?? null)
+		}],
+		...structured ? { structuredContent: structured } : {},
+		...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
+* through RLS. Answers 401 with RFC 9728 metadata so clients can sign in with
+* Supabase Auth's OAuth server.
+*/
+function createMcp(sb, options) {
+	const server = createServer(sb, options);
+	const expose = options.exposeErrors ?? defaultExpose();
+	const defs = buildJsonSchema({
+		meta: sb.meta,
+		config: { json: options.json ?? {} }
+	})["$defs"];
+	const registry = /* @__PURE__ */ new Map();
+	const register = (entry) => {
+		if (registry.has(entry.info.name)) throw new TypeError(`Duplicate MCP tool "${entry.info.name}"`);
+		registry.set(entry.info.name, entry);
+	};
+	const failure = (error) => textResult(toProblem(error, { expose }), true);
+	const refused = async (tool, args, ctx) => {
+		if (!options.authorize) return void 0;
+		const decision = await options.authorize(ctx, tool, args);
+		if (decision.allowed) return void 0;
+		return {
+			refusal: decision.reason ?? `Not allowed to call ${tool.info.name}`,
+			scopes: decision.scopes ?? []
+		};
+	};
+	const isVisible = async (tool, ctx) => !options.visible || options.visible(ctx, tool);
+	for (const [table, raw] of Object.entries(options.resources ?? {})) {
+		if (!raw) continue;
+		const resource = defineResource(sb, table, raw === true ? {} : raw);
+		for (const { info, operation } of tableTools(resource, defs)) {
+			const ref = {
+				info,
+				meta: void 0
+			};
+			register({
+				...ref,
+				async call(args, ctx) {
+					const input = args ?? {};
+					const refusal = await refused(ref, input, ctx);
+					if (refusal) return refusal;
+					const id = resource.keyParam ? input[resource.keyParam] : void 0;
+					const result = await resource.execute(ctx.db, operation, {
+						id,
+						query: input,
+						data: operation === "update" ? input["patch"] : input
+					});
+					if (!result.ok) return failure(result.error);
+					return textResult(operation === "delete" ? { deleted: true } : result.data);
+				}
+			});
+		}
+	}
+	const addTool = (tool) => {
+		const ref = {
+			info: tool.info,
+			meta: tool.meta
+		};
+		register({
+			...ref,
+			async call(args, ctx) {
+				let value = args ?? {};
+				if (tool.input) {
+					const parsed = await validate(tool.input, value, "arguments");
+					if (!parsed.ok) return failure(parsed.error);
+					value = parsed.data;
+				}
+				const refusal = await refused(ref, value, ctx);
+				if (refusal) return refusal;
+				const outcome = await settle(() => tool.run(value, ctx));
+				return outcome.ok ? textResult(outcome.data) : failure(outcome.error);
+			}
+		});
+	};
+	for (const tool of options.tools ?? []) addTool(tool);
+	const listTools = () => [...registry.values()].map((entry) => entry.info);
+	const visibleTools = async (ctx) => {
+		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 invoke = async (name, args, ctx, checkVisible = true) => {
+		const entry = registry.get(name);
+		try {
+			if (!entry || checkVisible && !await isVisible(entry, ctx)) return failure(dbError("not_found", `Unknown tool "${name}"`));
+			return await entry.call(args, ctx);
+		} catch (cause) {
+			return failure(dbError("unexpected", expose && cause instanceof Error ? cause.message : "The tool failed"));
+		}
+	};
+	const isRefusal = (value) => "refusal" in value;
+	const call = async (name, args, ctx) => {
+		const outcome = await invoke(name, args, ctx);
+		return isRefusal(outcome) ? failure(dbError("forbidden", outcome.refusal)) : outcome;
+	};
+	const scopes = (options.scopes ?? []).filter((scope) => scope !== "offline_access");
+	const serverInfo = {
+		name: options.name,
+		version: options.version,
+		...options.title ? { title: options.title } : {}
+	};
+	const capabilities = { tools: { listChanged: false } };
+	const unauthorized = (request) => {
+		const response = unauthorizedResponse(request, { resourceMetadataUrl: metadataUrl(request) });
+		if (scopes.length > 0) response.headers.set("www-authenticate", `${response.headers.get("www-authenticate") ?? "Bearer"}, scope=${quoted(scopes.join(" "))}`);
+		return response;
+	};
+	const forbidden = (request, message, needed = [], id = null) => {
+		const all = [.../* @__PURE__ */ new Set([...scopes, ...needed])];
+		const challenge = [
+			"Bearer error=\"insufficient_scope\"",
+			`error_description=${quoted(message)}`,
+			...all.length > 0 ? [`scope=${quoted(all.join(" "))}`] : [],
+			`resource_metadata=${quoted(metadataUrl(request))}`
+		].join(", ");
+		const response = rpcError(id, INVALID_REQUEST, message, 403);
+		response.headers.set("www-authenticate", challenge);
+		return response;
+	};
+	const unsupportedVersion = (id, requested) => rpcError(id, UNSUPPORTED_PROTOCOL_VERSION, "Unsupported protocol version", 400, {
+		supported: [...SUPPORTED_VERSIONS],
+		requested
+	});
+	/** 2026-07-28 requests carry their version and capabilities, mirrored in headers. */
+	const checkModern = (message, header, headers) => {
+		const meta = message.params?.["_meta"];
+		const version = isObject(meta) ? meta[META_VERSION] : void 0;
+		if (!isObject(meta) || typeof version !== "string" || !isObject(meta[META_CAPABILITIES])) return rpcError(message.id, INVALID_PARAMS, `Requests need _meta["${META_VERSION}"] and _meta["${META_CAPABILITIES}"]`, 400);
+		if (version !== MCP_PROTOCOL_VERSION) return unsupportedVersion(message.id, version);
+		const mismatch = (detail) => rpcError(message.id, HEADER_MISMATCH, `Header mismatch: ${detail}`, 400);
+		if (header !== version) return mismatch(`MCP-Protocol-Version must be ${version}`);
+		if (headers.get("mcp-method") !== message.method) return mismatch(`Mcp-Method must be ${message.method}`);
+		const name = message.params?.["name"];
+		if (message.method === "tools/call" && typeof name === "string") {
+			const sent = headers.get("mcp-name");
+			if (sent === null || headerName(sent) !== name) return mismatch(`Mcp-Name must be ${name}`);
+		}
+	};
+	const handler = 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 (request.method !== "POST") return new Response(null, {
+			status: 405,
+			headers: { allow: "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);
+		const denied = guard(ctx.auth, options.allow, options.aal);
+		if (denied) return denied.kind === "unauthorized" ? unauthorized(request) : forbidden(request, denied.message);
+		let message;
+		try {
+			message = await request.json();
+		} catch {
+			return rpcError(null, PARSE_ERROR, "Parse error", 400);
+		}
+		if (!isRpcRequest(message)) return rpcError(null, INVALID_REQUEST, "Expected one JSON-RPC 2.0 message", 400);
+		const meta = message.params?.["_meta"];
+		const modern = isObject(meta) && meta[META_VERSION] !== void 0 || header === MCP_PROTOCOL_VERSION;
+		if (modern) {
+			const invalid = checkModern(message, header, request.headers);
+			if (invalid) return invalid;
+		}
+		if (message.id === void 0) return new Response(null, { status: 202 });
+		const toolContext = () => withExtra(ctx, {
+			request,
+			signal: request.signal
+		});
+		const reply = (result) => Response.json({
+			jsonrpc: "2.0",
+			id: message.id,
+			result: modern ? {
+				...result,
+				resultType: "complete",
+				_meta: { [META_SERVER_INFO]: serverInfo }
+			} : result
+		});
+		const notFound = () => rpcError(message.id, METHOD_NOT_FOUND, `Method not found: ${message.method}`, modern ? 404 : 200);
+		switch (message.method) {
+			case "server/discover": return reply({
+				supportedVersions: [...SUPPORTED_VERSIONS],
+				capabilities,
+				...options.instructions ? { instructions: options.instructions } : {},
+				ttlMs: LIST_TTL_MS,
+				cacheScope: "private"
+			});
+			case "initialize": {
+				if (modern) return notFound();
+				const requested = message.params?.["protocolVersion"];
+				return reply({
+					protocolVersion: typeof requested === "string" && LEGACY_VERSIONS.includes(requested) ? requested : LEGACY_VERSIONS[0],
+					capabilities,
+					serverInfo,
+					...options.instructions ? { instructions: options.instructions } : {}
+				});
+			}
+			case "ping": return modern ? notFound() : reply({});
+			case "tools/list": return reply({
+				tools: await visibleTools(toolContext()),
+				...modern ? {
+					ttlMs: LIST_TTL_MS,
+					cacheScope: "private"
+				} : {}
+			});
+			case "tools/call": {
+				const name = message.params?.["name"];
+				const entry = typeof name === "string" ? registry.get(name) : void 0;
+				const context = toolContext();
+				if (!entry || !await isVisible(entry, context)) return rpcError(message.id, INVALID_PARAMS, `Unknown tool ${JSON.stringify(name)}`);
+				const outcome = await invoke(entry.info.name, message.params?.["arguments"], context, false);
+				if (!isRefusal(outcome)) return reply(outcome);
+				if (outcome.scopes.length > 0) return forbidden(request, outcome.refusal, outcome.scopes, message.id);
+				return reply(failure(dbError("forbidden", outcome.refusal)));
+			}
+			default: return notFound();
+		}
+	};
+	const metadata = (request) => Response.json({
+		resource: resourceOf(request),
+		authorization_servers: [...authorizationServers()],
+		bearer_methods_supported: ["header"],
+		...scopes.length > 0 ? { scopes_supported: scopes } : {}
+	}, { headers: { "access-control-allow-origin": "*" } });
+	const mcp = extendServer(server, {
+		get tools() {
+			return listTools();
+		},
+		tool(definition) {
+			addTool(defineTool(definition));
+			return mcp;
+		},
+		call,
+		handler,
+		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));
+			return handler(request);
+		}
+	});
+	return mcp;
+}
+//#endregion
+export { MCP_PROTOCOL_VERSION, createMcp, defineTool };