@fruggr/zendesk-mcp-server 3.3.1 → 3.5.0

package/README.md

@@ -224,13 +224,16 @@ clients, MCP client wiring, CORS and what stays the operator's job:
 ## Tool surface
 
 Tools are grouped into namespaces: **Tickets**, **Help Center**, **Users &
-Organizations**, **Search**, and **Requests** — the end-user surface, which is
-opt-in and covered under [End-user mode](#end-user-mode). The server registers
+Organizations**, **Search**, **Connector preferences** — this server's own
+per-user settings, such as SLA alert thresholds, never written to Zendesk — and
+**Requests** — the end-user surface, which is opt-in and covered under
+[End-user mode](#end-user-mode). The server registers
 them in one of three modes, so you can trade granularity against context budget:
 
 - **`all`**: every operation as its own tool, for clients with good tool selection;
 - **`namespace`** (default): one proxy tool per namespace, a balanced middle ground;
-- **`single`**: a single `zendesk` tool, for models with limited tool slots.
+- **`single`**: a single `zendesk` tool, for models with limited tool slots (the
+  connector's own preferences keep their `connector_preferences` proxy beside it).
 
 Proxies take `{ "operation": "<tool_name>", "params": { … } }` and validate
 `params` through the original schema. `--namespace`, `--tool` and `--read-only`

package/dist/THIRD-PARTY-NOTICES.md

@@ -5198,7 +5198,7 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
-## zod@4.6.5
+## zod@4.6.7
 
 License: MIT
 

package/dist/{http-BYYYoQaK.js → http-DDdso3Av.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { _ as __commonJSMin, a as verifyBearerToken, b as __toESM, c as zendeskGet, f as getOAuthUrls, h as errnoCode, i as WebStandardStreamableHTTPServerTransport, l as REQUEST_TIMEOUT_MS, m as createStartupError, o as OAuthError, p as STARTUP_DOCS, r as silentLogger, s as OAuthErrorCode, t as createMcpServer, u as deadlineSignal, v as __exportAll, y as __require } from "./index.js";
-import { d as escapeHtml, l as requestedScope, n as configDir, o as generateCodeChallenge, s as generateCodeVerifier, u as supportedScopes } from "./token-persistence-BUHh23BM.js";
+import { A as __commonJSMin, C as isLegacyRequest, D as STARTUP_DOCS, E as OAuthErrorCode, M as __require, N as __toESM, O as createStartupError, S as createMcpHandler, T as OAuthError, _ as deadlineSignal, a as watchGrantAlerts, b as DEFAULT_MAX_REQUEST_BODY_SIZE, c as configDir, g as REQUEST_TIMEOUT_MS, h as zendeskGet, i as defaultServerFactory, j as __exportAll, k as errnoCode, m as silentLogger, n as listenedUris, o as startSlaRuntime, p as createRequestStateCodec, r as createServerCaches, t as createListenFeed, w as verifyBearerToken, x as WebStandardStreamableHTTPServerTransport, y as getOAuthUrls } from "./index.js";
+import { a as supportedScopes, i as requestedScope, n as generateCodeVerifier, o as escapeHtml, t as generateCodeChallenge } from "./pkce-DE_v9NQy.js";
 import * as util$1 from "node:util";
 import { format, inspect } from "node:util";
 import * as crypto$2 from "node:crypto";
@@ -667,6 +667,185 @@ var NodeStreamableHTTPServerTransport = class {
 		this._webStandardTransport.closeStandaloneSSEStream();
 	}
 };
+/**
+* The rejection {@linkcode toWebRequest} produces for a body over the size
+* limit, recognisable by `name` and `status` without matching message text.
+*/
+var RequestBodyTooLargeError = class extends Error {
+	status = 413;
+	constructor(maxBytes) {
+		super(`Payload Too Large: Request body must not exceed ${maxBytes} bytes`);
+		this.name = "RequestBodyTooLargeError";
+	}
+};
+function resolveMaxRequestBodySize(value) {
+	if (value === void 0) return DEFAULT_MAX_REQUEST_BODY_SIZE;
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new RangeError(`maxRequestBodySize must be a positive number of bytes, got ${String(value)}`);
+	return value;
+}
+/**
+* Adapts a web-standard MCP handler (`handler.fetch`) to a Node.js
+* `(req, res, parsedBody?)` request handler. The returned function converts the
+* Node request to a web-standard `Request`, calls `handler.fetch`, then writes
+* the `Response` back to `res` (honoring write backpressure for streamed SSE
+* responses).
+*
+* `req.auth` is forwarded as the handler's pass-through `authInfo`. A function
+* third argument (Express's `next`) is ignored, never treated as a body.
+*
+* Pass `{ onerror }` to observe the adapter-level error fallback (request
+* conversion / `handler.fetch` throw) before the `500` response is written.
+*/
+function toNodeHandler(handler, opts) {
+	const maxRequestBodySize = resolveMaxRequestBodySize(opts?.maxRequestBodySize);
+	return async (req, res, parsedBody) => {
+		if (typeof parsedBody === "function") parsedBody = void 0;
+		let finished = false;
+		const abort = new AbortController();
+		res.on("close", () => {
+			if (!finished) abort.abort();
+		});
+		if (res.destroyed === true) abort.abort();
+		let response;
+		try {
+			const request = await toWebRequest(req, parsedBody, {
+				signal: abort.signal,
+				maxRequestBodySize
+			});
+			response = await handler.fetch(request, {
+				...req.auth !== void 0 && { authInfo: req.auth },
+				...parsedBody !== void 0 && { parsedBody }
+			});
+		} catch (error) {
+			if (error instanceof RequestBodyTooLargeError) response = Response.json({
+				jsonrpc: "2.0",
+				error: {
+					code: -32e3,
+					message: error.message
+				},
+				id: null
+			}, {
+				status: 413,
+				headers: { connection: "close" }
+			});
+			else {
+				try {
+					opts?.onerror?.(error instanceof Error ? error : new Error(String(error)));
+				} catch {}
+				response = internalServerErrorResponse(echoableRequestId(parsedBody));
+			}
+		}
+		const headers = {};
+		for (const [name, value] of response.headers) headers[name] = value;
+		res.writeHead(response.status, headers);
+		if (response.body === null) {
+			finished = true;
+			res.end();
+			return;
+		}
+		let drainResolve;
+		const releaseDrainWait = () => {
+			drainResolve?.();
+			drainResolve = void 0;
+		};
+		res.on("drain", releaseDrainWait);
+		const closed = new Promise((resolve) => {
+			abort.signal.addEventListener("abort", () => resolve(), { once: true });
+		});
+		try {
+			for await (const chunk of response.body) {
+				if (abort.signal.aborted) break;
+				if (res.write(chunk) === false) await Promise.race([new Promise((resolve) => {
+					drainResolve = resolve;
+				}), closed]);
+			}
+		} catch {}
+		finished = true;
+		res.end();
+	};
+}
+function singleHeaderValue(value) {
+	return Array.isArray(value) ? value[0] : value;
+}
+/**
+* Convert a Node.js `IncomingMessage` (duck-typed — an Express `req` works) to
+* the web-standard `Request` that `handler.fetch()` and `isLegacyRequest()`
+* take. This is the conversion {@linkcode toNodeHandler} performs internally,
+* exported for hand-wired compositions:
+*
+* ```ts
+* const probe = await toWebRequest(req, req.body);
+* await ((await isLegacyRequest(probe)) ? legacy(req, res) : modern(req, res, req.body));
+* ```
+*
+* With no `parsedBody` the Node stream is read to completion (up to
+* `maxRequestBodySize`, 4 MiB by default — a longer body rejects with an error
+* carrying `name: 'RequestBodyTooLargeError'` and `status: 413`) — read the
+* body from the returned `Request` afterwards, not from `req`. When a body
+* parser already consumed the stream (`express.json()`), pass the parsed value
+* as `parsedBody` and nothing is read from `req`.
+*/
+async function toWebRequest(req, parsedBody, options) {
+	const maxRequestBodySize = resolveMaxRequestBodySize(options?.maxRequestBodySize);
+	const method = (req.method ?? "GET").toUpperCase();
+	const url = `http://${singleHeaderValue(req.headers["host"]) ?? singleHeaderValue(req.headers[":authority"]) ?? "localhost"}${req.url ?? "/"}`;
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(req.headers)) {
+		if (value === void 0 || name.startsWith(":")) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+		else headers.set(name, value);
+	}
+	let body;
+	if (method !== "GET" && method !== "HEAD") if (parsedBody === void 0) {
+		if (Number(singleHeaderValue(req.headers["content-length"])) > maxRequestBodySize) throw new RequestBodyTooLargeError(maxRequestBodySize);
+		const decoder = new TextDecoder();
+		let collected = "";
+		let received = 0;
+		for await (const chunk of req) {
+			received += typeof chunk === "string" ? new TextEncoder().encode(chunk).byteLength : chunk.byteLength;
+			if (received > maxRequestBodySize) throw new RequestBodyTooLargeError(maxRequestBodySize);
+			collected += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+		}
+		collected += decoder.decode();
+		if (collected.length > 0) body = collected;
+	} else {
+		const serialized = JSON.stringify(parsedBody);
+		headers.delete("content-encoding");
+		headers.delete("transfer-encoding");
+		if (serialized === void 0) headers.delete("content-length");
+		else {
+			body = serialized;
+			headers.set("content-length", String(new TextEncoder().encode(serialized).byteLength));
+		}
+	}
+	return new Request(url, {
+		method,
+		headers,
+		...options?.signal !== void 0 && { signal: options.signal },
+		...body !== void 0 && { body }
+	});
+}
+/**
+* The JSON-RPC id to echo on an adapter-built error response: the body's `id`
+* when the body is a single JSON-RPC request whose id is a string or number,
+* `null` otherwise.
+*/
+function echoableRequestId(body) {
+	if (body === null || typeof body !== "object" || Array.isArray(body)) return null;
+	const { method, id } = body;
+	if (typeof method !== "string") return null;
+	return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function internalServerErrorResponse(id) {
+	return Response.json({
+		jsonrpc: "2.0",
+		error: {
+			code: -32603,
+			message: "Internal server error"
+		},
+		id
+	}, { status: 500 });
+}
 //#endregion
 //#region node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/buffer_utils.js
 const encoder$1 = new TextEncoder();
@@ -2824,7 +3003,8 @@ const deriveKeySet = (master) => {
 			kid: kidFor(master, "at-rest"),
 			key: createSecretKey(derive(master, "at-rest"))
 		},
-		cookieKey: derive(master, "cookie").toString("base64url")
+		cookieKey: derive(master, "cookie").toString("base64url"),
+		requestState: derive(master, "request-state")
 	};
 };
 const deriveKeyRing = (raw) => {
@@ -36261,6 +36441,7 @@ const createAuthorizationServer = (options) => {
 	return {
 		issuer,
 		resource,
+		requestStateKey: ring[0].requestState,
 		protectedResourceMetadata: {
 			resource,
 			authorization_servers: [issuer],
@@ -36326,6 +36507,47 @@ const prepareAuthorizationServer = async (config, logger = silentLogger) => {
 	});
 };
 //#endregion
+//#region src/utils/grant-registry.ts
+const createGrantRegistry = ({ idleTimeoutMs, now = Date.now, onCloseError = () => void 0 }) => {
+	const slots = /* @__PURE__ */ new Map();
+	const drop = async (grantId, slot) => {
+		slots.delete(grantId);
+		try {
+			await slot.entry.close();
+		} catch (error) {
+			onCloseError(grantId, error);
+		}
+	};
+	return {
+		acquire: (grantId, subject, create) => {
+			const existing = slots.get(grantId);
+			if (existing && existing.subject !== subject) return void 0;
+			const slot = existing ?? {
+				subject,
+				entry: create(),
+				lastActivityAt: now()
+			};
+			slot.lastActivityAt = now();
+			slots.set(grantId, slot);
+			return slot.entry;
+		},
+		close: async (grantId, entry) => {
+			const slot = slots.get(grantId);
+			if (slot && (entry === void 0 || slot.entry === entry)) await drop(grantId, slot);
+		},
+		sweep: async () => {
+			const cutoff = now() - idleTimeoutMs;
+			for (const [grantId, slot] of [...slots]) if (slots.get(grantId) === slot && slot.lastActivityAt <= cutoff) await drop(grantId, slot);
+		},
+		closeAll: async () => {
+			await Promise.all([...slots].map(([grantId, slot]) => drop(grantId, slot)));
+		},
+		get size() {
+			return slots.size;
+		}
+	};
+};
+//#endregion
 //#region src/transports/http.ts
 const WILDCARD_HOSTS = /* @__PURE__ */ new Set([
 	"0.0.0.0",
@@ -36344,7 +36566,7 @@ const DEFAULT_BROWSER_MCP_CLIENT_ORIGINS = [
 	"https://grok.com"
 ];
 const CORS_ALLOWED_METHODS = "GET, POST, DELETE, OPTIONS";
-const CORS_ALLOWED_HEADERS = "Authorization, Content-Type, Accept, mcp-session-id, mcp-protocol-version, last-event-id";
+const CORS_ALLOWED_HEADERS = "Authorization, Content-Type, Accept, mcp-session-id, mcp-protocol-version, last-event-id, mcp-method, mcp-name";
 const CORS_EXPOSE_HEADERS = "mcp-session-id";
 const CORS_MAX_AGE = "600";
 const LOCALHOST_HOSTNAMES = /* @__PURE__ */ new Set([
@@ -36480,6 +36702,7 @@ const sendUnauthorized = (res, issuer) => {
 	const wwwAuthenticate = `Bearer resource_metadata="${issuer}${PROTECTED_RESOURCE_PATHS[0]}", error="invalid_token", error_description="${MISSING_BEARER_MESSAGE}"`;
 	sendJsonRpcError(res, 401, -32e3, MISSING_BEARER_MESSAGE, { "WWW-Authenticate": wwwAuthenticate });
 };
+const asNodeRequest = (req) => req;
 const MAX_BODY_BYTES = 4194304;
 const readJsonBody = (req, maxBodyBytes) => new Promise((resolve) => {
 	const chunks = [];
@@ -36548,24 +36771,29 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 	const buildAuthorizationServer = await prepareAuthorizationServer(config, logger);
 	let authorizationServer;
 	const sessions = /* @__PURE__ */ new Map();
+	const sla = startSlaRuntime(config);
 	const idleTimeoutMs = options.sessionIdleTimeoutMs ?? SESSION_IDLE_TIMEOUT_MS;
 	const maxBodyBytes = options.maxBodyBytes ?? 4194304;
-	const dispatchToSession = async (req, res, sessionId, token) => {
+	const serverFactory = options.serverFactory ?? defaultServerFactory;
+	const grants = createGrantRegistry({
+		idleTimeoutMs,
+		onCloseError: (grantId, err) => logger.warn("grant_close_failed", {
+			grantId,
+			error: err instanceof Error ? err.message : String(err)
+		})
+	});
+	const effectiveConfig = (token) => !config.readOnly && token.canWrite ? config : {
+		...config,
+		readOnly: true
+	};
+	const dispatchToSession = async (req, res, sessionId, token, body) => {
 		const session = sessions.get(sessionId);
 		if (!session || session.subject !== token.subject) return false;
 		if (session.canWrite && !token.canWrite) return false;
 		session.auth.zendeskToken = token.zendeskAccessToken;
 		session.auth.grantId = token.grantId;
 		session.lastActivityAt = Date.now();
-		const body = req.method === "POST" ? await readJsonBody(req, maxBodyBytes) : {
-			ok: true,
-			value: void 0
-		};
-		if (!body.ok) {
-			respondBodyError(req, res, body);
-			return true;
-		}
-		await session.transport.handleRequest(req, res, body.value);
+		await session.transport.handleRequest(req, res, body);
 		return true;
 	};
 	const openSession = async (req, res, body, token, as) => {
@@ -36573,11 +36801,21 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 			zendeskToken: token.zendeskAccessToken,
 			grantId: token.grantId
 		};
-		const canWrite = !config.readOnly && token.canWrite;
-		const server = createMcpServer(canWrite ? config : {
-			...config,
-			readOnly: true
-		}, () => auth.zendeskToken, logger, () => void as.revokeGrant(auth.grantId));
+		const sessionConfig = effectiveConfig(token);
+		const server = serverFactory({
+			config: sessionConfig,
+			getToken: () => auth.zendeskToken,
+			logger,
+			onUnauthorized: () => void as.revokeGrant(auth.grantId),
+			slaRuntime: sla.runtime,
+			requestStateCodec: createRequestStateCodec({
+				key: as.requestStateKey,
+				principal: () => auth.grantId
+			}),
+			notifyResourceUpdated: (uri) => {
+				server.server.sendResourceUpdated({ uri }).catch(() => void 0);
+			}
+		});
 		const transport = new NodeStreamableHTTPServerTransport({
 			sessionIdGenerator: () => randomUUID(),
 			onsessioninitialized: (newId) => {
@@ -36585,7 +36823,7 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 					transport,
 					auth,
 					subject: token.subject,
-					canWrite,
+					canWrite: !sessionConfig.readOnly,
 					lastActivityAt: Date.now(),
 					close: async () => {
 						await transport.close();
@@ -36600,24 +36838,121 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 		await server.connect(transport);
 		await transport.handleRequest(req, res, body);
 	};
-	const handleMcpRequest = async (req, res, as) => {
-		const token = await authenticate(req, as);
-		if (!token) {
+	const createGrantEntry = (token, as) => {
+		const { grantId } = token;
+		const auth = { zendeskToken: token.zendeskAccessToken };
+		const getToken = () => auth.zendeskToken;
+		const onUnauthorized = () => {
+			entry.revoked = true;
+			as.revokeGrant(grantId);
+		};
+		const caches = createServerCaches(config, getToken, onUnauthorized);
+		const requestStateCodec = createRequestStateCodec({
+			key: as.requestStateKey,
+			principal: () => grantId
+		});
+		const handler = createMcpHandler(({ authInfo }) => {
+			const verified = authInfo?.extra?.["verified"];
+			if (!verified) throw new Error("2026-07-28 request without a verified token");
+			return serverFactory({
+				config: effectiveConfig(verified),
+				getToken,
+				logger,
+				onUnauthorized,
+				caches,
+				requestStateCodec,
+				slaRuntime: sla.runtime,
+				alertPolling: "grant",
+				notifyResourceUpdated: (uri) => handler.notify.resourceUpdated(uri)
+			});
+		}, {
+			legacy: "reject",
+			onerror: (err) => logger.debug("mcp_request_rejected", { error: err.message })
+		});
+		const listens = createListenFeed();
+		const stopAlerts = watchGrantAlerts({
+			config,
+			getToken,
+			caches,
+			slaRuntime: sla.runtime,
+			logger,
+			listens,
+			notify: (uri) => handler.notify.resourceUpdated(uri),
+			onUnauthorized
+		});
+		const entry = {
+			auth,
+			revoked: false,
+			inFlight: 0,
+			listens,
+			handle: toNodeHandler(handler),
+			close: () => {
+				stopAlerts();
+				listens.closeAll();
+				return handler.close();
+			}
+		};
+		return entry;
+	};
+	const serveModern = async (req, res, body, token, as) => {
+		const entry = grants.acquire(token.grantId, token.subject, () => createGrantEntry(token, as));
+		if (!entry) {
 			sendUnauthorized(res, as.issuer);
 			return;
 		}
+		entry.auth.zendeskToken = token.zendeskAccessToken;
+		const request = asNodeRequest(req);
+		request.auth = {
+			token: "",
+			clientId: token.clientId,
+			scopes: [],
+			expiresAt: token.expiresAt,
+			extra: { verified: token }
+		};
+		const listened = listenedUris(body);
+		const counted = listened === void 0;
+		if (listened) {
+			const stream = Symbol("listen");
+			res.once("close", () => entry.listens.close(stream));
+			entry.listens.open(stream, listened);
+		}
+		if (counted) entry.inFlight += 1;
+		try {
+			await entry.handle(request, res, body);
+		} finally {
+			if (counted) entry.inFlight -= 1;
+			if (entry.revoked && entry.inFlight === 0) await grants.close(token.grantId, entry);
+		}
+	};
+	const serveLegacy = async (req, res, body, token, as) => {
 		const sessionId = typeof req.headers["mcp-session-id"] === "string" ? req.headers["mcp-session-id"] : void 0;
-		if (sessionId && await dispatchToSession(req, res, sessionId, token)) return;
+		if (sessionId && await dispatchToSession(req, res, sessionId, token, body)) return;
 		if (req.method !== "POST") {
 			sendJsonRpcError(res, 400, -32e3, "No active session; initialize via POST first.");
 			return;
 		}
-		const body = await readJsonBody(req, maxBodyBytes);
-		if (!body.ok) {
-			respondBodyError(req, res, body);
+		await openSession(req, res, body, token, as);
+	};
+	const handleMcpRequest = async (req, res, as) => {
+		const token = await authenticate(req, as);
+		if (!token) {
+			sendUnauthorized(res, as.issuer);
+			return;
+		}
+		let body;
+		if (req.method === "POST") {
+			const read = await readJsonBody(req, maxBodyBytes);
+			if (!read.ok) {
+				respondBodyError(req, res, read);
+				return;
+			}
+			body = read.value;
+		}
+		if (body !== void 0 && !await isLegacyRequest(await toWebRequest(asNodeRequest(req), body), body)) {
+			await serveModern(req, res, body, token, as);
 			return;
 		}
-		await openSession(req, res, body.value, token, as);
+		await serveLegacy(req, res, body, token, as);
 	};
 	const route = async (req, res, as) => {
 		const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
@@ -36686,6 +37021,7 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 				});
 			}
 		}
+		await grants.sweep();
 	};
 	const sweeper = setInterval(() => void sweepIdleSessions(), options.sweepIntervalMs ?? SESSION_SWEEP_INTERVAL_MS);
 	sweeper.unref();
@@ -36693,8 +37029,10 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 		port: boundPort,
 		close: async () => {
 			clearInterval(sweeper);
+			sla.stop();
 			await Promise.all([...sessions.values()].map((session) => session.close()));
 			sessions.clear();
+			await grants.closeAll();
 			httpServer.closeAllConnections();
 			await new Promise((resolve, reject) => {
 				httpServer.close((err) => err ? reject(err) : resolve());