@questpie/mcp 3.15.2 → 3.17.0

package/dist/mcp-CuJEhynp.mjs

@@ -0,0 +1,350 @@
+import { C as validateMcpPrincipal, d as getAppMcpRelease, m as assertBoundedMcpValue, t as createMcpServer } from "./create-server-CEWFf041.mjs";
+import { t as mcpPlugin } from "./plugin-BZQe1pji.mjs";
+import { route } from "questpie";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+
+//#region src/server/oauth-scope-catalog.ts
+const mcpOAuthScopeCatalog = (contributorApp) => {
+	const oauth = getAppMcpRelease(contributorApp).catalog.oauth;
+	return {
+		scopes: [...oauth.scopes],
+		scopesSupported: [...oauth.scopesSupported]
+	};
+};
+
+//#endregion
+//#region src/server/mcp-http.ts
+/**
+* Shared MCP Streamable-HTTP handler.
+*
+* `route()` is single-method, so the MCP endpoint's four verbs (POST = JSON-RPC
+* messages, GET/DELETE = explicit stateless 405, OPTIONS = CORS preflight) are
+* registered as separate method-suffixed route files under `routes/`
+* (`mcp.ts` = POST, `mcp.get.ts`, `mcp.delete.ts`, `mcp.options.ts`) per the
+* codegen file convention — NOT method chaining and NOT a hand-written
+* `module.ts`. All four share THIS handler, which dispatches on
+* `request.method` internally because the transport needs one object for every
+* verb on the path. Stateful sessions and reconnect semantics are intentionally
+* absent.
+*/
+const MAX_MCP_HTTP_BODY_BYTES = 1024 * 1024;
+const MAX_MCP_HTTP_BATCH_SIZE = 16;
+const MAX_MCP_HTTP_RESPONSE_BYTES = 4 * 1024 * 1024;
+const CORS_ALLOWED_HEADERS = new Set([
+	"authorization",
+	"content-type",
+	"mcp-protocol-version",
+	"x-api-key"
+]);
+const mcpMeta = {
+	title: "MCP endpoint",
+	description: "Model Context Protocol endpoint for QUESTPIE."
+};
+function appFromRouteContext(ctx) {
+	return ctx.app;
+}
+function executionContextFromRouteContext(ctx) {
+	const routeCtx = { ...ctx };
+	delete routeCtx.app;
+	delete routeCtx.request;
+	return routeCtx;
+}
+function withCors(response, allowedOrigin$1) {
+	const headers = new Headers(response.headers);
+	if (allowedOrigin$1) {
+		headers.set("Access-Control-Allow-Origin", allowedOrigin$1);
+		headers.set("Vary", "Origin");
+	}
+	headers.set("Access-Control-Allow-Methods", "POST, OPTIONS");
+	headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization, MCP-Protocol-Version, x-api-key");
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function allowedOrigin(appUrl, request, additions) {
+	const requested = request.headers.get("origin");
+	if (!requested) return void 0;
+	const origins = new Set([new URL(appUrl).origin]);
+	for (const addition of additions ?? []) {
+		const origin = canonicalConfiguredOrigin(addition);
+		if (origin) origins.add(origin);
+	}
+	const canonicalRequested = canonicalConfiguredOrigin(requested);
+	return canonicalRequested && origins.has(canonicalRequested) ? canonicalRequested : null;
+}
+function canonicalConfiguredOrigin(value) {
+	try {
+		const url = new URL(value);
+		if (url.username || url.password || url.pathname !== "/" || url.search || url.hash || value !== url.origin) return null;
+		return url.origin;
+	} catch {
+		return null;
+	}
+}
+function canonicalHost(value, protocol) {
+	if (!value || value.trim() !== value || value.includes("://") || /[/?#@\\]/.test(value)) return null;
+	try {
+		const url = new URL(`${protocol}//${value}`);
+		if (url.username || url.password || url.pathname !== "/" || !url.host) return null;
+		return url.host.toLowerCase();
+	} catch {
+		return null;
+	}
+}
+function hasAllowedHost(appUrl, request, additions) {
+	const app = new URL(appUrl);
+	const allowed = new Set([app.host.toLowerCase()]);
+	for (const addition of additions ?? []) {
+		const host = canonicalHost(addition, app.protocol);
+		if (host) allowed.add(host);
+	}
+	const requested = canonicalHost(request.headers.get("host") ?? new URL(request.url).host, app.protocol);
+	return requested !== null && allowed.has(requested);
+}
+function isAllowedPreflight(request) {
+	if (!request.headers.has("origin")) return false;
+	if (request.headers.get("access-control-request-method")?.toUpperCase() !== "POST") return false;
+	const requestedHeaders = request.headers.get("access-control-request-headers");
+	if (!requestedHeaders) return true;
+	const headers = requestedHeaders.split(",").map((header) => header.trim().toLowerCase());
+	return headers.length <= CORS_ALLOWED_HEADERS.size && headers.every((header) => header.length > 0 && CORS_ALLOWED_HEADERS.has(header));
+}
+async function readBoundedBody(request) {
+	if (!request.body) return new Uint8Array(/* @__PURE__ */ new ArrayBuffer(0));
+	const reader = request.body.getReader();
+	const chunks = [];
+	let size = 0;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		size += value.byteLength;
+		if (size > MAX_MCP_HTTP_BODY_BYTES) {
+			await reader.cancel();
+			return;
+		}
+		chunks.push(value);
+	}
+	const body = new Uint8Array(new ArrayBuffer(size));
+	let offset = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return body;
+}
+function hasBoundedJsonRpcBatch(body, limits) {
+	try {
+		const payload = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(body));
+		assertBoundedMcpValue(payload, {
+			maxBytes: MAX_MCP_HTTP_BODY_BYTES,
+			maxValueDepth: limits.maxInputDepth,
+			maxValueNodes: limits.maxValueNodes
+		}, "input_too_large");
+		return !Array.isArray(payload) || payload.length > 0 && payload.length <= MAX_MCP_HTTP_BATCH_SIZE;
+	} catch {
+		return false;
+	}
+}
+async function finalizeResponse(response, close) {
+	if (!response.body) {
+		await close();
+		return response;
+	}
+	const reader = response.body.getReader();
+	const chunks = [];
+	let size = 0;
+	try {
+		while (true) {
+			const next = await reader.read();
+			if (next.done) break;
+			size += next.value.byteLength;
+			if (size > MAX_MCP_HTTP_RESPONSE_BYTES) {
+				await reader.cancel();
+				throw new Error("MCP response exceeded limit");
+			}
+			chunks.push(next.value);
+		}
+	} finally {
+		await close();
+	}
+	const body = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new Response(body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+/**
+* Build the `WWW-Authenticate` challenge value for an unauthenticated HTTP MCP
+* request. `resource_metadata` points at this app's Protected Resource metadata
+* document (RFC 9728), served beside the MCP route by the core
+* `oauth-protected-resource` route (MO4). An MCP client reads it to discover
+* the authorization server and start the OAuth 2.1 flow.
+*
+* The public origin comes from `app.config.app.url`, while the mount path comes
+* from the actual MCP request. This keeps the canonical external host used for
+* token audience binding, and also preserves adapter base paths such as `/api`.
+*/
+function protectedResourceChallenge(appUrl, requestUrl) {
+	const request = new URL(requestUrl);
+	request.pathname = request.pathname.replace(/\/+$/, "");
+	const metadataPath = new URL(".well-known/oauth-protected-resource", request).pathname;
+	const metadataUrl = new URL(appUrl);
+	metadataUrl.pathname = metadataPath;
+	metadataUrl.search = "";
+	metadataUrl.hash = "";
+	return `Bearer resource_metadata="${metadataUrl.href}"`;
+}
+/**
+* A verified principal is required to reach MCP tool execution over HTTP. The
+* request context resolves one for a cookie/bearer session (`kind: "user"`) or a
+* valid OAuth access token (`kind: "oauth"`); an unauthenticated request has
+* none. Read it structurally — the handler-args type does not surface it.
+*/
+function hasVerifiedPrincipal(ctx) {
+	const principal = ctx.principal;
+	const validated = validateMcpPrincipal(principal);
+	return validated?.kind === "user" || validated?.kind === "oauth";
+}
+async function handleMcpRequest(ctx) {
+	const { request } = ctx;
+	const app = appFromRouteContext(ctx);
+	const release = getAppMcpRelease(app);
+	const config = release.config;
+	const corsOrigin = allowedOrigin(app.config.app.url, request, config.http?.allowedOrigins);
+	if (corsOrigin === null || !hasAllowedHost(app.config.app.url, request, config.http?.allowedHosts)) return new Response(null, { status: 403 });
+	if (request.method === "GET" || request.method === "DELETE") return new Response(null, {
+		status: 405,
+		headers: { Allow: "POST, OPTIONS" }
+	});
+	if (request.method === "OPTIONS") {
+		if (!isAllowedPreflight(request)) return new Response(null, { status: 403 });
+		return withCors(new Response(null, { status: 204 }), corsOrigin);
+	}
+	if (request.headers.has("mcp-session-id") || request.headers.has("last-event-id")) return new Response(null, { status: 400 });
+	const declaredLength = request.headers.get("content-length");
+	if (declaredLength) {
+		if (!/^\d+$/.test(declaredLength)) return new Response(null, { status: 400 });
+		if (Number(declaredLength) > MAX_MCP_HTTP_BODY_BYTES) return new Response(null, { status: 413 });
+	}
+	if (!hasVerifiedPrincipal(ctx)) return withCors(new Response(null, {
+		status: 401,
+		headers: { "WWW-Authenticate": protectedResourceChallenge(app.config.app.url, request.url) }
+	}), corsOrigin);
+	const body = await readBoundedBody(request);
+	if (!body) return withCors(new Response(null, { status: 413 }), corsOrigin);
+	if (!hasBoundedJsonRpcBatch(body, release.execution.limits)) return withCors(new Response(null, { status: 400 }), corsOrigin);
+	const boundedRequest = new Request(request.url, {
+		method: request.method,
+		headers: request.headers,
+		body,
+		signal: request.signal
+	});
+	let server;
+	try {
+		server = await createMcpServer(app, {
+			transport: "http",
+			accessMode: "user",
+			request: boundedRequest,
+			ctx: executionContextFromRouteContext(ctx)
+		});
+		const appUrl = new URL(app.config.app.url);
+		const transport = new WebStandardStreamableHTTPServerTransport({
+			sessionIdGenerator: void 0,
+			allowedOrigins: [...new Set([appUrl.origin, ...(config.http?.allowedOrigins ?? []).map(canonicalConfiguredOrigin).filter((origin) => origin !== null)])],
+			allowedHosts: [...new Set([appUrl.host.toLowerCase(), ...(config.http?.allowedHosts ?? []).map((host) => canonicalHost(host, appUrl.protocol)).filter((host) => host !== null)])],
+			enableJsonResponse: config.http?.enableJsonResponse ?? true
+		});
+		await server.connect(transport);
+		return withCors(await finalizeResponse(await transport.handleRequest(boundedRequest), () => server.close()), corsOrigin);
+	} catch {
+		await server?.close().catch(() => void 0);
+		return withCors(new Response(null, { status: 500 }), corsOrigin);
+	}
+}
+async function mcpHandler(ctx) {
+	try {
+		return await handleMcpRequest(ctx);
+	} catch {
+		return new Response(null, { status: 500 });
+	}
+}
+
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.ts
+var mcp_default$1 = route().post().raw().access(true).meta(mcpMeta).handler(mcpHandler);
+
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.delete.ts
+var mcp_delete_default = route().delete().raw().access(true).meta(mcpMeta).handler(mcpHandler);
+
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.get.ts
+var mcp_get_default = route().get().raw().access(true).meta(mcpMeta).handler(mcpHandler);
+
+//#endregion
+//#region src/server/modules/mcp/routes/mcp.options.ts
+var mcp_options_default = route().options().raw().access(true).meta(mcpMeta).handler(mcpHandler);
+
+//#endregion
+//#region src/server/modules/mcp/plugin.ts
+/**
+* MCP module plugin — re-exports the MCP codegen plugin so that module
+* codegen discovers it and embeds it in the generated module definition.
+* This allows `extractPluginsFromModules` to pick it up automatically at
+* root-app codegen time (so consuming apps get the `mcp-tools` category,
+* `config/mcp.ts` discover, and scaffolds).
+*/
+var plugin_default = mcpPlugin();
+
+//#endregion
+//#region src/server/modules/mcp/.generated/module.ts
+const _module = {
+	name: "questpie-mcp",
+	routes: {
+		mcp: mcp_default$1,
+		"mcp:DELETE": mcp_delete_default,
+		"mcp:GET": mcp_get_default,
+		"mcp:OPTIONS": mcp_options_default
+	},
+	collections: {},
+	channels: {},
+	globals: {},
+	jobs: {},
+	messages: {},
+	services: {},
+	emails: {},
+	migrations: [],
+	seeds: [],
+	fieldTypes: {},
+	mcpTools: {},
+	plugin: plugin_default
+};
+var module_default = _module;
+
+//#endregion
+//#region src/server/modules/mcp/index.ts
+/**
+* MCP Module
+*
+* Backend module for the QUESTPIE Model Context Protocol endpoint.
+*
+* Exports:
+* - `mcpModule` — static module definition (generated by codegen from file convention)
+* - `McpModule` — type of the static module
+*/
+const mcpModule = {
+	...module_default,
+	oauthScopeCatalogs: { mcp: mcpOAuthScopeCatalog }
+};
+var mcp_default = mcpModule;
+
+//#endregion
+export { mcp_default as n, mcpModule as t };

package/dist/modules/mcp.d.mts

@@ -1,2 +1,2 @@
-import { n as McpModule, t as mcpModule } from "../index-Cxta5KOn.mjs";
+import { n as mcpModule, t as McpModule } from "../index-DlBFWTIg.mjs";
 export { type McpModule, mcpModule };

package/dist/modules/mcp.mjs

@@ -1,3 +1,3 @@
-import { t as mcpModule } from "../mcp-snyVygDQ.mjs";
+import { t as mcpModule } from "../mcp-CuJEhynp.mjs";
 
 export { mcpModule };

package/dist/{plugin-BJ6gELRj.mjs → plugin-BZQe1pji.mjs}

@@ -29,7 +29,7 @@ function mcpPlugin() {
 			scaffolds: { "mcp-tool": {
 				dir: "mcp-tools",
 				description: "MCP custom tool definition",
-				template: ({ kebab, camel }) => `import { mcpTool } from "@questpie/mcp";\nimport { z } from "zod";\n\nexport default mcpTool("${kebab}", {\n\tdescription: "Run ${kebab}.",\n\tinputSchema: z.object({}),\n}).handler(async ({ ctx }) => {\n\treturn {\n\t\tstructuredContent: { ok: true },\n\t\tcontent: [{ type: "text", text: "${camel} completed" }],\n\t};\n});\n`
+				template: ({ kebab, camel }) => `import { mcpTool } from "@questpie/mcp";\nimport { z } from "zod";\n\nexport default mcpTool("${kebab}", {\n\taccess: ({ session }) => !!session,\n\tscopes: false,\n\tdescription: "Run ${kebab}.",\n\tinputSchema: z.object({}),\n}).handler(async ({ ctx }) => {\n\treturn {\n\t\tstructuredContent: { ok: true },\n\t\tcontent: [{ type: "text", text: "${camel} completed" }],\n\t};\n});\n`
 			} }
 		} }
 	};

package/dist/plugin.mjs

@@ -1,3 +1,3 @@
-import { t as mcpPlugin } from "./plugin-BJ6gELRj.mjs";
+import { t as mcpPlugin } from "./plugin-BZQe1pji.mjs";
 
 export { mcpPlugin };

package/dist/{stdio-qyQFVEyU.mjs → stdio-CgIPiPUb.mjs}

@@ -1,4 +1,4 @@
-import { t as createMcpServer } from "./create-server-DIvtVlma.mjs";
+import { t as createMcpServer } from "./create-server-CEWFf041.mjs";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 //#region src/server/stdio.ts