@questpie/mcp 3.15.2 → 3.17.0

package/dist/{index-Cxta5KOn.d.mts → index-DlBFWTIg.d.mts}

@@ -1,23 +1,24 @@
-import * as questpie0 from "questpie";
+import * as questpie1 from "questpie";
 import { RouteDefinition, RouteParamsFromKey } from "questpie/types";
 
 //#region src/server/modules/mcp/routes/mcp.d.ts
-declare const _default$4: questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+declare const _default$4: questpie1.RawRouteDefinition<questpie1.JsonRouteParams>;
 //#endregion
 //#region src/server/modules/mcp/routes/mcp.delete.d.ts
-declare const _default$3: questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+declare const _default$3: questpie1.RawRouteDefinition<questpie1.JsonRouteParams>;
 //#endregion
 //#region src/server/modules/mcp/routes/mcp.get.d.ts
-declare const _default$2: questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+declare const _default$2: questpie1.RawRouteDefinition<questpie1.JsonRouteParams>;
 //#endregion
 //#region src/server/modules/mcp/routes/mcp.options.d.ts
-declare const _default$1: questpie0.RawRouteDefinition<questpie0.JsonRouteParams>;
+declare const _default$1: questpie1.RawRouteDefinition<questpie1.JsonRouteParams>;
 //#endregion
 //#region src/server/modules/mcp/plugin.d.ts
-declare const _default: questpie0.CodegenPlugin;
+declare const _default: questpie1.CodegenPlugin;
 //#endregion
 //#region src/server/modules/mcp/.generated/module.d.ts
 type McpCollections = Record<never, never>;
+type McpChannels = Record<never, never>;
 type McpGlobals = Record<never, never>;
 type McpJobs = Record<never, never>;
 type McpRoutes = {
@@ -36,23 +37,27 @@ type McpRoutes = {
 };
 type McpFieldTypes = Record<never, never>;
 type McpMcpTools = Record<never, never>;
-type McpModule = {
-  name: "questpie-mcp";
-  routes: McpRoutes;
-  collections: McpCollections;
-  globals: McpGlobals;
-  jobs: McpJobs;
-  fieldTypes: McpFieldTypes;
-  mcpTools: McpMcpTools;
-  messages: Record<never, never>;
-  services: Record<never, never>;
-  emails: Record<never, never>;
-  migrations: readonly unknown[];
-  seeds: readonly unknown[];
-  plugin: typeof _default;
-};
 //#endregion
 //#region src/server/modules/mcp/index.d.ts
-declare const mcpModule: McpModule;
+type McpModule = typeof mcpModule;
+declare const mcpModule: {
+  readonly oauthScopeCatalogs: {
+    readonly mcp: questpie1.OAuthScopeCatalogContributor;
+  };
+  readonly name: "questpie-mcp";
+  readonly routes: McpRoutes;
+  readonly collections: McpCollections;
+  readonly channels: McpChannels;
+  readonly globals: McpGlobals;
+  readonly jobs: McpJobs;
+  readonly fieldTypes: McpFieldTypes;
+  readonly mcpTools: McpMcpTools;
+  readonly messages: Record<never, never>;
+  readonly services: Record<never, never>;
+  readonly emails: Record<never, never>;
+  readonly migrations: readonly unknown[];
+  readonly seeds: readonly unknown[];
+  readonly plugin: typeof _default;
+};
 //#endregion
-export { McpModule as n, mcpModule as t };
+export { mcpModule as n, McpModule as t };

package/dist/index.d.mts

@@ -1,63 +1,31 @@
-import { t as mcpModule } from "./index-Cxta5KOn.mjs";
-import { _ as McpToolDefinition, a as McpAccessRuleContext, c as McpCrudDefaults, d as McpHttpConfig, f as McpRequiredScopes, g as McpToolConfig, h as McpStdioConfig, i as McpAccessRule, l as McpEntityPolicy, m as McpRoutesConfig, n as QuestpieApp, o as McpConfig, p as McpResourcesConfig, r as McpAccessMode, s as McpCrudConfig, t as startStdioServer, u as McpExecutionOptions, v as McpToolHandlerArgs, y as McpTransportKind } from "./stdio-t_9rKayH.mjs";
+import { n as mcpModule } from "./index-DlBFWTIg.mjs";
+import { A as McpWorkloadAuthorizer, B as WorkloadMcpServerOptions, C as McpToolConfig, D as McpWorkloadAuditEvent, E as McpTransportKind, F as McpWorkloadHandoffInput, I as McpWorkloadRequirement, L as McpWorkloadToolFacts, M as McpWorkloadContextBindingInput, N as McpWorkloadExecutionControl, O as McpWorkloadAuthorization, P as McpWorkloadHandoff, R as McpWorkloadToolKind, S as McpStdioConfig, T as McpToolHandlerArgs, _ as McpProgrammaticToolResult, a as McpAccessRule, b as McpResourcesConfig, c as McpCrudConfig, d as McpExecutionDiagnosticEvent, f as McpExecutionLimits, g as McpProgrammaticTool, h as McpProgrammaticRequestOptions, i as McpAccessMode, j as McpWorkloadContextBinder, k as McpWorkloadAuthorizationRequest, l as McpEntityPolicy, m as McpHttpConfig, n as QuestpieApp, o as McpAccessRuleContext, p as McpExecutionOptions, r as mcpPublicErrorCode, s as McpConfig, t as startStdioServer, u as McpExecutionConfig, v as McpPublicErrorCode, w as McpToolDefinition, x as McpRoutesConfig, y as McpRequiredScopes, z as McpWorkloadToolPort } from "./stdio-YoM70-42.mjs";
 import { t as mcpPlugin } from "./plugin-CMR-wkeP.mjs";
-import { AppContext, RequestContext, ScopeOperationKind, defaultOperationScope } from "questpie";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AppContext, Questpie, RequestContext, ScopeOperationKind, defaultOperationScope, introspectRoutes } from "questpie";
 import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 //#region src/server/create-server.d.ts
 declare function createMcpServer(app: QuestpieApp, options?: McpExecutionOptions): Promise<McpServer>;
+declare function createWorkloadMcpServer(app: QuestpieApp, options: WorkloadMcpServerOptions): Promise<McpServer>;
 //#endregion
-//#region src/server/config.d.ts
-declare function mcpConfig<TConfig extends McpConfig>(config: TConfig): TConfig;
-//#endregion
-//#region src/server/mcp-tool.d.ts
-declare class McpToolBuilder<TInputSchema extends z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny> {
-  private readonly name;
-  private readonly config;
-  constructor(name: string, config: McpToolConfig<TInputSchema, TOutputSchema>);
-  handler(handler: (args: McpToolHandlerArgs<z.infer<TInputSchema>>) => ReturnType<McpToolDefinition<TInputSchema, TOutputSchema>["handler"]>): McpToolDefinition<TInputSchema, TOutputSchema>;
-}
+//#region src/server/workload-tool-port.d.ts
 /**
- * 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" }] }));
- * ```
+ * Programmatic, custom-tool-only workload port. This is deliberately not a
+ * general in-process MCP client: CRUD, routes, resources, and transport
+ * authority are absent by construction.
  */
-declare function mcpTool<TInputSchema extends z.ZodTypeAny = z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny = z.ZodTypeAny>(name: string, config?: McpToolConfig<TInputSchema, TOutputSchema>): McpToolBuilder<TInputSchema, TOutputSchema>;
+declare function createWorkloadMcpToolPort(app: QuestpieApp, options: WorkloadMcpServerOptions): McpWorkloadToolPort;
 //#endregion
 //#region src/server/policy.d.ts
 type EntityKind = "collection" | "global" | "route";
 interface ResolvedMcpPolicy {
   expose: boolean;
-  read?: boolean | McpAccessRule;
-  write?: boolean | McpAccessRule;
-  delete?: boolean | McpAccessRule;
   operations: Record<string, boolean | McpAccessRule>;
   requiredScopes?: McpRequiredScopes;
   operationScopes: Record<string, McpRequiredScopes>;
+  workload?: McpWorkloadRequirement;
+  operationWorkloads: Record<string, McpWorkloadRequirement>;
   fields?: {
     include?: string[];
     exclude?: string[];
@@ -85,7 +53,7 @@ declare function requiredScopesForOperation(policy: ResolvedMcpPolicy, kind: Ent
  * is not OAuth-authenticated. Reads `ctx.principal` (populated by MO6): only the
  * `oauth` principal carries `scopes`; `user` and `system` do not.
  */
-declare function scopesFromContext(ctx: AppContext & Partial<RequestContext>): string[] | undefined;
+declare function scopesFromContext(ctx: AppContext & Partial<RequestContext>): string[] | undefined | null;
 /**
  * The OAuth scope gate (MO8, extended by the umbrella model — LOCKED #2).
  *
@@ -117,6 +85,82 @@ declare function scopesFromContext(ctx: AppContext & Partial<RequestContext>): s
  * the collection/global `.access()` RBAC independently, and all must pass. The
  * effective `oauth` permission is therefore `scopes ∩ RBAC`.
  */
-declare function scopeGateAllows(heldScopes: string[] | undefined, required: string[]): boolean;
+declare function scopeGateAllows(heldScopes: string[] | undefined | null, required: string[]): boolean;
+//#endregion
+//#region src/server/catalog.d.ts
+interface ResolvedMcpEntityCatalogEntry {
+  policy: ResolvedMcpPolicy;
+  operations: readonly string[];
+}
+interface ResolvedMcpRouteCatalogEntry extends ResolvedMcpEntityCatalogEntry {
+  route: ReturnType<typeof introspectRoutes>[number];
+  toolName: string;
+}
+interface ResolvedMcpCustomToolCatalogEntry {
+  tool: McpToolDefinition;
+}
+interface ResolvedMcpCatalog {
+  collections: ReadonlyMap<string, ResolvedMcpEntityCatalogEntry>;
+  globals: ReadonlyMap<string, ResolvedMcpEntityCatalogEntry>;
+  routes: ReadonlyMap<string, ResolvedMcpRouteCatalogEntry>;
+  customTools: ReadonlyMap<string, ResolvedMcpCustomToolCatalogEntry>;
+  resources: {
+    collections: ReadonlySet<string>;
+    globals: ReadonlySet<string>;
+    routes: ReadonlySet<string>;
+  };
+  oauth: {
+    scopes: readonly string[];
+    scopesSupported: readonly string[];
+  };
+}
+type CatalogApp = Pick<Questpie<any>, "getCollections" | "getGlobals"> & {
+  state?: {
+    mcpTools?: Record<string, unknown>;
+  } & Record<string, unknown>;
+  config?: Questpie<any>["config"];
+};
+declare function resolveMcpCatalog(app: CatalogApp, config: McpConfig): ResolvedMcpCatalog;
+//#endregion
+//#region src/server/config.d.ts
+declare function mcpConfig<TConfig extends McpConfig>(config: TConfig): TConfig;
+//#endregion
+//#region src/server/mcp-tool.d.ts
+declare class McpToolBuilder<TInputSchema extends z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny> {
+  private readonly name;
+  private readonly config;
+  constructor(name: string, config: McpToolConfig<TInputSchema, TOutputSchema>);
+  handler(handler: (args: McpToolHandlerArgs<z.infer<TInputSchema>>) => ReturnType<McpToolDefinition<TInputSchema, TOutputSchema>["handler"]>): McpToolDefinition<TInputSchema, TOutputSchema>;
+}
+/**
+ * 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` — required explicit opt-in and 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 it is required; use `false` for
+ *   an explicit no-OAuth-scope policy. 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", {
+ *   access: ({ session }) => !!session,
+ *   description: "Health probe",
+ *   inputSchema: z.object({}),
+ *   scopes: "routes:ops/ping:invoke", // only OAuth callers holding this scope
+ * }).handler(async () => ({ content: [{ type: "text", text: "pong" }] }));
+ * ```
+ */
+declare function mcpTool<TInputSchema extends z.ZodTypeAny = z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny = z.ZodTypeAny>(name: string, config: McpToolConfig<TInputSchema, TOutputSchema>): McpToolBuilder<TInputSchema, TOutputSchema>;
 //#endregion
-export { type McpAccessMode, type McpAccessRule, type McpAccessRuleContext, type McpConfig, type McpCrudConfig, type McpCrudDefaults, type McpEntityPolicy, type McpExecutionOptions, type McpHttpConfig, type McpRequiredScopes, type McpResourcesConfig, type McpRoutesConfig, type McpStdioConfig, type McpToolConfig, type McpToolDefinition, type McpToolHandlerArgs, type McpTransportKind, type ScopeOperationKind, createMcpServer, mcpModule as default, mcpModule, defaultOperationScope, mcpConfig, mcpPlugin, mcpTool, normalizeRequiredScopes, requiredScopesForOperation, scopeGateAllows, scopesFromContext, startStdioServer };
+export { type McpAccessMode, type McpAccessRule, type McpAccessRuleContext, type McpConfig, type McpCrudConfig, type McpEntityPolicy, type McpExecutionConfig, type McpExecutionDiagnosticEvent, type McpExecutionLimits, type McpExecutionOptions, type McpHttpConfig, type McpProgrammaticRequestOptions, type McpProgrammaticTool, type McpProgrammaticToolResult, type McpPublicErrorCode, type McpRequiredScopes, type McpResourcesConfig, type McpRoutesConfig, type McpStdioConfig, type McpToolConfig, type McpToolDefinition, type McpToolHandlerArgs, type McpTransportKind, type McpWorkloadAuditEvent, type McpWorkloadAuthorization, type McpWorkloadAuthorizationRequest, type McpWorkloadAuthorizer, type McpWorkloadContextBinder, type McpWorkloadContextBindingInput, type McpWorkloadExecutionControl, type McpWorkloadHandoff, type McpWorkloadHandoffInput, type McpWorkloadRequirement, type McpWorkloadToolFacts, type McpWorkloadToolKind, type McpWorkloadToolPort, type ResolvedMcpCatalog, type ResolvedMcpCustomToolCatalogEntry, type ResolvedMcpEntityCatalogEntry, type ResolvedMcpRouteCatalogEntry, type ScopeOperationKind, type WorkloadMcpServerOptions, createMcpServer, createWorkloadMcpServer, createWorkloadMcpToolPort, mcpModule as default, mcpModule, defaultOperationScope, mcpConfig, mcpPlugin, mcpPublicErrorCode, mcpTool, normalizeRequiredScopes, requiredScopesForOperation, resolveMcpCatalog, scopeGateAllows, scopesFromContext, startStdioServer };

package/dist/index.mjs

@@ -1,12 +1,99 @@
-import { a as requiredScopesForOperation, i as normalizeRequiredScopes, n as mcpTool, o as scopeGateAllows, r as defaultOperationScope, s as scopesFromContext, t as createMcpServer } from "./create-server-DIvtVlma.mjs";
-import { n as mcp_default, t as mcpModule } from "./mcp-snyVygDQ.mjs";
-import { t as mcpPlugin } from "./plugin-BJ6gELRj.mjs";
-import { t as startStdioServer } from "./stdio-qyQFVEyU.mjs";
+import { S as scopesFromContext, _ as resolveMcpCatalog, a as customToolWorkloadIdentity, b as requiredScopesForOperation, c as createWorkloadMcpBoundary, f as McpAccessDeniedError, g as toMcpToolError, h as mcpPublicErrorCode, i as customToolDescriptor, l as createRuntimeScope, m as assertBoundedMcpValue, n as createWorkloadMcpServer, o as executeCustomToolCall, p as McpPublicError, r as customToolAllows, s as authorizeWorkload, t as createMcpServer, u as createWorkloadMcpRelease, v as defaultOperationScope, w as mcpTool, x as scopeGateAllows, y as normalizeRequiredScopes } from "./create-server-CEWFf041.mjs";
+import { n as mcp_default, t as mcpModule } from "./mcp-CuJEhynp.mjs";
+import { t as mcpPlugin } from "./plugin-BZQe1pji.mjs";
+import { t as startStdioServer } from "./stdio-CgIPiPUb.mjs";
+import { randomUUID } from "node:crypto";
 
+//#region src/server/workload-tool-port.ts
+const defaultSignal = () => new AbortController().signal;
+/**
+* Programmatic, custom-tool-only workload port. This is deliberately not a
+* general in-process MCP client: CRUD, routes, resources, and transport
+* authority are absent by construction.
+*/
+function createWorkloadMcpToolPort(app, options) {
+	const workload = createWorkloadMcpBoundary(options);
+	const release = createWorkloadMcpRelease(app, options.config);
+	const scope = createRuntimeScope(app, {
+		transport: "workload",
+		accessMode: "user",
+		config: release.config
+	}, release.execution, workload);
+	return Object.freeze({
+		async listCustomTools(request = {}) {
+			const tools = [];
+			const controller = new AbortController();
+			let timedOut = false;
+			const cancel = () => controller.abort(request.signal?.reason);
+			if (request.signal?.aborted) cancel();
+			else request.signal?.addEventListener("abort", cancel, { once: true });
+			const timer = setTimeout(() => {
+				timedOut = true;
+				controller.abort(/* @__PURE__ */ new Error("MCP list deadline exceeded"));
+			}, release.execution.limits.timeoutMs);
+			const extra = {
+				signal: controller.signal,
+				requestId: request.requestId ?? randomUUID()
+			};
+			try {
+				if (controller.signal.aborted) throw new McpPublicError(timedOut ? "timeout" : "cancelled");
+				for (const [toolName, { tool }] of release.catalog.customTools) {
+					if (!tool.config.workload) continue;
+					const identity = customToolWorkloadIdentity(toolName, tool);
+					try {
+						let workloadAuthorization;
+						const descriptor = await scope.execution.execute({
+							operation: "tools/list",
+							transport: "workload",
+							accessMode: "user",
+							input: { name: toolName },
+							extra,
+							authorize: async (control) => {
+								workloadAuthorization = await authorizeWorkload(workload, "discovery", identity, tool.config.workload, control);
+								if (!workloadAuthorization || !await customToolAllows(scope, tool, workloadAuthorization.context)) throw new McpAccessDeniedError();
+								return workloadAuthorization.context;
+							},
+							concurrencyKey: () => workloadAuthorization?.concurrencyKey,
+							invoke: async () => customToolDescriptor(toolName, tool)
+						});
+						tools.push(descriptor);
+					} catch (error) {
+						if (mcpPublicErrorCode(error) === "access_denied") continue;
+						if (timedOut && mcpPublicErrorCode(error) === "cancelled") throw new McpPublicError("timeout");
+						throw error;
+					}
+				}
+				assertBoundedMcpValue({ tools }, {
+					maxBytes: release.execution.limits.maxOutputBytes,
+					maxValueDepth: release.execution.limits.maxOutputDepth,
+					maxValueNodes: release.execution.limits.maxValueNodes
+				}, "output_too_large");
+				return { tools };
+			} finally {
+				clearTimeout(timer);
+				request.signal?.removeEventListener("abort", cancel);
+			}
+		},
+		async callCustomTool(request) {
+			const entry = typeof request?.name === "string" && request.name.length <= 256 ? release.catalog.customTools.get(request.name) : void 0;
+			if (!entry?.tool.config.workload) return toMcpToolError(new McpPublicError("access_denied"));
+			try {
+				return await executeCustomToolCall(scope, request.name, entry.tool, request.input, {
+					signal: request.signal ?? defaultSignal(),
+					requestId: request.requestId ?? randomUUID()
+				});
+			} catch (error) {
+				return toMcpToolError(error);
+			}
+		}
+	});
+}
+
+//#endregion
 //#region src/server/config.ts
 function mcpConfig(config) {
 	return config;
 }
 
 //#endregion
-export { createMcpServer, mcp_default as default, defaultOperationScope, mcpConfig, mcpModule, mcpPlugin, mcpTool, normalizeRequiredScopes, requiredScopesForOperation, scopeGateAllows, scopesFromContext, startStdioServer };
+export { createMcpServer, createWorkloadMcpServer, createWorkloadMcpToolPort, mcp_default as default, defaultOperationScope, mcpConfig, mcpModule, mcpPlugin, mcpPublicErrorCode, mcpTool, normalizeRequiredScopes, requiredScopesForOperation, resolveMcpCatalog, scopeGateAllows, scopesFromContext, startStdioServer };