@fruggr/zendesk-mcp-server 2.23.0 → 3.0.0

package/dist/http-BXXDmcaZ.js

@@ -0,0 +1,1383 @@
+#!/usr/bin/env node
+import { a as configDir, c as requestedScope, d as getOAuthUrls, f as silentLogger, i as deadlineSignal, l as supportedScopes, n as zendeskGet, o as generateCodeChallenge, s as generateCodeVerifier, t as createMcpServer, u as escapeHtml } from "./index.js";
+import { createHash, createPrivateKey, createSecretKey, hkdfSync, randomBytes, randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { NodeStreamableHTTPServerTransport } from "@modelcontextprotocol/node";
+import { CompactEncrypt, compactDecrypt, decodeProtectedHeader } from "jose";
+import Provider, { errors, interactionPolicy } from "oidc-provider";
+//#region src/auth/server/expiring-map.ts
+/**
+* An in-memory map whose entries lapse after their own TTL. Expired entries are
+* swept on every `set`, so the map stays bounded by what was set within the
+* longest TTL, with no timer to hold the process open.
+*/
+const createExpiringMap = () => {
+	const entries = /* @__PURE__ */ new Map();
+	const get = (key) => {
+		const entry = entries.get(key);
+		return entry && entry.expiresAt > Date.now() ? entry.value : void 0;
+	};
+	return {
+		set: (key, value, ttlMs) => {
+			const now = Date.now();
+			for (const [k, entry] of entries) if (entry.expiresAt <= now) entries.delete(k);
+			entries.set(key, {
+				value,
+				expiresAt: now + ttlMs
+			});
+		},
+		get,
+		/** Read and forget: a pending value is used at most once. */
+		take: (key) => {
+			const value = get(key);
+			entries.delete(key);
+			return value;
+		},
+		/** Live and not-yet-swept entries. */
+		size: () => entries.size
+	};
+};
+//#endregion
+//#region src/auth/server/consent.ts
+const hostOf = (uri) => {
+	try {
+		return new URL(uri).host;
+	} catch {
+		return uri;
+	}
+};
+const SCOPE_LABELS = {
+	read: "Read your Zendesk data",
+	write: "Create and change Zendesk data on your behalf"
+};
+/**
+* The MCP consent screen, shown once per client that is not trusted (DCR,
+* unknown CIMD, loopback redirects). Names the client, the scopes and where the
+* code goes, per the spec's UI requirements. Every interpolated value is
+* escaped: the client name comes from a document anyone can publish.
+*/
+const renderConsentPage = (view) => {
+	const name = escapeHtml(view.clientName ?? view.clientId);
+	const scopes = view.scopes.map((scope) => `<li>${escapeHtml(SCOPE_LABELS[scope] ?? scope)}</li>`).join("");
+	const action = `/interaction/${encodeURIComponent(view.uid)}`;
+	return [
+		"<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\">",
+		"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">",
+		"<title>Authorize access to Zendesk</title>",
+		"<style>body{font-family:system-ui,sans-serif;max-width:32rem;margin:3rem auto;padding:0 1rem;line-height:1.5}",
+		"code{word-break:break-all}button{font:inherit;padding:.5rem 1.25rem;margin-right:.5rem}</style>",
+		"</head><body>",
+		`<h1>Allow ${name} to use your Zendesk account?</h1>`,
+		`<p><strong>${name}</strong> is asking to act as you on <strong>${escapeHtml(view.subdomain)}.zendesk.com</strong>:</p>`,
+		`<ul>${scopes}</ul>`,
+		`<p>After you allow it, you are sent back to <strong>${escapeHtml(hostOf(view.redirectUri))}</strong>`,
+		` (<code>${escapeHtml(view.redirectUri)}</code>). Only continue if you started this connection yourself.</p>`,
+		`<p>Client id: <code>${escapeHtml(view.clientId)}</code></p>`,
+		`<form method="post" action="${action}/confirm" style="display:inline"><button type="submit">Allow</button></form>`,
+		`<form method="post" action="${action}/abort" style="display:inline"><button type="submit">Deny</button></form>`,
+		"</body></html>"
+	].join("");
+};
+/** Plain error page for a failed sign-in. ASCII message, escaped. */
+const renderErrorPage = (title, detail) => `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Sign-in failed</title></head><body><h1>${escapeHtml(title)}</h1><p>${escapeHtml(detail)}</p></body></html>`;
+//#endregion
+//#region src/auth/server/trusted-clients.ts
+/**
+* Which CIMD clients skip our consent screen, and the fetch shim applied to CIMD
+* documents. Policy and seed list: `docs/decisions/oauth-authorization-server.md`
+* ("Consent") and the #127 plan (§2).
+*/
+const DEFAULT_TRUSTED_CLIENTS = ["https://claude.ai/oauth/mcp-oauth-client-metadata", "https://chatgpt.com/oauth/client.json"];
+const trustedClientSet = (extra, includeDefaults) => /* @__PURE__ */ new Set([...includeDefaults ? DEFAULT_TRUSTED_CLIENTS : [], ...extra]);
+const IPV4_LOOPBACK = /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+const isLoopbackHost = (hostname) => hostname === "localhost" || hostname === "[::1]" || IPV4_LOOPBACK.test(hostname);
+const parse = (uri) => URL.canParse(uri) ? new URL(uri) : void 0;
+/** HTTPS and not loopback: a code sent there cannot land on the user's machine. */
+const isSkipEligibleRedirect = (uri) => {
+	const url = parse(uri);
+	return url !== void 0 && url.protocol === "https:" && !isLoopbackHost(url.hostname);
+};
+/**
+* Skip the consent screen only for an allowlisted client id, asking for a
+* redirect URI its own document lists, over HTTPS and off loopback. The
+* document is served from the client's own domain, so the code cannot be
+* diverted to an attacker.
+*/
+const canSkipConsent = (request, trusted) => trusted.has(request.clientId) && request.registeredRedirectUris.includes(request.redirectUri) && isSkipEligibleRedirect(request.redirectUri);
+const isLoopbackHttp = (uri) => {
+	const url = typeof uri === "string" ? parse(uri) : void 0;
+	return url !== void 0 && url.protocol === "http:" && isLoopbackHost(url.hostname);
+};
+/**
+* Some CIMD documents (Claude Code, Zed) list only loopback redirect URIs but do
+* not declare `application_type: native`, so oidc-provider matches the port
+* exactly and rejects the random port the client listens on (RFC 8252 §7.3 says
+* any port). Such a document is a native app by every other sign.
+*/
+const inferNativeApplication = (document) => {
+	if (!document || typeof document !== "object" || Array.isArray(document)) return document;
+	const { application_type: applicationType, redirect_uris: redirectUris } = document;
+	const allLoopback = Array.isArray(redirectUris) && redirectUris.length > 0 && redirectUris.every(isLoopbackHttp);
+	return applicationType === void 0 && allLoopback ? {
+		...document,
+		application_type: "native"
+	} : document;
+};
+const MAX_INSPECTED_BYTES = 16384;
+const readCapped = async (response) => {
+	const reader = response.body?.getReader();
+	if (!reader) return /* @__PURE__ */ new Uint8Array();
+	const chunks = [];
+	let total = 0;
+	while (total <= MAX_INSPECTED_BYTES) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+		total += value.length;
+	}
+	await reader.cancel().catch(() => void 0);
+	return Buffer.concat(chunks);
+};
+/**
+* Wrap oidc-provider's `fetch` so CIMD documents go through
+* `inferNativeApplication`. The request options are passed through untouched:
+* they carry the library's SSRF-guarded dispatcher, timeout and redirect policy.
+* Anything that is not a client document (a JWKS, an error) is returned as read.
+*/
+const createCimdFetch = (baseFetch) => async (url, options) => {
+	const response = await baseFetch(url, options);
+	if (!response.ok) return response;
+	const bytes = await readCapped(response);
+	const rebuilt = (body) => new Response(body, {
+		status: response.status,
+		headers: response.headers
+	});
+	if (bytes.length > MAX_INSPECTED_BYTES) return rebuilt(Buffer.from(bytes));
+	let parsed;
+	try {
+		parsed = JSON.parse(Buffer.from(bytes).toString("utf8"));
+	} catch {}
+	if (!(typeof parsed?.client_id === "string")) return rebuilt(Buffer.from(bytes));
+	const headers = new Headers(response.headers);
+	headers.delete("content-length");
+	return new Response(JSON.stringify(inferNativeApplication(parsed)), {
+		status: response.status,
+		headers
+	});
+};
+//#endregion
+//#region src/auth/server/upstream.ts
+/**
+* Zendesk as the upstream identity provider, through the same public PKCE client
+* the stdio flow uses. The server runs PKCE itself; no client secret exists.
+* Why: `docs/decisions/oauth-authorization-server.md` ("Upstream login").
+*/
+const ZENDESK_ACCESS_TOKEN_TTL_S = 172800;
+const ZENDESK_REFRESH_TOKEN_TTL_S = 7776e3;
+/** ASCII-only (auth paths end up in headers); never carries the Zendesk body. */
+const upstreamAuthError = (message, status, cause) => Object.assign(new Error(message, cause === void 0 ? void 0 : { cause }), {
+	name: "UpstreamAuthError",
+	...status === void 0 ? {} : { status }
+});
+const isUpstreamAuthError = (err) => err instanceof Error && err.name === "UpstreamAuthError";
+const buildZendeskAuthorizeUrl = (upstream, params) => {
+	const url = new URL(getOAuthUrls(upstream.subdomain).authorizeUrl);
+	url.searchParams.set("response_type", "code");
+	url.searchParams.set("client_id", upstream.clientId);
+	url.searchParams.set("redirect_uri", params.redirectUri);
+	url.searchParams.set("scope", params.scope);
+	url.searchParams.set("state", params.state);
+	url.searchParams.set("code_challenge", params.codeChallenge);
+	url.searchParams.set("code_challenge_method", "S256");
+	return url.toString();
+};
+const toTokenSet = (result, previousRefreshToken) => ({
+	accessToken: result.access_token,
+	refreshToken: result.refresh_token ?? previousRefreshToken,
+	expiresAt: result.expires_in === void 0 ? void 0 : Date.now() + result.expires_in * 1e3,
+	scope: result.scope
+});
+const requestTokens = async (upstream, grant, logger) => {
+	const body = new URLSearchParams({
+		client_id: upstream.clientId,
+		expires_in: String(ZENDESK_ACCESS_TOKEN_TTL_S),
+		refresh_token_expires_in: String(ZENDESK_REFRESH_TOKEN_TTL_S),
+		...grant
+	});
+	let response;
+	try {
+		response = await fetch(getOAuthUrls(upstream.subdomain).tokenUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: body.toString(),
+			signal: deadlineSignal(upstream.timeoutMs ?? 3e4)
+		});
+	} catch (err) {
+		throw upstreamAuthError("Zendesk token endpoint unreachable.", void 0, err);
+	}
+	logger.debug("oauth_upstream_token", {
+		grant: grant["grant_type"],
+		status: response.status
+	});
+	if (!response.ok) throw upstreamAuthError(`Zendesk refused the ${grant["grant_type"]} grant (${response.status}).`, response.status);
+	return await response.json();
+};
+const exchangeZendeskCode = async (upstream, params, logger = silentLogger) => toTokenSet(await requestTokens(upstream, {
+	grant_type: "authorization_code",
+	code: params.code,
+	redirect_uri: params.redirectUri,
+	code_verifier: params.codeVerifier
+}, logger));
+/** Zendesk rotates on refresh: the caller must persist the returned set. */
+const refreshZendeskTokens = async (upstream, refreshToken, logger = silentLogger) => toTokenSet(await requestTokens(upstream, {
+	grant_type: "refresh_token",
+	refresh_token: refreshToken
+}, logger), refreshToken);
+/** Zendesk is not OIDC: the account is whoever `/users/me` says the token belongs to. */
+const fetchZendeskIdentity = async (upstream, accessToken) => {
+	const failure = (cause) => upstreamAuthError("Could not resolve the Zendesk account of the signed-in user.", void 0, cause);
+	let user;
+	try {
+		({user} = await zendeskGet(upstream.subdomain, accessToken, "/users/me"));
+	} catch (err) {
+		throw failure(err);
+	}
+	if (typeof user?.id !== "number") throw failure();
+	return {
+		id: user.id,
+		name: user.name,
+		role: user.role
+	};
+};
+//#endregion
+//#region src/auth/server/interactions.ts
+const PENDING_TTL_MS = 6e5;
+const CONSENT_MEMORY_TTL_S = 7776e3;
+const sendHtml = (res, status, html) => {
+	res.writeHead(status, {
+		"Content-Type": "text/html; charset=utf-8",
+		"Cache-Control": "no-store"
+	});
+	res.end(html);
+};
+const redirect = (res, location) => {
+	res.writeHead(302, {
+		Location: location,
+		"Cache-Control": "no-store"
+	});
+	res.end();
+};
+const EXPIRED = "This sign-in has expired or was opened in another browser. Start the connection again from your MCP client.";
+const consentMemoryKey = (accountId, clientId, redirectUris) => createHash("sha256").update(JSON.stringify([
+	accountId,
+	clientId,
+	[...redirectUris].sort()
+])).digest("base64url");
+const isExpiredLink = (err) => err instanceof Error && (err.name === "SessionNotFound" || err.name === "InvalidRequest");
+const UID = /^[\w-]{1,64}$/;
+/**
+* The login and consent steps oidc-provider hands off to us. Login is always a
+* round trip to Zendesk (fresh tokens for every grant); consent is skipped for
+* trusted CIMD clients and for a client this user already approved with the
+* same redirect URIs, and shown otherwise (ADR, Consent).
+*/
+const createInteractionRoutes = (deps) => {
+	const { provider, upstream, issuer } = deps;
+	const logger = deps.logger ?? silentLogger;
+	const callbackUrl = `${issuer}/oauth/callback`;
+	const verifiers = createExpiringMap();
+	const upstreamTokens = createExpiringMap();
+	const finish = (req, res, result) => provider.interactionFinished(req, res, result, { mergeWithLastSubmission: true });
+	const deny = (req, res, description) => finish(req, res, {
+		error: "access_denied",
+		error_description: description
+	});
+	const startUpstreamLogin = (res, uid) => {
+		const verifier = generateCodeVerifier();
+		verifiers.set(uid, verifier, PENDING_TTL_MS);
+		redirect(res, buildZendeskAuthorizeUrl(upstream, {
+			redirectUri: callbackUrl,
+			scope: requestedScope(deps.readOnly),
+			state: uid,
+			codeChallenge: generateCodeChallenge(verifier)
+		}));
+	};
+	const approve = async (req, res, details, { accountId, clientId }, tokens) => {
+		const grant = new provider.Grant({
+			accountId,
+			clientId
+		});
+		const missing = details.prompt.details;
+		if (missing.missingOIDCScope?.length) grant.addOIDCScope(missing.missingOIDCScope.join(" "));
+		for (const [indicator, scopes] of Object.entries(missing.missingResourceScopes ?? {})) grant.addResourceScope(indicator, scopes.join(" "));
+		const grantId = await grant.save();
+		await deps.zendeskGrants.save(grantId, tokens);
+		logger.info("oauth_grant_created", { clientId });
+		await finish(req, res, { consent: { grantId } });
+	};
+	const consentContext = async (details) => {
+		const accountId = String(details.session?.accountId);
+		const clientId = String(details.params["client_id"]);
+		const client = await provider.Client.find(clientId);
+		const redirectUris = client?.redirectUris ?? [];
+		return {
+			client,
+			accountId,
+			clientId,
+			pendingKey: `${accountId}|${clientId}`,
+			memoryKey: consentMemoryKey(accountId, clientId, redirectUris),
+			redirectUri: String(details.params["redirect_uri"]),
+			redirectUris
+		};
+	};
+	const showInteraction = async (req, res, uid) => {
+		const details = await provider.interactionDetails(req, res);
+		if (details.prompt.name === "login") {
+			startUpstreamLogin(res, uid);
+			return;
+		}
+		const context = await consentContext(details);
+		if (canSkipConsent({
+			clientId: context.clientId,
+			redirectUri: context.redirectUri,
+			registeredRedirectUris: context.redirectUris
+		}, deps.trustedClients) || await deps.consentMemory.get(context.memoryKey) === true) {
+			const tokens = upstreamTokens.take(context.pendingKey);
+			if (!tokens) return deny(req, res, "The Zendesk sign-in expired. Try again.");
+			return approve(req, res, details, context, tokens);
+		}
+		const missing = details.prompt.details;
+		const scopes = [...new Set(Object.values(missing.missingResourceScopes ?? {}).flat())];
+		sendHtml(res, 200, renderConsentPage({
+			uid,
+			clientName: context.client?.clientName,
+			clientId: context.clientId,
+			redirectUri: context.redirectUri,
+			scopes,
+			subdomain: upstream.subdomain
+		}));
+	};
+	const completeUpstreamLogin = async (req, res, uid, url) => {
+		const details = await provider.interactionDetails(req, res);
+		const verifier = verifiers.take(uid);
+		const code = url.searchParams.get("code");
+		if (!verifier || !code) return deny(req, res, "The Zendesk sign-in was cancelled or refused.");
+		try {
+			const tokens = await exchangeZendeskCode(upstream, {
+				code,
+				redirectUri: callbackUrl,
+				codeVerifier: verifier
+			}, logger);
+			const accountId = `zendesk:${(await fetchZendeskIdentity(upstream, tokens.accessToken)).id}`;
+			upstreamTokens.set(`${accountId}|${String(details.params["client_id"])}`, tokens, PENDING_TTL_MS);
+			await finish(req, res, { login: { accountId } });
+		} catch (err) {
+			if (!isUpstreamAuthError(err)) throw err;
+			logger.warn("oauth_upstream_login_failed", { error: err.message });
+			await deny(req, res, err.message);
+		}
+	};
+	const confirm = async (req, res) => {
+		const details = await provider.interactionDetails(req, res);
+		if (details.prompt.name !== "consent") return sendHtml(res, 400, renderErrorPage("Sign-in failed", EXPIRED));
+		const context = await consentContext(details);
+		const tokens = upstreamTokens.take(context.pendingKey);
+		if (!tokens) return deny(req, res, "The Zendesk sign-in expired. Try again.");
+		await deps.consentMemory.set(context.memoryKey, true, CONSENT_MEMORY_TTL_S);
+		return approve(req, res, details, context, tokens);
+	};
+	const routes = async (req, res, url) => {
+		const [, , uid = "", action] = url.pathname.split("/");
+		if (!UID.test(uid)) return sendHtml(res, 404, renderErrorPage("Not found", EXPIRED));
+		if (req.method === "GET" && action === void 0) return showInteraction(req, res, uid);
+		if (req.method === "GET" && action === "callback") return completeUpstreamLogin(req, res, uid, url);
+		if (req.method === "POST" && action === "confirm") return confirm(req, res);
+		if (req.method === "POST" && action === "abort") {
+			await provider.interactionDetails(req, res);
+			return deny(req, res, "The user declined access.");
+		}
+		return sendHtml(res, 404, renderErrorPage("Not found", EXPIRED));
+	};
+	return {
+		/** `/oauth/callback`: the one redirect URI registered at Zendesk. */
+		upstreamCallback: (res, url) => {
+			const uid = url.searchParams.get("state") ?? "";
+			if (!UID.test(uid)) {
+				sendHtml(res, 400, renderErrorPage("Sign-in failed", EXPIRED));
+				return;
+			}
+			const next = new URL(`/interaction/${uid}/callback`, issuer);
+			const code = url.searchParams.get("code");
+			if (code) next.searchParams.set("code", code);
+			redirect(res, `${next.pathname}${next.search}`);
+		},
+		/** `/interaction/<uid>[/callback|/confirm|/abort]`. */
+		handle: async (req, res, url) => {
+			try {
+				await routes(req, res, url);
+			} catch (err) {
+				if (!isExpiredLink(err)) throw err;
+				if (!res.headersSent) sendHtml(res, 400, renderErrorPage("Sign-in failed", EXPIRED));
+			}
+		}
+	};
+};
+const ED25519_PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+const derive = (master, purpose, length = 32) => Buffer.from(hkdfSync("sha256", master, Buffer.alloc(0), `zendesk-mcp/${purpose}/v1`, length));
+const kidFor = (master, purpose) => createHash("sha256").update(derive(master, `kid/${purpose}`, 16)).digest("base64url").slice(0, 16);
+/**
+* Parse `OAUTH_MASTER_SECRET`: base64 entries, comma-separated, newest first.
+* Errors never echo the value.
+*/
+const parseSecretList = (raw) => {
+	const entries = raw.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0).map((entry) => Buffer.from(entry, "base64"));
+	const [first, ...rest] = entries;
+	if (!first) throw new Error("OAuth master secret is empty.");
+	if (entries.some((secret) => secret.length < 32)) throw new Error(`OAuth master secret must decode to at least 32 bytes of base64 (generate one with: openssl rand -base64 32).`);
+	return [first, ...rest];
+};
+const deriveKeySet = (master) => {
+	return {
+		signingJwk: {
+			...createPrivateKey({
+				key: Buffer.concat([ED25519_PKCS8_PREFIX, derive(master, "signing")]),
+				format: "der",
+				type: "pkcs8"
+			}).export({ format: "jwk" }),
+			kid: kidFor(master, "signing"),
+			use: "sig",
+			alg: "EdDSA"
+		},
+		accessToken: {
+			kid: kidFor(master, "access-token"),
+			key: createSecretKey(derive(master, "access-token"))
+		},
+		atRest: {
+			kid: kidFor(master, "at-rest"),
+			key: createSecretKey(derive(master, "at-rest"))
+		},
+		cookieKey: derive(master, "cookie").toString("base64url")
+	};
+};
+const deriveKeyRing = (raw) => {
+	const [first, ...rest] = parseSecretList(raw);
+	return [deriveKeySet(first), ...rest.map(deriveKeySet)];
+};
+//#endregion
+//#region src/auth/server/file-store.ts
+const isWindows$1 = process.platform === "win32";
+const isLive = (entry, now) => entry.exp === void 0 || entry.exp > now;
+/**
+* A store over a `Map`, calling `onChange` after every write. The map is the
+* caller's, so a test can look at exactly what was stored.
+*/
+const createMemoryStore = (entries = /* @__PURE__ */ new Map(), onChange = () => void 0) => ({
+	get: async (key) => {
+		const entry = entries.get(key);
+		return entry && isLive(entry, Date.now()) ? entry.v : void 0;
+	},
+	set: async (key, value, ttlMs) => {
+		entries.set(key, ttlMs === void 0 ? { v: value } : {
+			v: value,
+			exp: Date.now() + ttlMs
+		});
+		onChange();
+	},
+	delete: async (key) => {
+		if (entries.delete(key)) onChange();
+	}
+});
+const isEntry = (value) => typeof value?.v === "string" && (value.exp === void 0 || typeof value.exp === "number");
+const load = (path) => {
+	let raw;
+	try {
+		raw = readFileSync(path, "utf8");
+	} catch (err) {
+		if (err.code === "ENOENT") return /* @__PURE__ */ new Map();
+		throw new Error(`Cannot read the OAuth store file (${err.code}).`, { cause: err });
+	}
+	const parsed = JSON.parse(raw);
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("The OAuth store file is not a JSON object.");
+	const now = Date.now();
+	return new Map(Object.entries(parsed).filter((entry) => isEntry(entry[1]) && isLive(entry[1], now)));
+};
+const persist = (path, entries) => {
+	const now = Date.now();
+	const live = [...entries].filter(([, entry]) => isLive(entry, now));
+	mkdirSync(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	const tmp = `${path}.${process.pid}.tmp`;
+	writeFileSync(tmp, JSON.stringify(Object.fromEntries(live)), { mode: 384 });
+	if (!isWindows$1) chmodSync(tmp, 384);
+	renameSync(tmp, path);
+};
+/**
+* The default store: one JSON file, written atomically on every change. Chosen
+* over `keyv-file`, whose plain `writeFile` can truncate the file on a crash and
+* whose loader then silently starts empty. Single process only (ADR, Storage).
+*/
+const createFileStore = (path) => {
+	const entries = load(path);
+	return createMemoryStore(entries, () => persist(path, entries));
+};
+//#endregion
+//#region src/auth/server/store.ts
+/**
+* Models that must survive a restart. Everything else (sessions, interactions,
+* authorization codes, ...) stays in memory: a restart costs an in-flight login
+* at most. `ZendeskTokens` is ours, keyed by grant id.
+*/
+const PERSISTENT_MODELS = /* @__PURE__ */ new Set([
+	"Client",
+	"Grant",
+	"RefreshToken",
+	"ZendeskTokens"
+]);
+const encoder = new TextEncoder();
+const decoder$1 = new TextDecoder();
+const hashId = (id) => createHash("sha256").update(id).digest("base64url");
+const seal = (ring, value, expiresAt) => new CompactEncrypt(encoder.encode(JSON.stringify(value))).setProtectedHeader({
+	alg: "dir",
+	enc: "A256GCM",
+	kid: ring[0].atRest.kid,
+	expiresAt
+}).encrypt(ring[0].atRest.key);
+const unseal = async (ring, sealed) => {
+	const { kid, expiresAt } = decodeProtectedHeader(sealed);
+	const keySet = ring.find((set) => set.atRest.kid === kid);
+	if (!keySet) return void 0;
+	const { plaintext } = await compactDecrypt(sealed, keySet.atRest.key);
+	return {
+		value: JSON.parse(decoder$1.decode(plaintext)),
+		current: keySet === ring[0],
+		expiresAt
+	};
+};
+const open = (ring, sealed) => unseal(ring, sealed).catch(() => void 0);
+const secondsUntil = (exp) => exp === void 0 ? void 0 : Math.max(exp - Math.floor(Date.now() / 1e3), 1);
+/**
+* One named collection of whole-payload-encrypted records. A record read under
+* an older secret is rewritten under the current one, so dropping that secret
+* later loses nothing still in use (DCR clients are otherwise never rewritten).
+*/
+const createSealedCollection = (store, name, ring) => {
+	const key = (id) => `${name}:${hashId(id)}`;
+	return {
+		get: async (id) => {
+			const sealed = await store.get(key(id));
+			if (sealed === void 0) return void 0;
+			const record = await open(ring, sealed);
+			if (record && !record.current) {
+				const { expiresAt } = record;
+				const ttlMs = expiresAt === void 0 ? void 0 : expiresAt - Date.now();
+				await store.set(key(id), await seal(ring, record.value, expiresAt), ttlMs);
+			}
+			return record?.value;
+		},
+		set: async (id, value, ttlSeconds) => {
+			const ttlMs = ttlSeconds ? ttlSeconds * 1e3 : void 0;
+			const expiresAt = ttlMs === void 0 ? void 0 : Date.now() + ttlMs;
+			await store.set(key(id), await seal(ring, value, expiresAt), ttlMs);
+		},
+		delete: async (id) => {
+			await store.delete(key(id));
+		}
+	};
+};
+const createKeyLock = () => {
+	const tails = /* @__PURE__ */ new Map();
+	return (lockKey, fn) => {
+		const run = (tails.get(lockKey) ?? Promise.resolve()).then(fn, fn);
+		const tail = run.catch(() => void 0);
+		tails.set(lockKey, tail);
+		tail.then(() => {
+			if (tails.get(lockKey) === tail) tails.delete(lockKey);
+		});
+		return run;
+	};
+};
+/** oidc-provider adapter factory over two stores, sealed with the at-rest key. */
+const createAdapterFactory = (stores, ring) => {
+	const memory = stores.memory ?? createMemoryStore();
+	const withLock = createKeyLock();
+	return (name) => {
+		const store = PERSISTENT_MODELS.has(name) ? stores.persistent : memory;
+		const records = createSealedCollection(store, name, ring);
+		const grantIndex = createSealedCollection(store, `${name}:grant`, ring);
+		const uidIndex = createSealedCollection(store, `${name}:uid`, ring);
+		const indexGrant = (grantId, id, exp) => withLock(`${name}:${grantId}`, async () => {
+			const current = await grantIndex.get(grantId);
+			const latestExp = Math.max(current?.exp ?? 0, exp ?? 0) || void 0;
+			const ttl = latestExp ? Math.max(latestExp - Math.floor(Date.now() / 1e3), 1) : void 0;
+			await grantIndex.set(grantId, {
+				ids: [...current?.ids ?? [], id],
+				exp: latestExp
+			}, ttl);
+		});
+		return {
+			upsert: async (id, payload, expiresIn) => {
+				await records.set(id, payload, expiresIn);
+				if (payload.grantId) await indexGrant(payload.grantId, id, payload.exp);
+				if (payload.uid) await uidIndex.set(payload.uid, id, expiresIn);
+			},
+			find: (id) => records.get(id),
+			findByUid: async (uid) => {
+				const id = await uidIndex.get(uid);
+				return id ? records.get(id) : void 0;
+			},
+			findByUserCode: async () => void 0,
+			consume: async (id) => {
+				const payload = await records.get(id);
+				if (!payload) return;
+				await records.set(id, {
+					...payload,
+					consumed: Math.floor(Date.now() / 1e3)
+				}, secondsUntil(payload.exp));
+			},
+			destroy: (id) => records.delete(id),
+			revokeByGrantId: (grantId) => withLock(`${name}:${grantId}`, async () => {
+				const index = await grantIndex.get(grantId);
+				if (!index) return;
+				await Promise.all(index.ids.map((id) => records.delete(id)));
+				await grantIndex.delete(grantId);
+			})
+		};
+	};
+};
+/**
+* Open the persistent store named by `--oauth-store`: `file://` (the default)
+* or `memory://` (tests, throwaway runs). Another backend means implementing
+* `RecordStore`; the ADR records why the store is not pluggable yet.
+*/
+const openStore = (uri) => {
+	const { protocol } = new URL(uri);
+	if (protocol === "memory:") return createMemoryStore();
+	if (protocol === "file:") return createFileStore(fileURLToPath(uri));
+	throw new Error(`Unsupported OAuth store scheme "${protocol}". Use file:// or memory://.`);
+};
+const grantUnavailableError = () => Object.assign(/* @__PURE__ */ new Error("The Zendesk authorization behind this grant is no longer valid."), { name: "ZendeskGrantUnavailable" });
+const isGrantUnavailableError = (err) => err instanceof Error && err.name === "ZendeskGrantUnavailable";
+const isRefusal = (err) => isUpstreamAuthError(err) && (err.status === 400 || err.status === 401);
+/**
+* Zendesk tokens per grant of ours. Both layers rotate their refresh tokens, so
+* two concurrent Zendesk refreshes would spend the same single-use token: the
+* refresh is serialised per grant. Only this step is locked, never our own
+* `/token` endpoint (ADR, Tokens).
+*/
+const createZendeskGrants = (options) => {
+	const { records, upstream } = options;
+	const logger = options.logger ?? silentLogger;
+	const refresh = options.refresh ?? refreshZendeskTokens;
+	const now = options.now ?? Date.now;
+	const margin = options.refreshMarginMs ?? 3e5;
+	const withLock = createKeyLock();
+	const needsRefresh = (tokens) => tokens.expiresAt !== void 0 && tokens.expiresAt - now() <= margin;
+	const refreshed = async (grantId, refreshToken) => {
+		let fresh;
+		try {
+			fresh = await refresh(upstream, refreshToken, logger);
+		} catch (err) {
+			logger.warn("oauth_upstream_refresh_failed", { error: err instanceof Error ? err.message : String(err) });
+			if (!isRefusal(err)) throw err;
+			await records.delete(grantId);
+			throw grantUnavailableError();
+		}
+		await records.set(grantId, fresh, ZENDESK_REFRESH_TOKEN_TTL_S);
+		return fresh.accessToken;
+	};
+	return {
+		save: (grantId, tokens) => records.set(grantId, tokens, ZENDESK_REFRESH_TOKEN_TTL_S),
+		remove: (grantId) => withLock(grantId, () => records.delete(grantId)),
+		accessToken: (grantId) => withLock(grantId, async () => {
+			const tokens = await records.get(grantId);
+			if (!tokens) throw grantUnavailableError();
+			if (!needsRefresh(tokens)) return tokens.accessToken;
+			if (!tokens.refreshToken) throw grantUnavailableError();
+			return refreshed(grantId, tokens.refreshToken);
+		})
+	};
+};
+//#endregion
+//#region src/auth/server/provider.ts
+const ACCESS_TOKEN_TTL_S = 3600;
+const GRANT_TTL_S = 7776e3;
+const SESSION_TTL_S = 43200;
+const INTERACTION_TTL_S = 600;
+/** Scopes the server advertises and grants; `offline_access` is for clients (ChatGPT) that ask for it. */
+const RESOURCE_SCOPES = ["read", "write"];
+const policyWithUpstreamLogin = () => {
+	const policy = interactionPolicy.base();
+	policy.get("login")?.checks.add(new interactionPolicy.Check("upstream_login_required", "every authorization signs in to Zendesk again", (ctx) => ctx.oidc.result?.["login"] === void 0 ? interactionPolicy.Check.REQUEST_PROMPT : interactionPolicy.Check.NO_NEED_TO_PROMPT));
+	return policy;
+};
+/** The page oidc-provider shows when it cannot send the error back to the client. */
+const providerErrorPage = (out) => renderErrorPage("Sign-in failed", `${out.error}: ${out.error_description ?? "the authorization request was rejected"}`);
+const buildProvider = (options) => {
+	const { ring, resource } = options;
+	const [current] = ring;
+	const scopes = options.allowWrite ? RESOURCE_SCOPES.join(" ") : "read";
+	const baseFetch = options.fetch ?? ((url, init) => globalThis.fetch(url, init));
+	const provider = new Provider(options.issuer, {
+		adapter: options.adapter,
+		jwks: { keys: ring.map((set) => set.signingJwk) },
+		cookies: { keys: ring.map((set) => set.cookieKey) },
+		clients: [],
+		fetch: createCimdFetch(baseFetch),
+		scopes: options.allowWrite ? [...RESOURCE_SCOPES, "offline_access"] : ["read", "offline_access"],
+		clientDefaults: {
+			grant_types: ["authorization_code", "refresh_token"],
+			response_types: ["code"],
+			token_endpoint_auth_method: "none",
+			id_token_signed_response_alg: "EdDSA"
+		},
+		responseTypes: ["code"],
+		clientAuthMethods: [
+			"none",
+			"private_key_jwt",
+			"client_secret_basic",
+			"client_secret_post"
+		],
+		clientBasedCORS: (_ctx, origin) => options.isAllowedOrigin(origin),
+		pkce: { required: () => true },
+		issueRefreshToken: async (_ctx, client) => client.grantTypeAllowed("refresh_token"),
+		expiresWithSession: async () => false,
+		ttl: {
+			AccessToken: ACCESS_TOKEN_TTL_S,
+			AuthorizationCode: 60,
+			Grant: GRANT_TTL_S,
+			Interaction: INTERACTION_TTL_S,
+			RefreshToken: GRANT_TTL_S,
+			Session: SESSION_TTL_S
+		},
+		features: {
+			devInteractions: { enabled: false },
+			registration: { enabled: true },
+			revocation: { enabled: true },
+			userinfo: { enabled: false },
+			rpInitiatedLogout: { enabled: false },
+			clientIdMetadataDocument: {
+				enabled: true,
+				ack: "draft-02",
+				allowFetch: async (_ctx, clientId) => {
+					const url = new URL(clientId);
+					if (url.protocol !== "https:") return false;
+					return url.port === "";
+				}
+			},
+			resourceIndicators: {
+				enabled: true,
+				defaultResource: () => resource,
+				useGrantedResource: () => true,
+				getResourceServerInfo: (_ctx, indicator) => {
+					if (indicator !== resource) throw new errors.InvalidTarget();
+					return {
+						scope: scopes,
+						audience: resource,
+						accessTokenTTL: ACCESS_TOKEN_TTL_S,
+						accessTokenFormat: "jwt",
+						jwt: { encrypt: {
+							alg: "dir",
+							enc: "A256GCM",
+							key: current.accessToken.key,
+							kid: current.accessToken.kid
+						} }
+					};
+				}
+			}
+		},
+		extraTokenClaims: async (_ctx, token) => {
+			if (token.kind !== "AccessToken" || !token.grantId) return void 0;
+			try {
+				return {
+					zd: await options.zendeskGrants.accessToken(token.grantId),
+					gid: token.grantId
+				};
+			} catch (err) {
+				if (isGrantUnavailableError(err)) throw new errors.InvalidGrant({
+					detail: "the Zendesk authorization behind this grant is no longer valid",
+					cause: err
+				});
+				throw err;
+			}
+		},
+		findAccount: async (_ctx, sub) => ({
+			accountId: sub,
+			claims: async () => ({ sub })
+		}),
+		loadExistingGrant: async (ctx) => {
+			const grantId = ctx.oidc.result?.["consent"]?.grantId;
+			return grantId ? ctx.oidc.provider.Grant.find(grantId) : void 0;
+		},
+		interactions: {
+			url: (_ctx, interaction) => `/interaction/${interaction.uid}`,
+			policy: policyWithUpstreamLogin()
+		},
+		renderError: async (ctx, out) => {
+			ctx.type = "html";
+			ctx.body = providerErrorPage(out);
+		}
+	});
+	provider.proxy = options.behindProxy;
+	return provider;
+};
+//#endregion
+//#region src/auth/server/secret.ts
+const MASTER_SECRET_FILE_NAME = "oauth-master-secret";
+const isWindows = process.platform === "win32";
+const readSecretFile = (path) => {
+	try {
+		return readFileSync(path, "utf8").trim() || void 0;
+	} catch (err) {
+		if (err.code === "ENOENT") return void 0;
+		throw new Error(`Cannot read the OAuth master secret file (${err.code}).`, { cause: err });
+	}
+};
+const writeSecretFile = (path, value) => {
+	mkdirSync(dirname(path), { recursive: true });
+	const tmp = `${path}.${process.pid}.tmp`;
+	writeFileSync(tmp, `${value}\n`, { mode: 384 });
+	if (!isWindows) chmodSync(tmp, 384);
+	renameSync(tmp, path);
+};
+const storeDirectory = (storeUri) => storeUri.startsWith("file:") ? dirname(fileURLToPath(storeUri)) : void 0;
+/**
+* Resolve the AS master secret: explicit value, then `--oauth-master-secret-file`,
+* then the persisted file in the config dir, then a fresh secret written there.
+* The library's public `DEV_KEYSTORE` fallback is thereby never reachable.
+* Rationale and custody rules: `docs/decisions/oauth-authorization-server.md`.
+*/
+const resolveMasterSecret = (input, logger = silentLogger) => {
+	const validated = (value, source) => {
+		parseSecretList(value);
+		return {
+			value,
+			source
+		};
+	};
+	if (input.value) return validated(input.value, "env");
+	if (input.file) {
+		const fromFlag = readSecretFile(input.file);
+		if (!fromFlag) throw new Error("The OAuth master secret file is missing or empty.");
+		return validated(fromFlag, "file-flag");
+	}
+	const generate = () => randomBytes(32).toString("base64");
+	if (input.storeUri.startsWith("memory:")) {
+		logger.info("oauth_master_secret_ephemeral", { hint: "memory:// store: the secret and every grant are lost on restart." });
+		return {
+			value: generate(),
+			source: "ephemeral"
+		};
+	}
+	const path = join(input.configDir, MASTER_SECRET_FILE_NAME);
+	const persisted = readSecretFile(path);
+	const secret = persisted ? validated(persisted, "persisted") : void 0;
+	const result = secret ?? {
+		value: generate(),
+		source: "generated"
+	};
+	if (!secret) {
+		writeSecretFile(path, result.value);
+		logger.info("oauth_master_secret_generated", { path });
+	}
+	if (storeDirectory(input.storeUri) === resolve(input.configDir)) logger.warn("oauth_master_secret_beside_store", { hint: "The auto-generated master secret sits next to the file store: fine locally, but a deployment should supply OAUTH_MASTER_SECRET from a secret manager instead." });
+	return result;
+};
+//#endregion
+//#region src/auth/server/authorization-server.ts
+const decoder = new TextDecoder();
+const asVerified = (claims, issuer, resource) => {
+	const audiences = Array.isArray(claims.aud) ? claims.aud : [claims.aud];
+	if (!(claims.iss === issuer && audiences.includes(resource) && typeof claims.exp === "number" && claims.exp * 1e3 > Date.now() && typeof claims.zd === "string" && typeof claims.gid === "string")) return void 0;
+	return {
+		zendeskAccessToken: claims.zd,
+		grantId: claims.gid,
+		clientId: String(claims.client_id),
+		subject: String(claims.sub),
+		canWrite: typeof claims.scope === "string" && claims.scope.split(" ").includes("write"),
+		expiresAt: claims.exp
+	};
+};
+const createAuthorizationServer = (options) => {
+	const { config, issuer, ring, persistent } = options;
+	const logger = options.logger ?? silentLogger;
+	const resource = `${issuer}/mcp`;
+	const upstream = {
+		subdomain: config.subdomain,
+		clientId: config.oauthClientId
+	};
+	const zendeskGrants = createZendeskGrants({
+		records: createSealedCollection(persistent, "ZendeskTokens", ring),
+		upstream,
+		logger,
+		refreshMarginMs: 39e5
+	});
+	const logRevokeFailure = (err) => {
+		logger.error("oauth_grant_revoke_failed", {
+			error: err instanceof Error ? err.message : String(err),
+			hint: "Revoked in this process only. Fix the store before restarting: its next successful write persists the removal."
+		});
+	};
+	const provider = buildProvider({
+		issuer,
+		resource,
+		ring,
+		adapter: createAdapterFactory({ persistent }, ring),
+		zendeskGrants,
+		allowWrite: !config.readOnly,
+		isAllowedOrigin: options.isAllowedOrigin,
+		behindProxy: config.publicUrl?.startsWith("https:") === true,
+		fetch: options.fetch
+	});
+	provider.on("server_error", (_ctx, err) => {
+		logger.error("oauth_server_error", { error: err.message });
+	});
+	const revokedGrants = createExpiringMap();
+	provider.on("grant.revoked", (_ctx, grantId) => {
+		revokedGrants.set(grantId, true, ACCESS_TOKEN_TTL_S * 1e3);
+		zendeskGrants.remove(grantId).catch(logRevokeFailure);
+	});
+	const interactions = createInteractionRoutes({
+		provider,
+		upstream,
+		issuer,
+		readOnly: config.readOnly,
+		zendeskGrants,
+		consentMemory: createSealedCollection(persistent, "Consent", ring),
+		trustedClients: trustedClientSet(config.oauthTrustedClients, config.defaultTrustedClients),
+		logger
+	});
+	const callback = provider.callback();
+	const readAccessToken = async (bearer) => {
+		const { kid } = decodeProtectedHeader(bearer);
+		const keySet = ring.find((set) => set.accessToken.kid === kid);
+		if (!keySet) return void 0;
+		const { plaintext } = await compactDecrypt(bearer, keySet.accessToken.key);
+		return asVerified(JSON.parse(decoder.decode(plaintext)), issuer, resource);
+	};
+	return {
+		issuer,
+		resource,
+		protectedResourceMetadata: {
+			resource,
+			authorization_servers: [issuer],
+			bearer_methods_supported: ["header"],
+			scopes_supported: supportedScopes(config.readOnly)
+		},
+		handle: async (req, res) => {
+			const url = new URL(req.url ?? "/", issuer);
+			if (url.pathname === "/oauth/callback" && req.method === "GET") {
+				interactions.upstreamCallback(res, url);
+				return;
+			}
+			if (url.pathname.startsWith("/interaction/")) {
+				await interactions.handle(req, res, url);
+				return;
+			}
+			await callback(req, res);
+		},
+		verifyAccessToken: async (bearer) => {
+			const verified = await readAccessToken(bearer).catch(() => void 0);
+			return verified && !revokedGrants.get(verified.grantId) ? verified : void 0;
+		},
+		revokeGrant: async (grantId) => {
+			revokedGrants.set(grantId, true, ACCESS_TOKEN_TTL_S * 1e3);
+			try {
+				const grant = await provider.Grant.find(grantId);
+				await Promise.all([
+					grant?.destroy(),
+					provider.RefreshToken.adapter.revokeByGrantId(grantId),
+					zendeskGrants.remove(grantId)
+				]);
+				logger.info("oauth_grant_revoked", { reason: "zendesk_unauthorized" });
+			} catch (err) {
+				logRevokeFailure(err);
+			}
+		}
+	};
+};
+/**
+* Resolve the master secret and open the store, before the HTTP port is bound:
+* a short supplied secret or an unusable store stops startup here. Returns the
+* builder to call once the public URL (issuer) is known.
+*/
+const prepareAuthorizationServer = async (config, logger = silentLogger) => {
+	const dir = configDir();
+	const storeUri = config.oauthStore ?? pathToFileURL(join(dir, "oauth-store.json")).href;
+	const secret = resolveMasterSecret({
+		value: config.oauthMasterSecret,
+		file: config.oauthMasterSecretFile,
+		configDir: dir,
+		storeUri
+	}, logger);
+	const ring = deriveKeyRing(secret.value);
+	const persistent = openStore(storeUri);
+	return (issuer, isAllowedOrigin, overrides = {}) => createAuthorizationServer({
+		config,
+		issuer,
+		ring,
+		persistent,
+		isAllowedOrigin,
+		logger,
+		fetch: overrides.fetch
+	});
+};
+//#endregion
+//#region src/transports/http.ts
+const WILDCARD_HOSTS = /* @__PURE__ */ new Set([
+	"0.0.0.0",
+	"::",
+	"*"
+]);
+const TRAILING_SLASHES = /\/+$/;
+const DEFAULT_BROWSER_MCP_CLIENT_ORIGINS = [
+	"https://chatgpt.com",
+	"https://chat.openai.com",
+	"https://claude.ai",
+	"https://gemini.google.com",
+	"https://copilot.microsoft.com",
+	"https://www.perplexity.ai",
+	"https://chat.mistral.ai",
+	"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_EXPOSE_HEADERS = "mcp-session-id";
+const CORS_MAX_AGE = "600";
+const LOCALHOST_HOSTNAMES = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+const ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+/**
+* Returns the origin string to reflect in `Access-Control-Allow-Origin`, or
+* `undefined` if the origin is not allowed.
+*
+* The returned value is **never the raw `Origin` request header**. It comes
+* from one of three sanitization points:
+*
+*   1. An entry of the hardcoded `DEFAULT_BROWSER_MCP_CLIENT_ORIGINS` array.
+*   2. An entry of the operator-configured `extraOrigins` array.
+*   3. A loopback origin rebuilt from validated URL components after the
+*      hostname has been allowlisted against `LOCALHOST_HOSTNAMES`.
+*
+* This shape keeps the dataflow from request header to response header
+* gated by a constant allowlist, which is the pattern CodeQL's
+* `js/cors-misconfiguration-for-credentials` rule recognises as safe when
+* combined with `Access-Control-Allow-Credentials: true`.
+*/
+const resolveAllowedOrigin = (origin, extraOrigins) => {
+	const defaultMatch = DEFAULT_BROWSER_MCP_CLIENT_ORIGINS.find((entry) => entry === origin);
+	if (defaultMatch) return defaultMatch;
+	const extraMatch = extraOrigins?.find((entry) => entry === origin);
+	if (extraMatch) return extraMatch;
+	try {
+		const url = new URL(origin);
+		if (!ALLOWED_PROTOCOLS.has(url.protocol)) return void 0;
+		if (!LOCALHOST_HOSTNAMES.has(url.hostname)) return void 0;
+		const port = url.port || (url.protocol === "https:" ? "443" : "80");
+		return `${url.protocol}//${url.hostname}:${port}`;
+	} catch {
+		return;
+	}
+};
+const applyCorsHeaders = (req, res, extraOrigins) => {
+	const requestOrigin = req.headers["origin"];
+	if (typeof requestOrigin !== "string" || requestOrigin.length === 0) return;
+	const allowedOrigin = resolveAllowedOrigin(requestOrigin, extraOrigins);
+	if (!allowedOrigin) return;
+	res.setHeader("Access-Control-Allow-Origin", allowedOrigin);
+	res.setHeader("Vary", "Origin");
+	res.setHeader("Access-Control-Allow-Credentials", "true");
+	res.setHeader("Access-Control-Expose-Headers", CORS_EXPOSE_HEADERS);
+};
+const handleCorsPreflight = (req, res, extraOrigins) => {
+	if (req.method !== "OPTIONS") return false;
+	applyCorsHeaders(req, res, extraOrigins);
+	if (res.getHeader("Access-Control-Allow-Origin")) {
+		res.setHeader("Access-Control-Allow-Methods", CORS_ALLOWED_METHODS);
+		res.setHeader("Access-Control-Allow-Headers", CORS_ALLOWED_HEADERS);
+		res.setHeader("Access-Control-Max-Age", CORS_MAX_AGE);
+	}
+	res.writeHead(204);
+	res.end();
+	return true;
+};
+const resolvePublicUrl = (config, logger = silentLogger) => {
+	if (config.publicUrl) return config.publicUrl.replace(TRAILING_SLASHES, "");
+	if (!WILDCARD_HOSTS.has(config.host)) return `http://${config.host}:${config.port}`;
+	logger.warn("public_url_unset", {
+		host: config.host,
+		advertised: `http://${config.host}:${config.port}`,
+		hint: "OAuth discovery will advertise a non-routable resource identifier and spec-compliant MCP clients may refuse the connection. Set PUBLIC_URL (or --public-url) to the URL clients use to reach this server (e.g. https://your-host.example.com)."
+	});
+	return `http://${config.host}:${config.port}`;
+};
+const MISSING_BEARER_MESSAGE = "Missing or invalid access token. Sign in through this server: its OAuth authorization server is named in the protected resource metadata.";
+const extractBearer = (request) => {
+	const header = request.headers["authorization"];
+	if (typeof header !== "string") return void 0;
+	if (!header.toLowerCase().startsWith("bearer ")) return void 0;
+	return header.slice(7).trim();
+};
+const PROTECTED_RESOURCE_PATHS = ["/.well-known/oauth-protected-resource/mcp", "/.well-known/oauth-protected-resource"];
+const sendJson = (res, status, body) => {
+	res.writeHead(status, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(body));
+};
+const sendJsonRpcError = (res, status, code, message, headers = {}) => {
+	res.writeHead(status, {
+		"Content-Type": "application/json",
+		...headers
+	});
+	res.end(JSON.stringify({
+		error: {
+			code,
+			message
+		},
+		id: null,
+		jsonrpc: "2.0"
+	}));
+};
+const failRequest = (res, err) => {
+	const message = err instanceof Error ? err.message : "Internal Server Error";
+	if (!res.headersSent) {
+		sendJsonRpcError(res, 500, -32603, message);
+		return;
+	}
+	if (!res.writableEnded) res.end();
+};
+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 MAX_BODY_BYTES = 4194304;
+const readJsonBody = (req, maxBodyBytes) => new Promise((resolve) => {
+	const chunks = [];
+	let total = 0;
+	let settled = false;
+	const settle = (result) => {
+		if (settled) return;
+		settled = true;
+		resolve(result);
+	};
+	req.on("data", (chunk) => {
+		total += chunk.length;
+		if (total > maxBodyBytes) {
+			req.removeAllListeners("data");
+			settle({
+				ok: false,
+				status: 413,
+				rpcCode: -32600,
+				message: `Request body exceeds ${maxBodyBytes} bytes.`
+			});
+			return;
+		}
+		chunks.push(chunk);
+	});
+	req.on("end", () => {
+		const raw = Buffer.concat(chunks).toString("utf8");
+		if (!raw) {
+			settle({
+				ok: true,
+				value: void 0
+			});
+			return;
+		}
+		try {
+			settle({
+				ok: true,
+				value: JSON.parse(raw)
+			});
+		} catch {
+			settle({
+				ok: false,
+				status: 400,
+				rpcCode: -32700,
+				message: "Parse error: request body is not valid JSON."
+			});
+		}
+	});
+	req.on("error", () => settle({
+		ok: false,
+		status: 400,
+		rpcCode: -32600,
+		message: "Request body could not be read."
+	}));
+});
+const respondBodyError = (req, res, failure) => {
+	const headers = failure.status === 413 ? { Connection: "close" } : {};
+	sendJsonRpcError(res, failure.status, failure.rpcCode, failure.message, headers);
+	if (failure.status === 413) {
+		if (res.writableFinished) req.destroy();
+		else res.once("finish", () => req.destroy());
+	}
+};
+const SESSION_IDLE_TIMEOUT_MS = 18e5;
+const SESSION_SWEEP_INTERVAL_MS = 6e4;
+const startHttpTransport = async (config, logger = silentLogger, options = {}) => {
+	const buildAuthorizationServer = await prepareAuthorizationServer(config, logger);
+	let authorizationServer;
+	const sessions = /* @__PURE__ */ new Map();
+	const idleTimeoutMs = options.sessionIdleTimeoutMs ?? SESSION_IDLE_TIMEOUT_MS;
+	const maxBodyBytes = options.maxBodyBytes ?? 4194304;
+	const dispatchToSession = async (req, res, sessionId, token) => {
+		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);
+		return true;
+	};
+	const openSession = async (req, res, body, token, as) => {
+		const auth = {
+			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 transport = new NodeStreamableHTTPServerTransport({
+			sessionIdGenerator: () => randomUUID(),
+			onsessioninitialized: (newId) => {
+				sessions.set(newId, {
+					transport,
+					auth,
+					subject: token.subject,
+					canWrite,
+					lastActivityAt: Date.now(),
+					close: async () => {
+						await transport.close();
+						await server.close();
+					}
+				});
+			}
+		});
+		transport.onclose = () => {
+			if (transport.sessionId) sessions.delete(transport.sessionId);
+		};
+		await server.connect(transport);
+		await transport.handleRequest(req, res, body);
+	};
+	const handleMcpRequest = async (req, res, as) => {
+		const bearer = extractBearer(req);
+		const token = bearer ? await as.verifyAccessToken(bearer) : void 0;
+		if (!token) {
+			sendUnauthorized(res, as.issuer);
+			return;
+		}
+		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 (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);
+			return;
+		}
+		await openSession(req, res, body.value, token, as);
+	};
+	const route = async (req, res, as) => {
+		const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+		if (req.method === "GET" && PROTECTED_RESOURCE_PATHS.includes(url.pathname)) {
+			sendJson(res, 200, as.protectedResourceMetadata);
+			return;
+		}
+		if (req.method === "GET" && url.pathname === "/healthz") {
+			sendJson(res, 200, {
+				status: "ok",
+				subdomain: config.subdomain
+			});
+			return;
+		}
+		if (url.pathname === "/mcp") {
+			await handleMcpRequest(req, res, as);
+			return;
+		}
+		await as.handle(req, res);
+	};
+	const requestListener = async (req, res) => {
+		try {
+			if (handleCorsPreflight(req, res, config.corsOrigins)) return;
+			applyCorsHeaders(req, res, config.corsOrigins);
+			if (!authorizationServer) {
+				sendJsonRpcError(res, 503, -32e3, "Server is starting.");
+				return;
+			}
+			await route(req, res, authorizationServer);
+		} catch (err) {
+			failRequest(res, err);
+		}
+	};
+	const httpServer = createServer((req, res) => {
+		requestListener(req, res);
+	});
+	await new Promise((resolve, reject) => {
+		httpServer.once("error", reject);
+		httpServer.listen(config.port, config.host, () => {
+			httpServer.off("error", reject);
+			resolve();
+		});
+	});
+	const addr = httpServer.address();
+	const boundPort = typeof addr === "object" && addr !== null ? addr.port : config.port;
+	authorizationServer = buildAuthorizationServer(resolvePublicUrl({
+		...config,
+		port: boundPort
+	}, logger), (origin) => resolveAllowedOrigin(origin, config.corsOrigins) !== void 0, { fetch: options.cimdFetch });
+	logger.info("http_transport_ready", {
+		host: config.host,
+		port: boundPort,
+		issuer: authorizationServer.issuer
+	});
+	const sweepIdleSessions = async () => {
+		const cutoff = Date.now() - idleTimeoutMs;
+		for (const [id, session] of sessions) {
+			if (session.lastActivityAt > cutoff) continue;
+			sessions.delete(id);
+			try {
+				await session.close();
+			} catch (err) {
+				logger.warn("session_close_failed", {
+					sessionId: id,
+					error: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}
+	};
+	const sweeper = setInterval(() => void sweepIdleSessions(), options.sweepIntervalMs ?? SESSION_SWEEP_INTERVAL_MS);
+	sweeper.unref();
+	return {
+		port: boundPort,
+		close: async () => {
+			clearInterval(sweeper);
+			await Promise.all([...sessions.values()].map((session) => session.close()));
+			sessions.clear();
+			httpServer.closeAllConnections();
+			await new Promise((resolve, reject) => {
+				httpServer.close((err) => err ? reject(err) : resolve());
+			});
+		}
+	};
+};
+//#endregion
+export { DEFAULT_BROWSER_MCP_CLIENT_ORIGINS, MAX_BODY_BYTES, extractBearer, resolveAllowedOrigin, resolvePublicUrl, startHttpTransport };