@lovable.dev/mcp-js 0.21.0 → 0.21.1-rc.1

package/dist/cors-B7CTXIHD.js

@@ -0,0 +1,829 @@
+import { c as DEFAULT_METRICS_ENDPOINT, i as log, l as resolveMetricsConfig, n as applyLogLevelFromEnv, o as parseSafeUrl, r as describeError, s as trimTrailingSlash, t as LOG_LEVEL_ENV_VAR } from "./logger-2OXtfiIW.js";
+import { t as version } from "./package-7EUptuSJ.js";
+import "./metadata-path-CAkNcfyY.js";
+import { createLocalJWKSet, decodeProtectedHeader, jwtVerify } from "jose";
+//#region src/core/http.ts
+const JSON_HEADERS = { "Content-Type": "application/json" };
+/** Strip the body from a built response, preserving status and headers, for HEAD. */
+function headResponse(response) {
+	return new Response(null, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+function methodNotAllowed(allow) {
+	return new Response(JSON.stringify({ error: "method not allowed" }), {
+		status: 405,
+		headers: {
+			...JSON_HEADERS,
+			Allow: allow
+		}
+	});
+}
+//#endregion
+//#region src/metrics/otlp.ts
+const SCOPE_NAME = "@lovable.dev/mcp-js";
+const EVENT_NAME = "mcp.tool.invocation";
+const SEVERITY_INFO = 9;
+function strAttr(key, value) {
+	return {
+		key,
+		value: { stringValue: value }
+	};
+}
+function intAttr(key, value) {
+	return {
+		key,
+		value: { intValue: String(Math.round(value)) }
+	};
+}
+function toLogRecord(rec) {
+	const attributes = [
+		strAttr("event.name", EVENT_NAME),
+		strAttr("mcp.method", rec.method),
+		strAttr("mcp.outcome", rec.outcome),
+		intAttr("mcp.duration_ms", rec.durationMs)
+	];
+	if (rec.tool !== null) attributes.push(strAttr("mcp.tool", rec.tool));
+	if (rec.reqBytes !== void 0) attributes.push(intAttr("mcp.request_size_bytes", rec.reqBytes));
+	if (rec.resBytes !== void 0) attributes.push(intAttr("mcp.response_size_bytes", rec.resBytes));
+	attributes.push(strAttr("mcp.stack", rec.stack));
+	return {
+		timeUnixNano: rec.timeUnixNano,
+		observedTimeUnixNano: rec.timeUnixNano,
+		severityNumber: SEVERITY_INFO,
+		severityText: "INFO",
+		body: { stringValue: EVENT_NAME },
+		attributes
+	};
+}
+/**
+* Build an OTLP/HTTP JSON `ExportLogsServiceRequest` body for a batch of
+* invocations. All records in a batch share one resource (the MCP server's
+* identity); per-tenant attribution is derived server-side from the auth header,
+* never from client-supplied resource attributes.
+*/
+function buildLogsPayload(records, server) {
+	return JSON.stringify({ resourceLogs: [{
+		resource: { attributes: [
+			strAttr("service.name", server.name),
+			strAttr("service.version", server.version),
+			strAttr("telemetry.sdk.name", SCOPE_NAME),
+			strAttr("telemetry.sdk.version", version),
+			strAttr("telemetry.sdk.language", "webjs")
+		] },
+		scopeLogs: [{
+			scope: {
+				name: SCOPE_NAME,
+				version
+			},
+			logRecords: records.map(toLogRecord)
+		}]
+	}] });
+}
+/** Wall-clock nanoseconds since the Unix epoch as a string, without losing
+*  precision to float64 (`Date.now()` ms × 1e6 would overflow 2^53). */
+function nowUnixNano() {
+	return `${Date.now()}000000`;
+}
+//#endregion
+//#region src/metrics/impl/base.ts
+/** Monotonic-ish millisecond clock for latency timing, with a `Date.now` fallback
+*  for runtimes without `performance.now`. */
+function nowMs() {
+	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+const NOOP_RECORDER = { async emit() {} };
+function createNoopRecorder() {
+	return NOOP_RECORDER;
+}
+/** Guarded `process.env` read — the shared fallback both stacks use for local
+*  dev. Tolerates a missing `process` global. */
+function readProcessEnv(name) {
+	try {
+		return typeof process !== "undefined" ? process.env?.[name] || void 0 : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Base per-request recorder. Owns everything stack-agnostic: log-level setup, the
+* `tool.invoked` log, the single-record OTLP POST (awaited so it lands within the
+* request — serverless workers kill detached work once the response returns), and
+* never throwing into tool dispatch. Every invocation is reported (no sampling).
+* Subclasses supply only the `stack` label and how to read env on that runtime.
+*
+* One instance is created per request by the stack handler and shared across
+* every invocation in that request; it is never a process-wide singleton, since
+* on Cloudflare the env binding isn't readable at module-init scope.
+*/
+var BaseMetricRecorder = class {
+	config;
+	server;
+	deps;
+	doFetch;
+	usesLovableEndpoint;
+	baseHeaders;
+	apiKey;
+	lazyLogLevelApplied = false;
+	constructor(config, server, deps = {}) {
+		this.config = config;
+		this.server = server;
+		this.deps = deps;
+		this.doFetch = deps.fetch ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0);
+		this.usesLovableEndpoint = config.endpoint === DEFAULT_METRICS_ENDPOINT;
+		const headers = {};
+		if (!this.usesLovableEndpoint) {
+			for (const [key, value] of Object.entries(config.headers)) if (key.toLowerCase() !== "content-type") headers[key] = value;
+		}
+		headers["content-type"] = "application/json";
+		this.baseHeaders = headers;
+	}
+	async emit(ev) {
+		await this.applyLazyLogLevel();
+		log.info("tool.invoked", {
+			tool: ev.tool,
+			method: ev.method,
+			outcome: ev.outcome,
+			durationMs: ev.durationMs,
+			stack: this.stack,
+			...ev.errorText !== void 0 && { errorText: ev.errorText }
+		});
+		if (!this.config.enabled) return;
+		if (!this.doFetch) {
+			log.warn("metrics.disabled_no_fetch", { endpoint: this.config.endpoint });
+			return;
+		}
+		const headers = { ...this.baseHeaders };
+		if (this.usesLovableEndpoint) {
+			const key = await this.resolveApiKey();
+			if (!key) {
+				log.warn("metrics.disabled_no_api_key", {
+					envVar: this.config.apiKeyEnvVar,
+					endpoint: this.config.endpoint
+				});
+				return;
+			}
+			headers.authorization = `Bearer ${key}`;
+		}
+		const body = buildLogsPayload([{
+			...ev,
+			timeUnixNano: nowUnixNano(),
+			stack: this.stack
+		}], this.server);
+		try {
+			const res = await this.doFetch(this.config.endpoint, {
+				method: "POST",
+				headers,
+				body,
+				keepalive: true
+			});
+			if (!res.ok) log.warn("metrics.rejected", {
+				status: res.status,
+				endpoint: this.config.endpoint
+			});
+		} catch (err) {
+			log.warn("metrics.failed", {
+				...describeError(err),
+				endpoint: this.config.endpoint
+			});
+		}
+	}
+	async resolveApiKey() {
+		if (this.apiKey) return this.apiKey;
+		this.apiKey = this.deps.getApiKey ? this.deps.getApiKey() : await this.readEnv(this.config.apiKeyEnvVar);
+		return this.apiKey;
+	}
+	async applyLazyLogLevel() {
+		if (this.lazyLogLevelApplied) return;
+		this.lazyLogLevelApplied = true;
+		applyLogLevelFromEnv(await this.readEnv(LOG_LEVEL_ENV_VAR));
+	}
+};
+//#endregion
+//#region src/metrics/impl/cloudflare.ts
+let cloudflareEnvPromise;
+async function readCloudflareEnv(name) {
+	try {
+		cloudflareEnvPromise ??= import(
+			/* @vite-ignore */
+			"cloudflare:workers"
+).then((m) => m.env).catch((err) => {
+			log.debug("metrics.cloudflare_env_import_failed", describeError(err));
+		});
+		const env = await cloudflareEnvPromise;
+		const raw = env?.[name];
+		const value = typeof raw === "string" && raw ? raw : void 0;
+		log.debug("metrics.read_cloudflare_env", {
+			name,
+			hasEnvBinding: !!env,
+			found: value !== void 0
+		});
+		return value;
+	} catch (err) {
+		log.debug("metrics.read_cloudflare_env_error", {
+			name,
+			...describeError(err)
+		});
+		return;
+	}
+}
+/** TanStack apps deploy to Cloudflare Workers: secrets live on the `env` binding
+*  (read via `cloudflare:workers`), with `process.env` as the local-dev fallback. */
+var TanStackMetricRecorder = class extends BaseMetricRecorder {
+	stack = "tanstack";
+	async readEnv(name) {
+		return readProcessEnv(name) ?? await readCloudflareEnv(name);
+	}
+};
+//#endregion
+//#region src/metrics/impl/supabase.ts
+function readDenoEnv(name) {
+	try {
+		const denoEnv = globalThis.Deno?.env;
+		const value = denoEnv?.get?.(name) || void 0;
+		log.debug("metrics.read_deno_env", {
+			name,
+			hasDenoEnv: !!denoEnv,
+			found: !!value
+		});
+		return value;
+	} catch (err) {
+		log.debug("metrics.read_deno_env_error", {
+			name,
+			...describeError(err)
+		});
+		return;
+	}
+}
+/** Supabase Edge Functions run on Deno: secrets are in `Deno.env`, with
+*  `process.env` as a fallback — both synchronous, resolved into the promise. */
+var SupabaseMetricRecorder = class extends BaseMetricRecorder {
+	stack = "supabase";
+	async readEnv(name) {
+		return readDenoEnv(name) ?? readProcessEnv(name);
+	}
+};
+//#endregion
+//#region src/metrics/recorder.ts
+/** Vend the recorder for a stack, in-flight per request. Returns a no-op when
+*  metrics are disabled (`metrics: false`); otherwise the stack-specific class,
+*  which still logs `tool.invoked` even if the key or endpoint is unavailable. */
+function createRecorderForRuntime(mcp, opts) {
+	const config = resolveMetricsConfig(mcp.metrics);
+	const server = {
+		name: mcp.name,
+		version: mcp.version
+	};
+	if (!config.enabled) return createNoopRecorder();
+	return opts.stack === "tanstack" ? new TanStackMetricRecorder(config, server) : new SupabaseMetricRecorder(config, server);
+}
+//#endregion
+//#region src/core/promise.ts
+/**
+* Caches only the fulfilled value: until one load resolves, concurrent callers
+* each run their own `load()`; afterwards every call returns the cached value
+* with no I/O. A rejection caches nothing, so the next call retries.
+*
+* Not single-flight by design. Sharing one in-flight promise across callers
+* breaks on Cloudflare Workers, where a promise that owns pending I/O can't be
+* awaited from a different request's I/O context.
+*/
+function cachedPromise(load, label) {
+	let settled = false;
+	let value;
+	return async () => {
+		if (settled) {
+			if (label) log.debug(`${label}.cache_hit`);
+			return value;
+		}
+		if (label) log.debug(`${label}.load_start`);
+		try {
+			const loaded = await load();
+			settled = true;
+			value = loaded;
+			if (label) log.debug(`${label}.settled`);
+			return loaded;
+		} catch (err) {
+			if (label) log.debug(`${label}.load_failed`, describeError(err));
+			throw err;
+		}
+	};
+}
+//#endregion
+//#region src/auth/discovery.ts
+var OAuthConfigurationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OAuthConfigurationError";
+	}
+};
+const METADATA_FETCH_TIMEOUT_MS = 5e3;
+function issuerPath(url) {
+	const path = trimTrailingSlash(url.pathname);
+	return path === "" ? void 0 : path;
+}
+function pathInsertedOAuthMetadataUrls(url, path) {
+	return [`${url.origin}/.well-known/oauth-authorization-server${path}`, `${url.origin}/.well-known/openid-configuration${path}`];
+}
+/**
+* Spec-legal metadata URLs for the issuer, ordered by RFC precedence: RFC 8414
+* path insertion first, then OIDC Discovery's issuer-relative form.
+* `fetchOAuthServerMetadata` validates the published `issuer` before accepting,
+* so order affects latency only, never which server verifies tokens.
+*/
+function oauthMetadataUrlsForIssuer(issuer) {
+	const normalizedIssuer = trimTrailingSlash(issuer);
+	const url = new URL(normalizedIssuer);
+	const path = issuerPath(url);
+	if (!path) return [`${normalizedIssuer}/.well-known/oauth-authorization-server`, `${normalizedIssuer}/.well-known/openid-configuration`];
+	return [...pathInsertedOAuthMetadataUrls(url, path), `${normalizedIssuer}/.well-known/openid-configuration`];
+}
+async function fetchFirstValidOAuthServerMetadata(metadataUrls, expectedIssuer) {
+	const errors = [];
+	for (const url of metadataUrls) try {
+		return await fetchOAuthServerMetadata(url, expectedIssuer);
+	} catch (err) {
+		log.debug("oauth.discovery.attempt_failed", {
+			url,
+			...describeError(err)
+		});
+		errors.push(`${url}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	log.error("oauth.discovery.exhausted", {
+		expectedIssuer,
+		urlsTried: metadataUrls,
+		errors
+	});
+	throw new Error(`failed to discover OAuth server metadata (${errors.join("; ")})`);
+}
+async function fetchOAuthServerMetadata(url, expectedIssuer) {
+	log.debug("oauth.discovery.fetch", { url });
+	const response = await fetch(url, {
+		signal: AbortSignal.timeout(METADATA_FETCH_TIMEOUT_MS),
+		redirect: "manual"
+	});
+	if (!response.ok) throw new Error(String(response.status));
+	const json = await response.json();
+	if (typeof json.issuer !== "string") throw new Error("missing issuer");
+	parseSafeUrl("discovered issuer", json.issuer);
+	if (trimTrailingSlash(json.issuer) !== expectedIssuer) {
+		log.warn("oauth.discovery.issuer_mismatch", {
+			url,
+			expectedIssuer,
+			published: json.issuer
+		});
+		throw new Error("issuer mismatch");
+	}
+	if (typeof json.jwks_uri !== "string") throw new Error("missing jwks_uri");
+	parseSafeUrl("discovered jwks_uri", json.jwks_uri);
+	return {
+		issuer: json.issuer,
+		jwks_uri: json.jwks_uri
+	};
+}
+async function fetchIssuerOAuthServerMetadata(issuer) {
+	try {
+		return await fetchFirstValidOAuthServerMetadata(oauthMetadataUrlsForIssuer(issuer), issuer);
+	} catch (err) {
+		log.error("oauth.discovery.config_error", {
+			issuer,
+			...describeError(err),
+			outcome: "500 oauth configuration error"
+		});
+		throw new OAuthConfigurationError(`OAuth issuer discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+/** Metadata and token verification share issuer/JWKS discovery, but transient failures must not poison the runtime. */
+function createOAuthDiscoveryResolver(auth) {
+	const configuredIssuer = trimTrailingSlash(auth.issuer);
+	const oauthServerMetadata = cachedPromise(() => fetchIssuerOAuthServerMetadata(configuredIssuer), "oauth.discovery.metadata");
+	return {
+		resolveIssuer: async () => configuredIssuer,
+		resolveJwksUri: async () => {
+			if (auth.jwksUri) {
+				log.debug("oauth.jwks.resolved", {
+					jwksUri: auth.jwksUri,
+					source: "configured"
+				});
+				return auth.jwksUri;
+			}
+			const jwksUri = (await oauthServerMetadata()).jwks_uri;
+			log.debug("oauth.jwks.resolved", {
+				jwksUri,
+				source: "discovered"
+			});
+			return jwksUri;
+		}
+	};
+}
+//#endregion
+//#region src/auth/resource.ts
+/**
+* Defaults the protected-resource name from the request `Host` so hosted apps stay portable
+* across domains. A validated config always sets `acceptedAudiences` or `resource`, so this
+* default only names the advertised metadata, never the accepted JWT audience. Deployments
+* behind an untrusted proxy should still pin `auth.resource` so a spoofed `Host` can't shift
+* the advertised metadata URL.
+*/
+function resolveProtectedResource(auth, request, options) {
+	if (auth.resource) return trimTrailingSlash(auth.resource);
+	const path = resolveResourcePath(options.resourcePath, request);
+	const resourceURL = new URL(path, request.url);
+	resourceURL.search = "";
+	resourceURL.hash = "";
+	return trimTrailingSlash(resourceURL.toString());
+}
+/**
+* A bare absolute path can't anchor `resource` to another origin; `//host`, `\\host`,
+* absolute URLs, and `..` segments can. WHATWG URL coerces `\` to `/` for special
+* schemes, so a backslash would smuggle a `//`-style authority past the prefix check.
+*/
+function assertResourcePathShape(resourcePath, label = "resourcePath") {
+	if (!resourcePath.startsWith("/") || resourcePath.startsWith("//") || resourcePath.includes("\\") || /(^|\/)\.\.(\/|$)/.test(resourcePath)) throw new Error(`@lovable.dev/mcp-js: ${label} must be an absolute path beginning with "/" without ".." segments or backslashes (got ${JSON.stringify(resourcePath)})`);
+}
+function resolveResourcePath(resourcePath, request) {
+	if (resourcePath === void 0) return new URL(request.url).pathname;
+	assertResourcePathShape(resourcePath);
+	return resourcePath;
+}
+//#endregion
+//#region src/auth/claims.ts
+function readString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function splitScopes(value) {
+	if (typeof value === "string") return value.split(/\s+/).filter(Boolean);
+	return stringClaimList(value);
+}
+function stringClaim(claims, name) {
+	return readString(claims[name]);
+}
+/** Normalizes a string-or-array claim from untrusted wire data, dropping non-string and empty entries. */
+function stringClaimList(value) {
+	if (typeof value === "string") return value === "" ? [] : [value];
+	if (Array.isArray(value)) return value.filter((entry) => typeof entry === "string" && entry !== "");
+	return [];
+}
+//#endregion
+//#region src/auth/verifier.ts
+const DEFAULT_JWT_ALGORITHMS = [
+	"RS256",
+	"RS384",
+	"RS512",
+	"ES256",
+	"ES384",
+	"ES512",
+	"EdDSA"
+];
+const DEFAULT_CLOCK_TOLERANCE_SECONDS = 30;
+const DEFAULT_ACCESS_TOKEN_TYPS = ["at+jwt", "JWT"];
+const JWKS_FETCH_TIMEOUT_MS = 5e3;
+var OAuthTokenError = class extends Error {
+	status;
+	oauthError;
+	constructor(status, oauthError, message) {
+		super(message);
+		this.status = status;
+		this.oauthError = oauthError;
+		this.name = "OAuthTokenError";
+	}
+};
+function resolveAcceptedAudiences(auth, resource) {
+	return auth.acceptedAudiences ?? [resource];
+}
+function tokenHeaderFields(token) {
+	try {
+		const header = decodeProtectedHeader(token);
+		return {
+			jwtAlg: header.alg,
+			jwtKid: header.kid,
+			tokenLength: token.length
+		};
+	} catch {
+		return { tokenLength: token.length };
+	}
+}
+async function fetchVerificationKeySet(jwksUri) {
+	try {
+		const response = await fetch(jwksUri, {
+			signal: AbortSignal.timeout(JWKS_FETCH_TIMEOUT_MS),
+			redirect: "manual"
+		});
+		if (!response.ok) throw new Error(`JWKS endpoint returned ${response.status}`);
+		return createLocalJWKSet(await response.json());
+	} catch (err) {
+		log.error("oauth.jwks.fetch_failed", {
+			...describeError(err),
+			outcome: "500 oauth configuration error"
+		});
+		throw new OAuthConfigurationError(`JWKS fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+function assertAccessTokenTyp(token, allowed) {
+	let header;
+	try {
+		header = decodeProtectedHeader(token);
+	} catch (err) {
+		log.debug("oauth.verify.bad_header", {
+			...describeError(err),
+			outcome: "401 invalid_token"
+		});
+		throw new OAuthTokenError(401, "invalid_token", "Malformed JWT header");
+	}
+	const typ = header.typ;
+	if (typeof typ !== "string" || !allowed.includes(typ)) {
+		log.debug("oauth.verify.bad_typ", {
+			jwtTyp: typ,
+			allowed,
+			outcome: "401 invalid_token"
+		});
+		throw new OAuthTokenError(401, "invalid_token", "Access token typ header is not accepted");
+	}
+}
+async function verifyJwtClaims(token, keySet, issuer, auth) {
+	try {
+		const { payload } = await jwtVerify(token, keySet, {
+			issuer: [issuer, `${issuer}/`],
+			algorithms: auth.algorithms ? [...auth.algorithms] : DEFAULT_JWT_ALGORITHMS,
+			requiredClaims: ["sub", "exp"],
+			clockTolerance: auth.clockToleranceSeconds ?? DEFAULT_CLOCK_TOLERANCE_SECONDS
+		});
+		return payload;
+	} catch (err) {
+		log.debug("oauth.verify.rejected", {
+			...describeError(err),
+			outcome: "401 invalid_token"
+		});
+		throw err;
+	}
+}
+function checkAcceptedAudience(claims, accepted, auth) {
+	if (claims.aud !== void 0 && !(Array.isArray(claims.aud) && claims.aud.length === 0)) {
+		if (stringClaimList(claims.aud).some((audience) => accepted.includes(audience))) return "aud";
+		log.debug("oauth.verify.bad_audience", {
+			tokenAud: claims.aud,
+			accepted,
+			outcome: "401 invalid_token"
+		});
+	} else if (auth.acceptResourceClaim !== false) {
+		const acceptedTrimmed = accepted.map(trimTrailingSlash);
+		if (stringClaimList(claims.resource).some((resource) => acceptedTrimmed.includes(trimTrailingSlash(resource)))) return "resource";
+		log.debug("oauth.verify.bad_resource", {
+			tokenResource: claims.resource,
+			accepted,
+			outcome: "401 invalid_token"
+		});
+	} else log.debug("oauth.verify.empty_audience", {
+		accepted,
+		outcome: "401 invalid_token"
+	});
+	throw new OAuthTokenError(401, "invalid_token", "token audience is not accepted");
+}
+function assertNonEmptySubject(claims) {
+	const sub = claims["sub"];
+	if (typeof sub !== "string" || sub.trim() === "") {
+		log.debug("oauth.verify.bad_subject", { subType: typeof sub });
+		throw new OAuthTokenError(401, "invalid_token", "token subject claim must be a non-empty string");
+	}
+}
+/** Rejects copied app-session JWTs that were not issued to an OAuth client. */
+function assertOAuthClientClaim(auth, clientId) {
+	if (auth.requireOAuthClientClaim !== false && !clientId) {
+		log.debug("oauth.verify.missing_client_claim", { outcome: "401 invalid_token" });
+		throw new OAuthTokenError(401, "invalid_token", "OAuth client claim is required");
+	}
+}
+/** `token` is non-enumerable so a stray `JSON.stringify(auth)` or spread can't leak the bearer. */
+function makeBearer(token) {
+	return Object.defineProperty({}, "token", {
+		value: token,
+		enumerable: false
+	});
+}
+function buildMcpAuthContext(args) {
+	const { claims } = args;
+	return {
+		type: "oauth",
+		principal: {
+			claims,
+			issuer: args.issuer,
+			resource: args.resource,
+			acceptedAudiences: args.acceptedAudiences,
+			scopes: splitScopes(claims.scope),
+			sub: stringClaim(claims, "sub"),
+			email: stringClaim(claims, "email"),
+			clientId: stringClaim(claims, "client_id") ?? stringClaim(claims, "azp")
+		},
+		bearer: makeBearer(args.token)
+	};
+}
+function createOAuthTokenVerifier(auth, discovery) {
+	const allowedTyps = auth.accessTokenTyp ?? DEFAULT_ACCESS_TOKEN_TYPS;
+	return async (token, request, options) => {
+		const resource = resolveProtectedResource(auth, request, options);
+		const issuer = await discovery.resolveIssuer();
+		const acceptedAudiences = resolveAcceptedAudiences(auth, resource);
+		log.debug("oauth.verify.start", {
+			issuer,
+			acceptedAudiences,
+			resource,
+			...tokenHeaderFields(token)
+		});
+		const jwksUri = await discovery.resolveJwksUri();
+		log.debug("oauth.jwks.fetch", { jwksUri });
+		const keySet = await fetchVerificationKeySet(jwksUri);
+		assertAccessTokenTyp(token, allowedTyps);
+		const claims = await verifyJwtClaims(token, keySet, issuer, auth);
+		const audienceVia = checkAcceptedAudience(claims, acceptedAudiences, auth);
+		assertNonEmptySubject(claims);
+		const context = buildMcpAuthContext({
+			token,
+			claims,
+			issuer,
+			resource,
+			acceptedAudiences
+		});
+		assertOAuthClientClaim(auth, context.principal.clientId);
+		log.info("oauth.verify.ok", {
+			sub: context.principal.sub,
+			clientId: context.principal.clientId,
+			scopes: context.principal.scopes,
+			audienceVia
+		});
+		return context;
+	};
+}
+//#endregion
+//#region src/auth/authorize.ts
+function quoteAuthenticateParam(value) {
+	return `"${value.replace(/[\u0000-\u001F\u007F]/g, "").replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function resolveProtectedResourceMetadataUrl(auth, request, options) {
+	if (auth.protectedResourceMetadataUrl !== void 0) return auth.protectedResourceMetadataUrl;
+	const base = auth.resource ?? request.url;
+	return new URL(options.metadataPath ?? "/.well-known/oauth-protected-resource", base).toString();
+}
+/** OAuth clients use the challenge to find this server's protected-resource metadata. */
+function wwwAuthenticateHeader(auth, request, options, params = {}) {
+	const values = [`realm=${quoteAuthenticateParam("mcp")}`, `resource_metadata=${quoteAuthenticateParam(resolveProtectedResourceMetadataUrl(auth, request, options))}`];
+	if (auth.requiredScopes && auth.requiredScopes.length > 0) values.push(`scope=${quoteAuthenticateParam(auth.requiredScopes.join(" "))}`);
+	if (params.error) values.push(`error=${quoteAuthenticateParam(params.error)}`);
+	if (params.errorDescription) values.push(`error_description=${quoteAuthenticateParam(params.errorDescription)}`);
+	return `Bearer ${values.join(", ")}`;
+}
+function challengeResponse(auth, request, options, status, oauthError, errorDescription) {
+	const headers = new Headers(JSON_HEADERS);
+	headers.set("WWW-Authenticate", wwwAuthenticateHeader(auth, request, options, {
+		error: oauthError,
+		errorDescription
+	}));
+	headers.set("Cache-Control", "no-store");
+	return new Response(JSON.stringify({ error: status === 403 ? "forbidden" : "unauthorized" }), {
+		status,
+		headers
+	});
+}
+function oauthConfigurationErrorResponse() {
+	return new Response(JSON.stringify({ error: "oauth configuration error" }), {
+		status: 500,
+		headers: {
+			...JSON_HEADERS,
+			"Cache-Control": "no-store"
+		}
+	});
+}
+function parseBearerToken(request) {
+	const header = request.headers.get("Authorization");
+	if (!header) return void 0;
+	const match = /^Bearer\s+(.+)$/i.exec(header.trim());
+	if (!match) return void 0;
+	const token = match[1].trim();
+	if (token === "" || /\s/.test(token)) return void 0;
+	return token;
+}
+/** @internal Builds the OAuth runtime (discovery + verifier) for a definition and its route options. */
+function getOAuthRuntime(mcp, options = {}) {
+	if (options.resourcePath !== void 0) assertResourcePathShape(options.resourcePath);
+	if (options.metadataPath !== void 0) assertResourcePathShape(options.metadataPath, "metadataPath");
+	const stableOptions = {
+		resourcePath: options.resourcePath,
+		metadataPath: options.metadataPath
+	};
+	const auth = mcp.auth?.type === "oauth" ? mcp.auth : void 0;
+	if (!auth) return {
+		kind: "unconfigured",
+		options: stableOptions
+	};
+	if (options.metadataPath !== void 0 && auth.protectedResourceMetadataUrl !== void 0) throw new Error(`@lovable.dev/mcp-js: the Vite plugin generates protected-resource metadata (metadataPath set), so auth.protectedResourceMetadataUrl must not also be set. Drop protectedResourceMetadataUrl, or set protectedResourceMetadataRoute: false in mcpPlugin(...) to host the document yourself.`);
+	const discovery = createOAuthDiscoveryResolver(auth);
+	return {
+		kind: "configured",
+		auth,
+		discovery,
+		verify: createOAuthTokenVerifier(auth, discovery),
+		options: stableOptions
+	};
+}
+/**
+* REST companion routes (`/.mcp/list-tools`, `/.mcp/invoke-tool/*`) are internal
+* RPC the main MCP server calls, so their own request path must never become the
+* advertised resource. Require `auth.resource` or a `resourcePath` so the bound
+* `principal.resource` is the public MCP route, not the internal `/.mcp/*` path.
+* The MCP protocol handler is exempt: its own path is the public resource.
+*/
+function assertRestResourceBinding(mcp, options = {}) {
+	const auth = mcp.auth?.type === "oauth" ? mcp.auth : void 0;
+	if (auth && auth.resource === void 0 && options.resourcePath === void 0) throw new Error(`@lovable.dev/mcp-js: REST companion handlers require auth.resource or a resourcePath so principal.resource binds to the public MCP route, not the internal /.mcp/* request path`);
+}
+function missingRequiredScopes(auth, scopes) {
+	const requiredScopes = auth.requiredScopes ?? [];
+	if (requiredScopes.length === 0) return [];
+	const granted = new Set(scopes);
+	return requiredScopes.filter((scope) => !granted.has(scope));
+}
+function assertRequiredScopes(auth, context) {
+	if (missingRequiredScopes(auth, context.principal.scopes).length > 0) throw new OAuthTokenError(403, "insufficient_scope", "Additional OAuth scope is required");
+}
+function createRequestAuthorizer(mcp, options = {}) {
+	const runtime = getOAuthRuntime(mcp, options);
+	return { async authorize(request, recorder) {
+		if (runtime.kind === "unconfigured") return { ok: true };
+		const startedAt = nowMs();
+		const token = parseBearerToken(request);
+		if (!token) {
+			log.info("auth.no_bearer_token", { outcome: "401" });
+			return {
+				ok: false,
+				response: challengeResponse(runtime.auth, request, runtime.options, 401)
+			};
+		}
+		try {
+			const auth = await runtime.verify(token, request, runtime.options);
+			assertRequiredScopes(runtime.auth, auth);
+			return {
+				ok: true,
+				auth
+			};
+		} catch (err) {
+			if (err instanceof OAuthConfigurationError) {
+				log.error("auth.config_error", {
+					...describeError(err),
+					outcome: "500"
+				});
+				await recorder?.emit({
+					tool: null,
+					method: "authorize",
+					outcome: "auth_config_error",
+					durationMs: nowMs() - startedAt
+				});
+				return {
+					ok: false,
+					response: oauthConfigurationErrorResponse()
+				};
+			}
+			if (err instanceof OAuthTokenError) {
+				log.info("auth.token_rejected", {
+					status: err.status,
+					oauthError: err.oauthError
+				});
+				return {
+					ok: false,
+					response: challengeResponse(runtime.auth, request, runtime.options, err.status, err.oauthError, err.message)
+				};
+			}
+			log.error("auth.unexpected_error", {
+				...describeError(err),
+				outcome: "401"
+			});
+			return {
+				ok: false,
+				response: challengeResponse(runtime.auth, request, runtime.options, 401, "invalid_token", "Invalid access token")
+			};
+		}
+	} };
+}
+//#endregion
+//#region src/core/cors.ts
+const EXPOSE_HEADERS = "WWW-Authenticate, Mcp-Session-Id, Mcp-Protocol-Version";
+const ALLOW_HEADERS = "Authorization, Content-Type, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-ID";
+/** Add permissive CORS to a built response, preserving its other headers. */
+function withCors(response) {
+	response.headers.set("Access-Control-Allow-Origin", "*");
+	response.headers.set("Access-Control-Expose-Headers", EXPOSE_HEADERS);
+	return response;
+}
+function corsPreflightResponse(allowMethods) {
+	return new Response(null, {
+		status: 204,
+		headers: {
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": allowMethods,
+			"Access-Control-Allow-Headers": ALLOW_HEADERS,
+			"Access-Control-Max-Age": "86400"
+		}
+	});
+}
+//#endregion
+export { getOAuthRuntime as a, resolveProtectedResource as c, nowMs as d, JSON_HEADERS as f, createRequestAuthorizer as i, createRecorderForRuntime as l, methodNotAllowed as m, withCors as n, oauthConfigurationErrorResponse as o, headResponse as p, assertRestResourceBinding as r, assertResourcePathShape as s, corsPreflightResponse as t, createNoopRecorder as u };