@questpie/mcp 3.16.0 → 3.18.0

package/dist/create-server-DIvtVlma.mjs

@@ -1,1014 +0,0 @@
-import { createAdapterContext, createContextFactory, defaultOperationScope, evaluateRouteAccess, executeJsonRoute, extractAppServices, introspectCollection, introspectGlobal, introspectRoutes, isJsonRoute, umbrellaScopeFor } from "questpie";
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-
-//#region src/server/zod-json-schema.ts
-function jsonSchemaCompatibleSchema(schema) {
-	if (!schema) return void 0;
-	if (canConvertToJsonSchema(schema)) return schema;
-	const def = schema._def;
-	switch (def?.type) {
-		case "date": return z.string().describe("ISO date or date-time string");
-		case "optional": return jsonSchemaCompatibleSchema(def.innerType)?.optional() ?? z.unknown();
-		case "nullable": return jsonSchemaCompatibleSchema(def.innerType)?.nullable() ?? z.unknown();
-		case "default":
-		case "prefault":
-		case "catch": return jsonSchemaCompatibleSchema(def.innerType)?.optional() ?? z.unknown();
-		case "array": return z.array(jsonSchemaCompatibleSchema(def.element) ?? z.unknown());
-		case "record": {
-			const keySchema = jsonSchemaCompatibleSchema(def.keyType);
-			return z.record(keySchema instanceof z.ZodString ? keySchema : z.string(), jsonSchemaCompatibleSchema(def.valueType) ?? z.unknown());
-		}
-		case "union": {
-			const options = Array.isArray(def.options) ? def.options.map((option) => jsonSchemaCompatibleSchema(option) ?? z.unknown()) : [];
-			if (options.length === 0) return z.unknown();
-			if (options.length === 1) return options[0];
-			return z.union(options);
-		}
-		case "object": {
-			const shape = schema.shape;
-			const nextShape = {};
-			for (const [key, value] of Object.entries(shape)) nextShape[key] = jsonSchemaCompatibleSchema(value) ?? z.unknown();
-			const objectSchema = z.object(nextShape);
-			if (def.catchall && def.catchall._def?.type !== "never") return objectSchema.catchall(jsonSchemaCompatibleSchema(def.catchall) ?? z.unknown());
-			return objectSchema;
-		}
-		default: return z.unknown();
-	}
-}
-function toJsonSchema(schema) {
-	const compatible = jsonSchemaCompatibleSchema(schema);
-	if (!compatible) return void 0;
-	try {
-		return z.toJSONSchema(compatible);
-	} catch {
-		return;
-	}
-}
-function canConvertToJsonSchema(schema) {
-	try {
-		z.toJSONSchema(schema);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-//#endregion
-//#region src/server/field-policy.ts
-const recordSchema = z.record(z.string(), z.unknown());
-const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const hasFieldPolicy = (policy) => (policy.fields?.include?.length ?? 0) > 0 || (policy.fields?.exclude?.length ?? 0) > 0;
-const allowedKeysFor = (keys, policy) => {
-	const initial = policy.fields?.include?.length ? policy.fields.include : Array.from(keys);
-	const allowed = new Set(initial);
-	for (const key of policy.fields?.exclude ?? []) allowed.delete(key);
-	return allowed;
-};
-function filterRecordFields(value, policy) {
-	if (!hasFieldPolicy(policy) || !isRecord(value)) return value;
-	const allowed = allowedKeysFor(Object.keys(value), policy);
-	const next = {};
-	for (const key of allowed) if (hasOwn(value, key)) next[key] = value[key];
-	return next;
-}
-function filterCrudResultFields(value, policy) {
-	if (!hasFieldPolicy(policy)) return value;
-	if (Array.isArray(value)) return value.map((item) => filterCrudResultFields(item, policy));
-	if (!isRecord(value)) return value;
-	if (Array.isArray(value.docs)) return {
-		...value,
-		docs: value.docs.map((doc) => filterRecordFields(doc, policy))
-	};
-	if (isRecord(value.data)) return {
-		...value,
-		data: filterRecordFields(value.data, policy)
-	};
-	return filterRecordFields(value, policy);
-}
-function filterEntitySchemaFields(schema, policy) {
-	if (!hasFieldPolicy(policy) || !isRecord(schema.fields)) return schema;
-	const allowed = allowedKeysFor(Object.keys(schema.fields), policy);
-	const fields = {};
-	for (const key of allowed) if (hasOwn(schema.fields, key)) fields[key] = schema.fields[key];
-	const next = {
-		...schema,
-		fields
-	};
-	if (isRecord(schema.validation)) {
-		const validation = schema.validation;
-		next.validation = filterValidationSchemas(validation, allowed);
-	}
-	return next;
-}
-function filterValidationSchemas(validation, allowed) {
-	const next = { ...validation };
-	for (const [key, schema] of Object.entries(validation)) next[key] = filterJsonSchemaProperties(schema, allowed);
-	return next;
-}
-function filterJsonSchemaProperties(schema, allowed) {
-	if (!isRecord(schema) || !isRecord(schema.properties)) return schema;
-	const jsonSchema = schema;
-	const properties = {};
-	for (const key of allowed) if (hasOwn(jsonSchema.properties, key)) properties[key] = jsonSchema.properties[key];
-	return {
-		...jsonSchema,
-		properties,
-		required: Array.isArray(jsonSchema.required) ? jsonSchema.required.filter((key) => allowed.has(key)) : jsonSchema.required
-	};
-}
-function createCollectionDataSchema(collection, operation, policy) {
-	const validation = collection.state?.validation;
-	return filterZodObjectSchema(operation === "create" ? validation?.insertSchema : validation?.updateSchema, policy, entityFieldNames(collection));
-}
-function createGlobalDataSchema(global, policy) {
-	const validation = global.state?.validation;
-	return filterZodObjectSchema(validation?.updateSchema, policy, entityFieldNames(global));
-}
-function filterZodObjectSchema(schema, policy, knownFields) {
-	if (!schema) return recordSchema;
-	if (!(schema instanceof z.ZodObject)) return recordSchema;
-	const shape = schema.shape;
-	if (!(hasFieldPolicy(policy) || !!knownFields?.length)) return schema;
-	const allowed = allowedKeysFor(knownFields ?? Object.keys(shape), policy);
-	const nextShape = {};
-	for (const key of allowed) if (hasOwn(shape, key)) nextShape[key] = jsonSchemaCompatibleSchema(shape[key]) ?? z.unknown();
-	return z.object(nextShape);
-}
-function entityFieldNames(entity) {
-	const fields = entity.state?.fields;
-	if (!isRecord(fields)) return void 0;
-	return Object.keys(fields);
-}
-
-//#endregion
-//#region src/server/policy.ts
-const DEFAULT_MCP_CONFIG = {
-	crud: {
-		maxLimit: 100,
-		defaults: {},
-		collections: {},
-		globals: {}
-	},
-	routes: {
-		exposeAnnotated: true,
-		routes: {}
-	},
-	resources: {
-		schemas: true,
-		routes: true
-	},
-	http: {
-		accessMode: "user",
-		enableJsonResponse: true
-	},
-	stdio: { accessMode: "system" }
-};
-function isPlainObject(value) {
-	return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function mergeDeep(base, override) {
-	if (!override) return { ...base };
-	const out = { ...base };
-	for (const [key, value] of Object.entries(override)) if (isPlainObject(value) && isPlainObject(out[key])) out[key] = mergeDeep(out[key], value);
-	else if (value !== void 0) out[key] = value;
-	return out;
-}
-function resolveMcpConfig(app, override) {
-	return mergeDeep(mergeDeep(DEFAULT_MCP_CONFIG, app.state?.config?.mcp ?? {}), override);
-}
-function defaultAccessModeForTransport(config, transport) {
-	if (transport === "http") return "user";
-	return config.stdio?.accessMode ?? "system";
-}
-function resolveEntityPolicy(config, kind, name, transport = "http") {
-	if (kind === "route") {
-		const override$1 = config.routes?.routes?.[name];
-		return normalizePolicy({
-			expose: true,
-			read: true
-		}, override$1);
-	}
-	if (kind === "global") {
-		const defaults$1 = {
-			...transport === "stdio" ? {
-				read: true,
-				write: true
-			} : {
-				read: true,
-				write: false
-			},
-			...config.crud?.defaults?.globals ?? {}
-		};
-		const override$1 = config.crud?.globals?.[name];
-		return normalizePolicy({
-			expose: true,
-			...defaults$1
-		}, override$1);
-	}
-	const defaults = {
-		...transport === "stdio" ? {
-			read: true,
-			write: true,
-			delete: true
-		} : {
-			read: true,
-			write: false,
-			delete: false
-		},
-		...config.crud?.defaults?.collections ?? {}
-	};
-	const override = config.crud?.collections?.[name];
-	return normalizePolicy({
-		expose: true,
-		...defaults
-	}, override);
-}
-function normalizePolicy(defaults, override) {
-	if (override === false) return {
-		expose: false,
-		operations: {},
-		operationScopes: {}
-	};
-	const base = {
-		expose: defaults.expose ?? true,
-		read: defaults.read,
-		write: defaults.write,
-		delete: defaults.delete,
-		operations: { ...defaults.operations ?? {} },
-		requiredScopes: defaults.requiredScopes,
-		operationScopes: { ...defaults.operationScopes ?? {} },
-		fields: defaults.fields,
-		description: defaults.description
-	};
-	if (override === true || override === void 0) return base;
-	return {
-		...base,
-		...override,
-		expose: override.expose ?? base.expose,
-		operations: {
-			...base.operations,
-			...override.operations ?? {}
-		},
-		requiredScopes: override.requiredScopes ?? base.requiredScopes,
-		operationScopes: {
-			...base.operationScopes,
-			...override.operationScopes ?? {}
-		}
-	};
-}
-function operationRule(policy, operation) {
-	if (policy.operations[operation] !== void 0) return policy.operations[operation];
-	if (operation === "delete") return policy.delete;
-	if (operation === "create" || operation === "update") return policy.write;
-	return policy.read;
-}
-/** Normalize an {@link McpRequiredScopes} declaration to a scope list. */
-function normalizeRequiredScopes(required) {
-	if (required === void 0 || required === false) return [];
-	return typeof required === "string" ? [required] : [...required];
-}
-/**
-* Resolve the scopes an OAuth caller must hold for a given entity operation.
-*
-* Precedence (most specific wins), each level is declarative data:
-* 1. `policy.operationScopes[operationName]` — per-operation override.
-* 2. `policy.requiredScopes` — entity-level requirement (all operations).
-* 3. the default `<resource>:<name>:<verb>` mapping derived from the kind.
-*
-* A level set to `false` explicitly requires no scope (stops the fallback).
-* Returns a (possibly empty) scope list; empty means "no scope required". This
-* resolves the requirement; the deny/register decision that consumes it is
-* {@link scopeGateAllows}.
-*/
-function requiredScopesForOperation(policy, kind, name, operationName, operationKind) {
-	const perOperation = policy.operationScopes[operationName];
-	if (perOperation !== void 0) return normalizeRequiredScopes(perOperation);
-	if (policy.requiredScopes !== void 0) return normalizeRequiredScopes(policy.requiredScopes);
-	return [defaultOperationScope(kind, name, operationKind)];
-}
-/**
-* The consented scopes carried by the request, or `undefined` when the caller
-* is not OAuth-authenticated. Reads `ctx.principal` (populated by MO6): only the
-* `oauth` principal carries `scopes`; `user` and `system` do not.
-*/
-function scopesFromContext(ctx) {
-	const principal = ctx.principal;
-	if (principal && principal.kind === "oauth") return principal.scopes;
-}
-/**
-* The OAuth scope gate (MO8, extended by the umbrella model — LOCKED #2).
-*
-* Given the scopes the caller holds (from {@link scopesFromContext}) and the
-* scopes an operation requires (from {@link requiredScopesForOperation} or a
-* custom tool's `config.scopes`), decide whether the scope gate passes.
-*
-* Semantics:
-* - `heldScopes === undefined` → the caller is not OAuth-authenticated (`user`,
-*   `system`, or unauthenticated). The scope gate does not apply and PASSES;
-*   authorization is left entirely to RBAC / MCP rules. This is what keeps the
-*   first-party admin (`user`) and stdio (`system`) paths unchanged.
-* - Otherwise the caller is an `oauth` principal: the gate PASSES iff EVERY
-*   required scope is satisfied — a required scope is satisfied when the caller
-*   holds it directly OR holds its applicable coarse umbrella
-*   ({@link umbrellaScopeFor}). An empty `required` needs nothing, so it passes
-*   for everyone.
-*
-* The umbrella widening is deliberately narrow — it can only satisfy a
-* granular `<resource>:<name>:read|write` with the matching `<resource>:read`
-* or `<resource>:write` umbrella. `read` and `write` are independent (holding
-* `collections:write` never satisfies a `<name>:read` requirement, and vice
-* versa), and there is NO umbrella for `:delete` or `routes:…:invoke`. So the
-* umbrella grants convenience without ever over-granting across verb, resource
-* kind, or into delete/invoke.
-*
-* This gate is **additive** — it can only ever REMOVE access from an `oauth`
-* caller. It never grants access on its own: callers still run the MCP rule and
-* the collection/global `.access()` RBAC independently, and all must pass. The
-* effective `oauth` permission is therefore `scopes ∩ RBAC`.
-*/
-function scopeGateAllows(heldScopes, required) {
-	if (heldScopes === void 0) return true;
-	if (required.length === 0) return true;
-	const held = new Set(heldScopes);
-	return required.every((scope) => {
-		if (held.has(scope)) return true;
-		const umbrella = umbrellaScopeFor(scope);
-		return umbrella !== void 0 && held.has(umbrella);
-	});
-}
-async function evaluateMcpRule(rule, options) {
-	if (rule === void 0) return true;
-	if (typeof rule === "boolean") return rule;
-	return rule({
-		transport: options.transport,
-		accessMode: options.accessMode,
-		session: options.ctx.session,
-		scopes: scopesFromContext(options.ctx),
-		ctx: options.ctx
-	});
-}
-
-//#endregion
-//#region src/server/runtime.ts
-function createRuntimeScope(app, options) {
-	const transport = options.transport ?? "http";
-	const accessMode = options.accessMode ?? (transport === "stdio" ? "system" : "user");
-	const createContext = createContextFactory(app);
-	let requestContextPromise;
-	return {
-		app,
-		transport,
-		accessMode,
-		request: options.request,
-		async getContext() {
-			if (options.ctx) return options.ctx;
-			if (options.request) {
-				requestContextPromise ??= createAdapterContext(app, options.request, { accessMode }).then((adapterContext) => ({
-					...adapterContext.appContext,
-					request: options.request
-				}));
-				return requestContextPromise;
-			}
-			return createContext({ accessMode });
-		}
-	};
-}
-function safeJsonStringify(value) {
-	return JSON.stringify(value, (_key, nestedValue) => {
-		if (typeof nestedValue === "bigint") return nestedValue.toString();
-		if (nestedValue instanceof Date) return nestedValue.toISOString();
-		return nestedValue;
-	}, 2);
-}
-function toToolResult(value) {
-	if (value && typeof value === "object" && ("content" in value || "structuredContent" in value || "isError" in value)) {
-		const result = value;
-		if (!result.content) return {
-			...result,
-			content: [{
-				type: "text",
-				text: safeJsonStringify(result.structuredContent ?? null)
-			}]
-		};
-		return result;
-	}
-	return {
-		structuredContent: value && typeof value === "object" && !Array.isArray(value) ? value : { value },
-		content: [{
-			type: "text",
-			text: safeJsonStringify(value)
-		}]
-	};
-}
-function toToolError(error) {
-	return {
-		isError: true,
-		content: [{
-			type: "text",
-			text: error instanceof Error ? error.message : String(error)
-		}]
-	};
-}
-function jsonResource(uri, value) {
-	return { contents: [{
-		uri,
-		mimeType: "application/json",
-		text: safeJsonStringify(value)
-	}] };
-}
-
-//#endregion
-//#region src/server/crud-tools.ts
-const whereSchema = z.record(z.string(), z.unknown());
-const relationLoadSchema = z.record(z.string(), z.unknown());
-const findOptionsSchema = z.object({
-	where: whereSchema.optional(),
-	sort: z.record(z.string(), z.union([z.literal("asc"), z.literal("desc")])).optional(),
-	limit: z.number().int().positive().optional(),
-	page: z.number().int().positive().optional(),
-	offset: z.number().int().nonnegative().optional(),
-	with: relationLoadSchema.optional(),
-	columns: z.record(z.string(), z.boolean()).optional(),
-	locale: z.string().optional(),
-	includeDeleted: z.boolean().optional(),
-	stage: z.string().optional()
-}).passthrough();
-const countOptionsSchema = z.object({
-	where: whereSchema.optional(),
-	includeDeleted: z.boolean().optional()
-}).passthrough();
-const idSchema = z.union([z.string(), z.number()]);
-const getOptionsSchema = z.object({
-	id: idSchema,
-	with: relationLoadSchema.optional(),
-	columns: z.record(z.string(), z.boolean()).optional(),
-	locale: z.string().optional(),
-	includeDeleted: z.boolean().optional(),
-	stage: z.string().optional()
-}).passthrough();
-const createSchema = z.object({ data: recordSchema });
-const updateSchema = z.object({
-	id: idSchema,
-	data: recordSchema
-});
-const deleteSchema = z.object({ id: idSchema });
-const globalGetSchema = z.object({
-	with: relationLoadSchema.optional(),
-	columns: z.record(z.string(), z.boolean()).optional(),
-	locale: z.string().optional(),
-	stage: z.string().optional()
-}).passthrough();
-const globalUpdateSchema = z.object({
-	data: recordSchema,
-	with: relationLoadSchema.optional(),
-	columns: z.record(z.string(), z.boolean()).optional(),
-	locale: z.string().optional(),
-	stage: z.string().optional()
-}).passthrough();
-const COLLECTION_OPERATIONS = [
-	{
-		name: "list",
-		kind: "read",
-		description: (name) => `List ${name} records.`,
-		schema: findOptionsSchema,
-		execute: (crud, input, ctx, maxLimit) => crud.find({
-			...input,
-			limit: Math.min(input.limit ?? maxLimit, maxLimit)
-		}, ctx)
-	},
-	{
-		name: "count",
-		kind: "read",
-		description: (name) => `Count ${name} records.`,
-		schema: countOptionsSchema,
-		execute: (crud, input, ctx) => crud.count(input, ctx)
-	},
-	{
-		name: "get",
-		kind: "read",
-		description: (name) => `Get one ${name} record by id.`,
-		schema: getOptionsSchema,
-		execute: (crud, input, ctx) => {
-			const { id, ...options } = input;
-			return crud.findOne({
-				...options,
-				where: { id }
-			}, ctx);
-		}
-	},
-	{
-		name: "create",
-		kind: "write",
-		description: (name) => `Create a ${name} record.`,
-		schema: createSchema,
-		execute: (crud, input, ctx) => crud.create(input.data, ctx)
-	},
-	{
-		name: "update",
-		kind: "write",
-		description: (name) => `Update a ${name} record by id.`,
-		schema: updateSchema,
-		execute: (crud, input, ctx) => crud.updateById({
-			id: input.id,
-			data: input.data
-		}, ctx)
-	},
-	{
-		name: "delete",
-		kind: "delete",
-		description: (name) => `Delete a ${name} record by id.`,
-		schema: deleteSchema,
-		execute: (crud, input, ctx) => crud.deleteById({ id: input.id }, ctx)
-	}
-];
-const GLOBAL_OPERATIONS = [{
-	name: "get",
-	kind: "read",
-	description: (name) => `Get the ${name} global.`,
-	schema: globalGetSchema,
-	execute: (crud, input, ctx) => crud.get(input, ctx)
-}, {
-	name: "update",
-	kind: "write",
-	description: (name) => `Update the ${name} global.`,
-	schema: globalUpdateSchema,
-	execute: (crud, input, ctx) => {
-		const { data, ...options } = input;
-		return crud.update(data, ctx, options);
-	}
-}];
-function collectionOperationSchema(operationName, collection, policy) {
-	if (operationName === "create") return z.object({ data: createCollectionDataSchema(collection, "create", policy) });
-	if (operationName === "update") return z.object({
-		id: idSchema,
-		data: createCollectionDataSchema(collection, "update", policy)
-	});
-	return COLLECTION_OPERATIONS.find((operation) => operation.name === operationName)?.schema ?? recordSchema;
-}
-function globalOperationSchema(operationName, global, policy) {
-	if (operationName === "update") return globalUpdateSchema.extend({ data: createGlobalDataSchema(global, policy) });
-	return GLOBAL_OPERATIONS.find((operation) => operation.name === operationName)?.schema ?? recordSchema;
-}
-function filterOperationInput(operationName, input, policy) {
-	if ((operationName === "create" || operationName === "update") && input && typeof input === "object" && "data" in input) return {
-		...input,
-		data: filterRecordFields(input.data, policy)
-	};
-	return input;
-}
-async function questpieAllows(scope, kind, name, operation) {
-	if (scope.accessMode === "system") return true;
-	const ctx = await scope.getContext();
-	const crudContext = {
-		db: ctx.db ?? scope.app.db,
-		session: ctx.session,
-		locale: ctx.locale,
-		accessMode: scope.accessMode,
-		stage: ctx.stage
-	};
-	if (kind === "collection") {
-		const collection = scope.app.getCollections()[name];
-		const schema$1 = await introspectCollection(collection, crudContext, scope.app);
-		if (!schema$1.access.visible) return false;
-		const mappedOperation$1 = operation === "write" ? "update" : operation;
-		const result$1 = schema$1.access.operations[mappedOperation$1];
-		return !!result$1 && result$1.allowed !== false;
-	}
-	const global = scope.app.getGlobals()[name];
-	const schema = await introspectGlobal(global, crudContext, scope.app);
-	if (!schema.access.visible) return false;
-	const mappedOperation = operation === "write" ? "update" : "read";
-	const result = schema.access.operations[mappedOperation];
-	return !!result && result.allowed !== false;
-}
-async function shouldRegister(scope, policy, kind, entityName, operationName, operationKind) {
-	if (!policy.expose) return false;
-	const ctx = await scope.getContext();
-	if (!await evaluateMcpRule(operationRule(policy, operationName) ?? operationRule(policy, operationKind === "write" ? "update" : operationKind), {
-		transport: scope.transport,
-		accessMode: scope.accessMode,
-		ctx
-	})) return false;
-	if (!scopeGateAllows(scopesFromContext(ctx), requiredScopesForOperation(policy, kind, entityName, operationName, operationKind))) return false;
-	return questpieAllows(scope, kind, entityName, operationKind);
-}
-async function registerCrudTools(server, scope, config) {
-	const maxLimit = config.crud?.maxLimit ?? 100;
-	const collections = scope.app.getCollections();
-	const globals = scope.app.getGlobals();
-	for (const name of Object.keys(collections)) {
-		const collection = collections[name];
-		const policy = resolveEntityPolicy(config, "collection", name, scope.transport);
-		const crud = scope.app.collections[name];
-		for (const operation of COLLECTION_OPERATIONS) {
-			if (!await shouldRegister(scope, policy, "collection", name, operation.name, operation.kind)) continue;
-			server.registerTool(`collections.${name}.${operation.name}`, {
-				description: policy.description ?? operation.description(name),
-				inputSchema: collectionOperationSchema(operation.name, collection, policy),
-				annotations: {
-					readOnlyHint: operation.kind === "read",
-					destructiveHint: operation.kind === "delete",
-					idempotentHint: operation.name === "update" || operation.name === "delete"
-				}
-			}, async (input) => {
-				try {
-					const ctx = await scope.getContext();
-					if (!await evaluateMcpRule(operationRule(policy, operation.name) ?? operationRule(policy, operation.kind === "write" ? "update" : operation.kind), {
-						transport: scope.transport,
-						accessMode: scope.accessMode,
-						ctx
-					})) throw new Error("MCP access denied");
-					if (!scopeGateAllows(scopesFromContext(ctx), requiredScopesForOperation(policy, "collection", name, operation.name, operation.kind))) throw new Error("MCP access denied");
-					const nextInput = filterOperationInput(operation.name, input, policy);
-					return toToolResult(filterCrudResultFields(await operation.execute(crud, nextInput, ctx, maxLimit), policy));
-				} catch (error) {
-					return toToolError(error);
-				}
-			});
-		}
-	}
-	for (const name of Object.keys(globals)) {
-		const global = globals[name];
-		const policy = resolveEntityPolicy(config, "global", name, scope.transport);
-		const crud = scope.app.globals[name];
-		for (const operation of GLOBAL_OPERATIONS) {
-			if (!await shouldRegister(scope, policy, "global", name, operation.name, operation.kind)) continue;
-			server.registerTool(`globals.${name}.${operation.name}`, {
-				description: policy.description ?? operation.description(name),
-				inputSchema: globalOperationSchema(operation.name, global, policy),
-				annotations: {
-					readOnlyHint: operation.kind === "read",
-					idempotentHint: operation.name === "update"
-				}
-			}, async (input) => {
-				try {
-					const ctx = await scope.getContext();
-					if (!await evaluateMcpRule(operationRule(policy, operation.name) ?? operationRule(policy, operation.kind === "write" ? "update" : operation.kind), {
-						transport: scope.transport,
-						accessMode: scope.accessMode,
-						ctx
-					})) throw new Error("MCP access denied");
-					if (!scopeGateAllows(scopesFromContext(ctx), requiredScopesForOperation(policy, "global", name, operation.name, operation.kind))) throw new Error("MCP access denied");
-					const nextInput = filterOperationInput(operation.name, input, policy);
-					return toToolResult(filterCrudResultFields(await operation.execute(crud, nextInput, ctx), policy));
-				} catch (error) {
-					return toToolError(error);
-				}
-			});
-		}
-	}
-}
-
-//#endregion
-//#region src/server/mcp-tool.ts
-var McpToolBuilder = class {
-	constructor(name, config) {
-		this.name = name;
-		this.config = config;
-	}
-	handler(handler) {
-		return Object.freeze({
-			__brand: "mcpTool",
-			name: this.name,
-			config: this.config,
-			handler
-		});
-	}
-};
-/**
-* Define a custom MCP tool, contributed by a module the same way collections and
-* routes are (via `ModuleDefinition.mcpTools`). `mcpTool(name, config).handler(fn)`
-* returns a frozen, branded {@link McpToolDefinition}; the CRUD/route tools the
-* framework auto-generates are the same shape.
-*
-* `config` mirrors the MCP tool contract: `inputSchema`/`outputSchema` (Zod),
-* `title`/`description`/`annotations` for discovery, plus the two QUESTPIE
-* authorization hooks that compose exactly like the built-in tools:
-* - `access` — an {@link McpAccessRule} run against the caller's transport /
-*   accessMode / session (and, for an OAuth caller, its scopes). Same RBAC-style
-*   gate the CRUD tools use.
-* - `scopes` — the OAuth scopes an `oauth` caller must hold ({@link McpToolConfig.scopes}).
-*   Custom tools have no default scope mapping (unlike CRUD, there is no
-*   resource/operation to derive one from), so an omitted value requires no
-*   scope. The shipped scope gate ({@link scopeGateAllows}) enforces this at both
-*   `tools/list` (hidden) and `tools/call` (denied); `system`/`user` callers
-*   carry no scopes and skip it, so the effective bound is always `scopes ∩ RBAC`.
-*
-* @example
-* ```ts
-* export const ping = mcpTool("ops.ping", {
-*   description: "Health probe",
-*   inputSchema: z.object({}),
-*   scopes: "routes:ops/ping:invoke", // only OAuth callers holding this scope
-* }).handler(async () => ({ content: [{ type: "text", text: "pong" }] }));
-* ```
-*/
-function mcpTool(name, config = {}) {
-	return new McpToolBuilder(name, config);
-}
-function isMcpTool(value) {
-	return !!value && typeof value === "object" && value.__brand === "mcpTool" && typeof value.handler === "function";
-}
-
-//#endregion
-//#region src/server/custom-tools.ts
-async function registerCustomTools(server, scope) {
-	const tools = scope.app.state?.mcpTools ?? {};
-	for (const [key, tool] of Object.entries(tools)) {
-		if (!isMcpTool(tool)) continue;
-		const ctx = await scope.getContext();
-		if (!await evaluateMcpRule(tool.config.access, {
-			transport: scope.transport,
-			accessMode: scope.accessMode,
-			ctx
-		})) continue;
-		const requiredScopes = normalizeRequiredScopes(tool.config.scopes);
-		if (!scopeGateAllows(scopesFromContext(ctx), requiredScopes)) continue;
-		server.registerTool(tool.name || key, {
-			title: tool.config.title,
-			description: tool.config.description,
-			inputSchema: jsonSchemaCompatibleSchema(tool.config.inputSchema),
-			outputSchema: jsonSchemaCompatibleSchema(tool.config.outputSchema),
-			annotations: tool.config.annotations,
-			_meta: tool.config._meta
-		}, async (input) => {
-			try {
-				const callCtx = await scope.getContext();
-				if (!await evaluateMcpRule(tool.config.access, {
-					transport: scope.transport,
-					accessMode: scope.accessMode,
-					ctx: callCtx
-				})) throw new Error("MCP access denied");
-				if (!scopeGateAllows(scopesFromContext(callCtx), requiredScopes)) throw new Error("MCP access denied");
-				const parsedInput = tool.config.inputSchema ? await tool.config.inputSchema.parseAsync(input) : input;
-				return tool.handler({
-					input: parsedInput,
-					ctx: callCtx,
-					transport: scope.transport,
-					accessMode: scope.accessMode,
-					request: scope.request
-				});
-			} catch (error) {
-				return toToolError(error);
-			}
-		});
-	}
-}
-
-//#endregion
-//#region src/server/resources.ts
-async function collectionSchema(scope, name) {
-	const ctx = await scope.getContext();
-	const collection = scope.app.getCollections()[name];
-	return introspectCollection(collection, {
-		db: ctx.db ?? scope.app.db,
-		session: ctx.session,
-		locale: ctx.locale,
-		accessMode: scope.accessMode,
-		stage: ctx.stage
-	}, scope.app);
-}
-async function globalSchema(scope, name) {
-	const ctx = await scope.getContext();
-	const global = scope.app.getGlobals()[name];
-	return introspectGlobal(global, {
-		db: ctx.db ?? scope.app.db,
-		session: ctx.session,
-		locale: ctx.locale,
-		accessMode: scope.accessMode,
-		stage: ctx.stage
-	}, scope.app);
-}
-async function visibleCollections(scope, config) {
-	const entries = [];
-	for (const name of Object.keys(scope.app.getCollections())) {
-		const policy = resolveEntityPolicy(config, "collection", name, scope.transport);
-		if (!policy.expose) continue;
-		const ctx = await scope.getContext();
-		if (!await evaluateMcpRule(operationRule(policy, "read") ?? operationRule(policy, "list"), {
-			transport: scope.transport,
-			accessMode: scope.accessMode,
-			ctx
-		})) continue;
-		const schema = await collectionSchema(scope, name);
-		if (scope.accessMode === "system" || schema.access.visible && schema.access.operations.read.allowed !== false) entries.push(filterEntitySchemaFields(schema, policy));
-	}
-	return entries;
-}
-async function visibleGlobals(scope, config) {
-	const entries = [];
-	for (const name of Object.keys(scope.app.getGlobals())) {
-		const policy = resolveEntityPolicy(config, "global", name, scope.transport);
-		if (!policy.expose) continue;
-		const ctx = await scope.getContext();
-		if (!await evaluateMcpRule(operationRule(policy, "read") ?? operationRule(policy, "get"), {
-			transport: scope.transport,
-			accessMode: scope.accessMode,
-			ctx
-		})) continue;
-		const schema = await globalSchema(scope, name);
-		if (scope.accessMode === "system" || schema.access.visible && schema.access.operations.read.allowed !== false) entries.push(filterEntitySchemaFields(schema, policy));
-	}
-	return entries;
-}
-function routeToolInputSchema(route$1) {
-	if (!isJsonRoute(route$1.definition)) return void 0;
-	const params = route$1.params ?? [];
-	if (params.length === 0) return route$1.definition.schema;
-	const shape = {};
-	for (const param of params) shape[param] = z.string();
-	return z.object({
-		params: z.object(shape),
-		input: route$1.definition.schema
-	});
-}
-async function routeCatalog(scope, config) {
-	if (config.resources?.routes === false) return [];
-	if (config.routes?.exposeAnnotated === false) return [];
-	const ctx = await scope.getContext();
-	const services = extractAppServices(scope.app, {
-		db: ctx.db ?? scope.app.db,
-		session: ctx.session,
-		locale: ctx.locale
-	});
-	const routes = [];
-	for (const route$1 of introspectRoutes(scope.app)) {
-		if (!isJsonRoute(route$1.definition)) continue;
-		if (route$1.meta?.mcp?.expose !== true) continue;
-		const policy = resolveEntityPolicy(config, "route", route$1.key, scope.transport);
-		if (!policy.expose) continue;
-		if (!await evaluateMcpRule(operationRule(policy, "execute") ?? operationRule(policy, "read"), {
-			transport: scope.transport,
-			accessMode: scope.accessMode,
-			ctx
-		})) continue;
-		const params = Object.fromEntries((route$1.params ?? []).map((param) => [param, ""]));
-		if (!await evaluateRouteAccess(route$1.definition.access, {
-			...services,
-			locale: ctx.locale,
-			request: scope.request,
-			params
-		})) continue;
-		routes.push({
-			key: route$1.key,
-			path: route$1.path,
-			methods: route$1.methods,
-			mode: route$1.mode,
-			params: route$1.params,
-			meta: route$1.meta,
-			hasInputSchema: isJsonRoute(route$1.definition),
-			hasOutputSchema: isJsonRoute(route$1.definition) && !!route$1.definition.outputSchema,
-			inputSchema: toJsonSchema(route$1.definition.schema),
-			outputSchema: toJsonSchema(route$1.definition.outputSchema),
-			toolInputSchema: toJsonSchema(routeToolInputSchema(route$1))
-		});
-	}
-	return routes;
-}
-function resourceEntry(uri, name, description) {
-	return {
-		uri,
-		name,
-		mimeType: "application/json",
-		description
-	};
-}
-function registerSchemaResources(server, scope, config) {
-	if (config.resources?.schemas === false) return;
-	server.registerResource("questpie-schema-collections", "questpie://schema/collections", {
-		title: "QUESTPIE collections schema",
-		mimeType: "application/json"
-	}, async (uri) => jsonResource(uri.toString(), await visibleCollections(scope, config)));
-	server.registerResource("questpie-schema-collection", new ResourceTemplate("questpie://schema/collections/{name}", {
-		list: async () => ({ resources: (await visibleCollections(scope, config)).map((schema) => resourceEntry(`questpie://schema/collections/${schema.name}`, `Collection ${schema.name}`, schema.description ? String(schema.description) : void 0)) }),
-		complete: { name: async (value) => (await visibleCollections(scope, config)).map((schema) => schema.name).filter((name) => name.startsWith(value)) }
-	}), {
-		title: "QUESTPIE collection schema",
-		mimeType: "application/json"
-	}, async (uri, variables) => {
-		const name = String(variables.name);
-		const schema = (await visibleCollections(scope, config)).find((item) => item.name === name);
-		if (!schema) throw new Error(`Collection ${name} is not exposed to MCP`);
-		return jsonResource(uri.toString(), schema);
-	});
-	server.registerResource("questpie-schema-globals", "questpie://schema/globals", {
-		title: "QUESTPIE globals schema",
-		mimeType: "application/json"
-	}, async (uri) => jsonResource(uri.toString(), await visibleGlobals(scope, config)));
-	server.registerResource("questpie-schema-global", new ResourceTemplate("questpie://schema/globals/{name}", {
-		list: async () => ({ resources: (await visibleGlobals(scope, config)).map((schema) => resourceEntry(`questpie://schema/globals/${schema.name}`, `Global ${schema.name}`, schema.description ? String(schema.description) : void 0)) }),
-		complete: { name: async (value) => (await visibleGlobals(scope, config)).map((schema) => schema.name).filter((name) => name.startsWith(value)) }
-	}), {
-		title: "QUESTPIE global schema",
-		mimeType: "application/json"
-	}, async (uri, variables) => {
-		const name = String(variables.name);
-		const schema = (await visibleGlobals(scope, config)).find((item) => item.name === name);
-		if (!schema) throw new Error(`Global ${name} is not exposed to MCP`);
-		return jsonResource(uri.toString(), schema);
-	});
-	server.registerResource("questpie-schema-routes", "questpie://schema/routes", {
-		title: "QUESTPIE route schema",
-		mimeType: "application/json"
-	}, async (uri) => jsonResource(uri.toString(), await routeCatalog(scope, config)));
-	server.registerResource("questpie-schema-route", new ResourceTemplate("questpie://schema/routes/{key}", {
-		list: async () => ({ resources: (await routeCatalog(scope, config)).map((route$1) => resourceEntry(`questpie://schema/routes/${encodeURIComponent(route$1.key)}`, `Route ${route$1.key}`, route$1.meta?.description)) }),
-		complete: { key: async (value) => (await routeCatalog(scope, config)).map((route$1) => route$1.key).filter((key) => key.startsWith(value)) }
-	}), {
-		title: "QUESTPIE route schema",
-		mimeType: "application/json"
-	}, async (uri, variables) => {
-		const key = decodeURIComponent(String(variables.key));
-		const route$1 = (await routeCatalog(scope, config)).find((item) => item.key === key);
-		if (!route$1) throw new Error(`Route ${key} is not exposed to MCP`);
-		return jsonResource(uri.toString(), route$1);
-	});
-}
-
-//#endregion
-//#region src/server/route-tools.ts
-function sanitizeRouteKey(key) {
-	return key.replace(/[:/[\].]+/g, ".").replace(/\.+/g, ".").replace(/^\./, "").replace(/\.$/, "");
-}
-function routeInputSchema(route$1) {
-	if (!isJsonRoute(route$1.definition)) return z.object({});
-	if (route$1.params.length === 0) return jsonSchemaCompatibleSchema(route$1.definition.schema) ?? z.object({});
-	const paramsShape = {};
-	for (const param of route$1.params) paramsShape[param] = z.string();
-	return z.object({
-		params: z.object(paramsShape),
-		input: jsonSchemaCompatibleSchema(route$1.definition.schema) ?? z.object({})
-	});
-}
-async function registerRouteTools(server, scope, config) {
-	if (config.routes?.exposeAnnotated === false) return;
-	for (const route$1 of introspectRoutes(scope.app)) {
-		const definition = route$1.definition;
-		if (!isJsonRoute(definition)) continue;
-		if (route$1.meta?.mcp?.expose !== true) continue;
-		const policy = resolveEntityPolicy(config, "route", route$1.key, scope.transport);
-		if (!policy.expose) continue;
-		const ctx = await scope.getContext();
-		if (!await evaluateMcpRule(operationRule(policy, "execute") ?? operationRule(policy, "read"), {
-			transport: scope.transport,
-			accessMode: scope.accessMode,
-			ctx
-		})) continue;
-		if (!scopeGateAllows(scopesFromContext(ctx), requiredScopesForOperation(policy, "route", route$1.key, "execute", "invoke"))) continue;
-		const name = route$1.meta.mcp.name ?? `routes.${sanitizeRouteKey(route$1.key)}`;
-		const inputSchema = routeInputSchema(route$1);
-		server.registerTool(name, {
-			title: route$1.meta.mcp.title ?? route$1.meta.title,
-			description: route$1.meta.mcp.description ?? route$1.meta.description,
-			inputSchema,
-			outputSchema: jsonSchemaCompatibleSchema(definition.outputSchema),
-			annotations: route$1.meta.mcp.annotations
-		}, async (input) => {
-			try {
-				const routeCtx = await scope.getContext();
-				if (!await evaluateMcpRule(operationRule(policy, "execute") ?? operationRule(policy, "read"), {
-					transport: scope.transport,
-					accessMode: scope.accessMode,
-					ctx: routeCtx
-				})) throw new Error("MCP access denied");
-				if (!scopeGateAllows(scopesFromContext(routeCtx), requiredScopesForOperation(policy, "route", route$1.key, "execute", "invoke"))) throw new Error("MCP access denied");
-				const routeInput = route$1.params.length > 0 ? input.input : input;
-				const params = route$1.params.length > 0 ? input.params : {};
-				return toToolResult(await executeJsonRoute(scope.app, definition, routeInput, routeCtx, scope.request ?? new Request("http://questpie.local/mcp"), params));
-			} catch (error) {
-				return toToolError(error);
-			}
-		});
-	}
-}
-
-//#endregion
-//#region src/server/create-server.ts
-async function createMcpServer(app, options = {}) {
-	const config = resolveMcpConfig(app, options.config);
-	const transport = options.transport ?? "http";
-	const accessMode = transport === "http" ? "user" : options.accessMode ?? defaultAccessModeForTransport(config, transport);
-	const scope = createRuntimeScope(app, {
-		...options,
-		transport,
-		accessMode,
-		config
-	});
-	const server = new McpServer({
-		name: config.name ?? "questpie",
-		version: config.version ?? "0.0.0"
-	}, { capabilities: {
-		tools: {},
-		resources: {}
-	} });
-	await registerCrudTools(server, scope, config);
-	await registerRouteTools(server, scope, config);
-	registerSchemaResources(server, scope, config);
-	await registerCustomTools(server, scope);
-	return server;
-}
-
-//#endregion
-export { requiredScopesForOperation as a, normalizeRequiredScopes as i, mcpTool as n, scopeGateAllows as o, defaultOperationScope as r, scopesFromContext as s, createMcpServer as t };