@classytic/arc 2.18.5 → 2.20.0

package/dist/{mcpPlugin-D1wuRD2c.mjs → mcpPlugin-CuW6L_uD.mjs}

@@ -1,14 +1,15 @@
 import { p as isArcError, t as ArcError } from "./errors-DkO8Nk6-.mjs";
-import { t as BaseController } from "./BaseController-Dy6EQHjM.mjs";
-import { N as normalizePermissionResult } from "./permissions-BPB1xqGf.mjs";
-import { i as resolvePipelineSteps, t as resolveActionPermission } from "./actionPermissions-h7DYDNMg.mjs";
+import { c as getOrgId, g as getUserId } from "./types-bHblZ9YN.mjs";
+import { t as BaseController } from "./BaseController-D-MHZ27_.mjs";
+import { N as normalizePermissionResult } from "./permissions-CgbOLJZG.mjs";
 import { t as executePipeline } from "./pipe-BOLmGIxa.mjs";
-import { t as pluralize } from "./pluralize-DccFV9R7.mjs";
-import { i as shouldRejectAdditionalProperties, r as schemaIRToZodShape, t as normalizeSchemaIR } from "./schemaIR-D1MJwqmp.mjs";
-import { n as validateAggregations } from "./validate-CRcaWzp2.mjs";
-import { n as executeAggregation } from "./buildHandler-B0qvAguf.mjs";
-import { isHttpError, toErrorContract } from "@classytic/repo-core/errors";
+import { i as resolvePipelineSteps, t as resolveActionPermission } from "./actionPermissions-C9RMiIpc.mjs";
+import { n as validateAggregations } from "./validate-C2mGgSXg.mjs";
+import { n as executeAggregation } from "./buildHandler-D_2ULWxZ.mjs";
+import { t as pluralize } from "./pluralize-BhrgwZb9.mjs";
+import { r as shouldRejectAdditionalProperties, t as normalizeSchemaIR } from "./schemaIR-ajetw3Fv.mjs";
 import { createHash, randomUUID } from "node:crypto";
+import { isHttpError, toErrorContract } from "@classytic/repo-core/errors";
 import fp from "fastify-plugin";
 import { z } from "zod";
 //#region src/integrations/mcp/createMcpServer.ts
@@ -264,7 +265,7 @@ function buildRequestContext(input, auth, operation, policyFilters, scopeOverrid
 * them explicitly here rather than asking the parser at runtime — Arc must
 * not import MongoKit internals just to know what an operator looks like.
 */
-const OPERATOR_SUFFIXES = new Set([
+const OPERATOR_SUFFIXES = /* @__PURE__ */ new Set([
 	"eq",
 	"ne",
 	"gt",
@@ -671,12 +672,20 @@ function resolveCrudDescription(override, meta) {
 * // shape = { name: z.string(), price: z.number() }
 * ```
 */
+/**
+* Projection (`select`) field — reused by the list shape AND the single-entity
+* `get` shape. The controller honors `select` on `getById` identically to list
+* (both flow through `QueryResolver.resolve`), so exposing it on `get` gives an
+* MCP agent the same field-projection it already has on list.
+*/
+const PROJECTION_FIELD = z.string().optional().describe("Comma-separated field list to project (e.g. 'name,price'). Prefix with '-' to exclude (e.g. '-description').");
 const PAGINATION_SHAPE = {
-	page: z.number().int().min(1).optional().describe("Page number (1-based)"),
+	page: z.number().int().min(1).optional().describe("Page number (1-based). Ignored when `cursor` is set."),
 	limit: z.number().int().min(1).max(100).optional().describe("Items per page (max 100)"),
+	cursor: z.string().optional().describe("Opaque keyset cursor from a previous page's `next`. Pass it to fetch the following page; when set, `page` is ignored (cursor/keyset pagination — stable under concurrent inserts)."),
 	sort: z.string().optional().describe("Sort field, prefix with - for descending"),
 	search: z.string().optional().describe("Full-text search query"),
-	select: z.string().optional().describe("Comma-separated field list to project (e.g. 'name,price'). Prefix with '-' to exclude (e.g. '-description')."),
+	select: PROJECTION_FIELD,
 	populate: z.string().optional().describe("Comma-separated relation paths to hydrate (e.g. 'supplier,category'). Follows Mongoose populate syntax when the adapter is MongoKit.")
 };
 /**
@@ -688,7 +697,7 @@ function fieldRulesToZod(fieldRules, options = {}) {
 	const { mode = "create", hiddenFields = [], readonlyFields = [], extraHideFields = [] } = options;
 	if (mode === "list") return buildListShape(fieldRules, options);
 	if (!fieldRules) return {};
-	const allHidden = new Set([...hiddenFields, ...extraHideFields]);
+	const allHidden = /* @__PURE__ */ new Set([...hiddenFields, ...extraHideFields]);
 	const allReadonly = new Set(readonlyFields);
 	const shape = {};
 	for (const [name, rule] of Object.entries(fieldRules)) {
@@ -738,7 +747,7 @@ function typeToZod(type) {
 	}
 }
 /** Operators that apply to numeric/date fields */
-const COMPARISON_OPS = new Set([
+const COMPARISON_OPS = /* @__PURE__ */ new Set([
 	"gt",
 	"gte",
 	"lt",
@@ -761,7 +770,7 @@ function opDescription(op, fieldName) {
 /** Build list/query shape with filterable fields, operators, and pagination */
 function buildListShape(fieldRules, options) {
 	const { filterableFields = [], hiddenFields = [], extraHideFields = [], allowedOperators } = options;
-	const allHidden = new Set([...hiddenFields, ...extraHideFields]);
+	const allHidden = /* @__PURE__ */ new Set([...hiddenFields, ...extraHideFields]);
 	const shape = { ...PAGINATION_SHAPE };
 	if (!fieldRules) return shape;
 	for (const name of filterableFields) {
@@ -917,6 +926,61 @@ async function forwardResponse(reply, response) {
 	reply.send(await response.text());
 }
 //#endregion
+//#region src/core/schemaIRZod.ts
+/**
+* Schema IR → Zod adapter — the MCP-facing half of [schemaIR.ts](./schemaIR.ts).
+*
+* Lives in its OWN module (not schemaIR.ts) because it is the only part that
+* needs zod at runtime. schemaIR.ts is statically imported by
+* `createActionRouter`, which every actions-bearing resource loads at boot —
+* a top-level `import { z } from "zod"` there made zod a de-facto REQUIRED
+* dependency for any host using `actions:`, despite zod being an optional
+* peer (boot crash when absent, even with plain-JSON-Schema action bodies
+* and no MCP). Only MCP code imports this module, and the MCP integration
+* already hard-requires zod (the SDK does), so the top-level import is
+* correct HERE and a bug THERE.
+*/
+/**
+* Emit a flat Zod shape from the IR. The MCP SDK wraps the returned record
+* in `z.object()` internally, so we return the bare shape (same contract
+* as `ToolDefinition.inputSchema`).
+*
+* `additionalProperties: false` is honored at the MCP handler layer rather
+* than baked into the Zod shape — the SDK's input validation happens before
+* the handler runs, and flat shapes can't express `.strict()` mode.
+* `shouldRejectAdditionalProperties(ir)` (schemaIR.ts) returns the flag so
+* callers can gate their handler on it.
+*/
+function schemaIRToZodShape(ir) {
+	const requiredSet = new Set(ir.required);
+	const result = {};
+	for (const [name, prop] of Object.entries(ir.properties)) {
+		const desc = typeof prop.description === "string" && prop.description.length > 0 ? prop.description : name;
+		const base = jsonSchemaPropToZod(prop);
+		result[name] = requiredSet.has(name) ? base.describe(desc) : base.optional().describe(desc);
+	}
+	return result;
+}
+/**
+* Convert a single JSON Schema property to a Zod type. Understands enum,
+* numeric/integer/boolean/array/object, and falls back to string for
+* unrecognized types (matches MCP's "strings for opaque fields" convention).
+*
+* Internal — use `schemaIRToZodShape` which wires this up with required/optional
+* + description handling.
+*/
+function jsonSchemaPropToZod(schema) {
+	if (Array.isArray(schema.enum) && schema.enum.length > 0) return z.enum(schema.enum);
+	switch (typeof schema.type === "string" ? schema.type : "string") {
+		case "number":
+		case "integer": return z.number();
+		case "boolean": return z.boolean();
+		case "array": return z.array(z.unknown());
+		case "object": return z.record(z.string(), z.unknown());
+		default: return z.string();
+	}
+}
+//#endregion
 //#region src/integrations/mcp/action-tools.ts
 /**
 * Convert an action's `schema` field into a Zod shape for MCP input.
@@ -942,7 +1006,7 @@ function convertActionSchemaToZod(raw) {
 */
 function createActionToolHandler(actionName, handler, permissions, resourceName, _resourcePermissions, rawSchema, idLess = false) {
 	const ir = rawSchema ? normalizeSchemaIR(rawSchema) : void 0;
-	const allowedKeys = (ir ? shouldRejectAdditionalProperties(ir) : false) && ir ? new Set([...idLess ? [] : ["id"], ...Object.keys(ir.properties)]) : void 0;
+	const allowedKeys = (ir ? shouldRejectAdditionalProperties(ir) : false) && ir ? /* @__PURE__ */ new Set([...idLess ? [] : ["id"], ...Object.keys(ir.properties)]) : void 0;
 	return async (input, ctx) => {
 		const session = ctx.session;
 		if (allowedKeys) {
@@ -1239,7 +1303,10 @@ function buildInputSchema(op, fieldRules, opts) {
 			mode: "list",
 			...opts
 		});
-		case "get": return getIdShape();
+		case "get": return {
+			...getIdShape(),
+			select: PROJECTION_FIELD
+		};
 		case "create":
 			if (!fieldRules && opts.adapterBodies?.createBody) {
 				const shape = jsonSchemaToZodShape(opts.adapterBodies.createBody, "create");
@@ -1424,14 +1491,17 @@ function createCustomRouteHandler(route, controller, hasId, options) {
 			const reqCtx = buildRequestContext(input, session, operationKindForRoute(route.method, hasId), permResult?.filters, permResult?.scope);
 			if (typeof route.handler === "function") {
 				const fn = route.handler;
-				if (pipelineSteps.length > 0) return toCallToolResult(await executePipeline(pipelineSteps, {
-					...reqCtx,
-					resource: resourceName,
-					operation: operationName
-				}, async (ctx) => {
-					const raw = await fn(ctx);
-					return raw !== null && typeof raw === "object" && "data" in raw ? raw : { data: raw };
-				}, operationName));
+				if (pipelineSteps.length > 0) {
+					const pipeCtx = {
+						...reqCtx,
+						resource: resourceName,
+						operation: operationName
+					};
+					return toCallToolResult(await executePipeline(pipelineSteps, pipeCtx, async (ctx) => {
+						const raw = await fn(ctx);
+						return raw !== null && typeof raw === "object" && "data" in raw ? raw : { data: raw };
+					}, operationName));
+				}
 				const out = await fn(reqCtx);
 				return toCallToolResult(out !== null && typeof out === "object" && "data" in out ? out : { data: out });
 			}
@@ -1452,13 +1522,7 @@ function createCustomRouteHandler(route, controller, hasId, options) {
 			};
 			return toCallToolResult(await method(reqCtx));
 		} catch (err) {
-			return {
-				content: [{
-					type: "text",
-					text: `Error: ${err instanceof Error ? err.message : String(err)}`
-				}],
-				isError: true
-			};
+			return toCallToolError(err instanceof Error ? err : new Error(String(err)));
 		}
 	};
 }
@@ -1472,13 +1536,7 @@ function createMcpHandlerPassthrough(mcpHandler) {
 		try {
 			return await mcpHandler(input);
 		} catch (err) {
-			return {
-				content: [{
-					type: "text",
-					text: `Error: ${err instanceof Error ? err.message : String(err)}`
-				}],
-				isError: true
-			};
+			return toCallToolError(err instanceof Error ? err : new Error(String(err)));
 		}
 	};
 }
@@ -1655,14 +1713,18 @@ function resourceToTools(resource, config = {}) {
 	if (resource.aggregations && Object.keys(resource.aggregations).length > 0) {
 		const repoForAgg = resource.controller?.repository;
 		const buildOptionsFromSession = (session) => {
-			const s = session;
+			const auth = session ?? null;
+			const scope = buildScope(auth);
 			const out = {};
-			const orgId = s?.scope?.organizationId;
+			const orgId = getOrgId(scope);
 			if (orgId) out.organizationId = orgId;
-			const userId = s?.scope?.userId ?? s?.user?.id;
+			const userId = getUserId(scope);
 			if (userId) out.userId = userId;
-			if (s?.user) out.user = s.user;
-			if (s?.requestId) out.requestId = s.requestId;
+			if (auth?.userId) out.user = {
+				id: auth.userId,
+				roles: auth.roles ?? [],
+				orgRoles: auth.orgRoles ?? []
+			};
 			return out;
 		};
 		tools.push(...buildAggregationTools({
@@ -1713,13 +1775,29 @@ function registerSchemaResources(server, resources, overrides) {
 				name: r.name,
 				displayName: r.displayName,
 				operations: getOps(r, overrides?.[r.name]?.operations),
-				fields: r.schemaOptions?.fieldRules ?? {},
+				fields: visibleFieldRules(r.schemaOptions?.fieldRules),
 				filterableFields: schemaOpts?.filterableFields ?? [],
 				presets: r._appliedPresets ?? []
 			}, null, 2)
 		}] }));
 	}
 }
+/**
+* Strip `hidden: true` / `systemManaged: true` entries before serializing —
+* the schema-discovery resource must not re-expose exactly what
+* `fieldRulesToZod` strips from tool input schemas (tenant keys, internal
+* scoring fields, ...). Same visibility rule, one discovery surface.
+*/
+function visibleFieldRules(fieldRules) {
+	if (!fieldRules) return {};
+	const out = {};
+	for (const [name, rule] of Object.entries(fieldRules)) {
+		const flags = rule ?? {};
+		if (flags.hidden === true || flags.systemManaged === true) continue;
+		out[name] = rule;
+	}
+	return out;
+}
 function getOps(r, override) {
 	let ops = [
 		"list",
@@ -1901,10 +1979,16 @@ const mcpPluginImpl = async (fastify, options) => {
 		const more = allTools.length > 5 ? ` (+${allTools.length - 5} more)` : "";
 		fastify.log.warn(`[arc/mcp] MCP server registered at "${prefix}" with auth DISABLED. Anyone who can reach this URL has full access to ${allTools.length} tools across ${enabledResources.length} resources: ${toolList}${more}. Pass \`auth: betterAuthInstance\` or \`auth: async (headers) => ...\` to gate access. Safe only for stdio transports, local development, or explicitly-public read-only APIs.`);
 	}
-	fastify.get(`${prefix}/health`, async (_request, reply) => {
-		reply.send({
+	fastify.get(`${prefix}/health`, async (request, reply) => {
+		const liveness = {
 			status: "ok",
-			mode: stateful ? "stateful" : "stateless",
+			mode: stateful ? "stateful" : "stateless"
+		};
+		if (options.auth) {
+			if (!await resolveMcpAuth(request.headers, options.auth)) return reply.send(liveness);
+		}
+		reply.send({
+			...liveness,
 			tools: allTools.length,
 			resources: enabledResources.length,
 			toolNames: allTools.map((t) => t.name),
@@ -1991,9 +2075,22 @@ function registerStatelessRoutes(fastify, prefix, options, createServer, Transpo
 	});
 }
 function registerStatefulRoutes(fastify, prefix, options, cache, createServer, Transport) {
-	/** Check if the requesting principal owns the session */
+	/**
+	* Check if the requesting principal owns the session. FAIL-CLOSED:
+	*
+	*   - `authResult === null` (failed/absent credentials) NEVER owns a
+	*     session — pre-2.20 this returned `true`, so an unauthenticated
+	*     caller with a leaked `Mcp-Session-Id` could attach to the victim's
+	*     SSE stream, terminate the session, and (via the auth-snapshot
+	*     refresh) wipe `entry.auth` to null — after which ANY principal
+	*     passed ownership and took over the session.
+	*   - `entry.auth === null` under configured auth is equally a deny:
+	*     POST 401s before creating a session, so an auth-mode session always
+	*     has an owner snapshot; a missing one means corrupted state.
+	*/
 	function isSessionOwner(entry, authResult) {
-		if (!options.auth || !entry.auth || !authResult) return true;
+		if (!options.auth) return true;
+		if (!authResult || !entry.auth) return false;
 		const prev = entry.auth;
 		return prev.userId === authResult.userId && prev.organizationId === authResult.organizationId && prev.clientId === authResult.clientId;
 	}
@@ -2053,6 +2150,7 @@ function registerStatefulRoutes(fastify, prefix, options, cache, createServer, T
 		if (!entry) return reply.code(403).send({ error: "Unauthorized" });
 		if (options.auth) {
 			const authResult = await resolveMcpAuth(request.headers, options.auth);
+			if (!authResult) return reply.code(401).send({ error: "Unauthorized" });
 			if (!isSessionOwner(entry, authResult)) return reply.code(403).send({ error: "Unauthorized" });
 			entry.auth = authResult;
 			entry.authRef.current = authResult;
@@ -2067,6 +2165,7 @@ function registerStatefulRoutes(fastify, prefix, options, cache, createServer, T
 		if (!entry) return reply.code(204).send();
 		if (options.auth) {
 			const authResult = await resolveMcpAuth(request.headers, options.auth);
+			if (!authResult) return reply.code(401).send({ error: "Unauthorized" });
 			if (!isSessionOwner(entry, authResult)) return reply.code(403).send({ error: "Unauthorized" });
 			entry.auth = authResult;
 			entry.authRef.current = authResult;

package/dist/middleware/index.d.mts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, L as RequestWithExtras, Q as MiddlewareConfig } from "../index-CHNQIhcb.mjs";
+import { I as MiddlewareHandler, L as RequestWithExtras, Q as MiddlewareConfig } from "../index-_--GyzcO.mjs";
 import { RouteHandlerMethod } from "fastify";
 
 //#region src/middleware/middleware.d.ts

package/dist/middleware/index.mjs

@@ -1,4 +1,4 @@
-import { t as CRUD_OPERATIONS } from "../constants-gaEeMlz-.mjs";
+import { t as CRUD_OPERATIONS } from "../constants-DNre0wRg.mjs";
 import { t as multipartBody } from "../multipartBody-CHEQSZ6G.mjs";
 //#region src/middleware/middleware.ts
 /**