@codemem/mcp 0.31.4 → 0.32.1

package/dist/http.js

@@ -0,0 +1,1049 @@
+#!/usr/bin/env node
+import { t as e } from "./server-Djvf0Yik.js";
+import { createServer as t } from "node:http";
+import { isIP as n } from "node:net";
+import { pathToFileURL as r } from "node:url";
+import { MemoryStore as i, resolveDbPath as a } from "@codemem/core";
+import { requireBearerAuth as o } from "@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js";
+import { createOAuthMetadata as s, getOAuthProtectedResourceMetadataUrl as c, mcpAuthRouter as l } from "@modelcontextprotocol/sdk/server/auth/router.js";
+import { StreamableHTTPServerTransport as u } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import d from "express";
+import { createHmac as f, createPublicKey as p, randomBytes as m, randomUUID as h, timingSafeEqual as g, verify as _ } from "node:crypto";
+import { AccessDeniedError as v, InvalidClientError as y, InvalidClientMetadataError as b, InvalidGrantError as x, InvalidRequestError as S, InvalidTokenError as C, ServerError as w, TemporarilyUnavailableError as T, UnsupportedResponseTypeError as E } from "@modelcontextprotocol/sdk/server/auth/errors.js";
+import { OAuthProtectedResourceMetadataSchema as D, OAuthTokensSchema as O } from "@modelcontextprotocol/sdk/shared/auth.js";
+//#region src/audit.ts
+var k = new Set([
+	"token",
+	"accesstoken",
+	"refreshtoken",
+	"idtoken",
+	"code",
+	"codeverifier",
+	"codechallenge",
+	"clientsecret",
+	"authorization",
+	"password",
+	"secret"
+]);
+function ee(e) {
+	return e.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function A(e, t) {
+	for (let e of Object.keys(t)) if (k.has(ee(e))) throw Error(`OAuth audit event must not carry forbidden field: ${e}`);
+	let { now: n, ...r } = t;
+	return {
+		kind: e,
+		timestamp: new Date(n ?? Date.now()).toISOString(),
+		...r
+	};
+}
+function te(e) {
+	let t = !1;
+	return (n) => {
+		try {
+			e(n);
+		} catch (e) {
+			t || (t = !0, console.error("codemem MCP OAuth audit emitter failed (further failures suppressed):", e));
+		}
+	};
+}
+function ne(e = process.stderr) {
+	return (t) => {
+		e.write(`${JSON.stringify({
+			source: "codemem-mcp-oauth-audit",
+			...t
+		})}\n`);
+	};
+}
+function re() {
+	return () => {};
+}
+function ie(e = process.env.CODEMEM_MCP_AUDIT) {
+	let t = e?.trim().toLowerCase();
+	return t === "0" || t === "false" || t === "no" ? re() : ne();
+}
+var ae = "codemem MCP", j = ["memory:read", "memory:write"], M = "https://github.com/kunickiaj/codemem#readme", oe = "https://claude.ai/api/mcp/auth_callback", N = new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1"
+]), se = new Set(["authorization_code", "refresh_token"]), ce = new Set(["code"]), P = 3600, F = 720 * 60 * 60, le = 100, ue = 100, de = 100, I = 32, fe = 43, pe = /^[A-Za-z0-9_-]{43}$/, me = /^[A-Za-z0-9_-]{43}$/, he = class {
+	#e = /* @__PURE__ */ new Map();
+	getClient(e) {
+		return this.#e.get(e);
+	}
+	registerClient(e) {
+		let t = De(e.redirect_uris);
+		if (t) throw new b(t);
+		if (e.client_secret || e.token_endpoint_auth_method !== "none") throw new b("Only public clients with token_endpoint_auth_method=none are supported");
+		if (e.grant_types && !Oe(e.grant_types, se)) throw new b("Only authorization_code and refresh_token grant_types are supported");
+		if (e.response_types && !Oe(e.response_types, ce)) throw new b("Only code response_type is supported");
+		if (this.#e.size >= 100) {
+			let e = this.#e.keys().next().value;
+			e && this.#e.delete(e);
+		}
+		let n = {
+			...e,
+			token_endpoint_auth_method: "none",
+			grant_types: e.grant_types ?? ["authorization_code", "refresh_token"],
+			response_types: e.response_types ?? ["code"],
+			client_id: h(),
+			client_id_issued_at: Math.floor(Date.now() / 1e3)
+		};
+		return this.#e.set(n.client_id, n), n;
+	}
+}, ge = class {
+	#e = /* @__PURE__ */ new Map();
+	issueCode(e, t = Date.now()) {
+		if (this.#t(t), this.#e.size >= le) return;
+		let n = h();
+		return this.#e.set(n, {
+			...e,
+			used: !1
+		}), n;
+	}
+	peekCode(e) {
+		let t = this.#e.get(e);
+		if (!(!t || t.used)) return t;
+	}
+	consumeCode(e) {
+		let t = this.#e.get(e);
+		if (!(!t || t.used)) return t.used = !0, t;
+	}
+	#t(e) {
+		for (let [t, n] of this.#e) n.expiresAt <= e && this.#e.delete(t);
+	}
+}, _e = class {
+	#e = /* @__PURE__ */ new Map();
+	#t = m(32);
+	issueToken(e, t = Date.now(), n, r, i = []) {
+		if (this.#n(t), this.#e.size >= ue) return;
+		let a = m(I), o = V(a, this.#t);
+		return this.#e.set(o, {
+			clientId: e,
+			grantId: r,
+			scopes: [...i],
+			resource: n,
+			tokenHash: o,
+			issuedAt: t,
+			expiresAt: t + P * 1e3,
+			lastUsedAt: null,
+			revokedAt: null
+		}), {
+			token: a.toString("base64url"),
+			expiresIn: P
+		};
+	}
+	verifyToken(e, t = Date.now()) {
+		let n = z(e);
+		if (!n) return {
+			ok: !1,
+			reason: "unknown_token"
+		};
+		let r = V(n, this.#t), i = this.#e.get(r);
+		return !i || !U(i.tokenHash, r) ? {
+			ok: !1,
+			reason: "unknown_token"
+		} : i.revokedAt === null ? i.expiresAt <= t ? {
+			ok: !1,
+			reason: "expired_token"
+		} : (i.lastUsedAt = t, {
+			ok: !0,
+			record: { ...i }
+		}) : {
+			ok: !1,
+			reason: "revoked_token"
+		};
+	}
+	revokeToken(e, t = Date.now()) {
+		let n = z(e);
+		if (!n) return !1;
+		let r = V(n, this.#t), i = this.#e.get(r);
+		return !i || !U(i.tokenHash, r) ? !1 : (i.revokedAt === null && (i.revokedAt = t), !0);
+	}
+	revokeTokensForGrant(e, t = Date.now()) {
+		let n = 0;
+		for (let r of this.#e.values()) r.grantId !== e || r.revokedAt !== null || (r.revokedAt = t, n += 1);
+		return n;
+	}
+	#n(e) {
+		for (let [t, n] of this.#e) (n.expiresAt <= e || n.revokedAt !== null) && this.#e.delete(t);
+	}
+}, ve = class {
+	#e = /* @__PURE__ */ new Map();
+	#t = /* @__PURE__ */ new Map();
+	#n = /* @__PURE__ */ new Map();
+	#r = m(32);
+	issueGrant(e, t = Date.now()) {
+		if (this.#i(t), this.#e.size >= de) return;
+		let n = Pe(), r = B(n, this.#r);
+		if (!r) return;
+		let i = {
+			grantId: h(),
+			clientId: e.clientId,
+			scopes: [...e.scopes ?? []],
+			resource: e.resource,
+			currentRefreshTokenHash: r,
+			previousRefreshTokenHash: null,
+			issuedAt: t,
+			expiresAt: t + F * 1e3,
+			rotatedAt: null,
+			revokedAt: null
+		};
+		return this.#e.set(i.grantId, i), this.#t.set(r, i.grantId), this.#n.set(i.grantId, new Set([r])), {
+			grant: {
+				...i,
+				scopes: [...i.scopes]
+			},
+			refreshToken: n,
+			expiresIn: F
+		};
+	}
+	rotateRefreshToken(e, t, n = {}, r = Date.now()) {
+		let i = B(t, this.#r);
+		if (!i) return {
+			ok: !1,
+			reason: "unknown_refresh_token"
+		};
+		let a = this.#t.get(i);
+		if (!a) return {
+			ok: !1,
+			reason: "unknown_refresh_token"
+		};
+		let o = this.#e.get(a);
+		if (!o) return {
+			ok: !1,
+			reason: "unknown_refresh_token"
+		};
+		if (o.revokedAt !== null) return {
+			ok: !1,
+			reason: "revoked_refresh_token",
+			grantId: a
+		};
+		if (o.expiresAt <= r) return this.revokeGrant(a, r), {
+			ok: !1,
+			reason: "expired_refresh_token",
+			grantId: a
+		};
+		if (o.clientId !== e) return {
+			ok: !1,
+			reason: "client_mismatch",
+			grantId: a
+		};
+		if (!Fe(n.scopes ?? o.scopes, o.scopes)) return {
+			ok: !1,
+			reason: "scope_mismatch",
+			grantId: a
+		};
+		if ((o.resource ?? null) !== (n.resource ?? o.resource ?? null)) return {
+			ok: !1,
+			reason: "resource_mismatch",
+			grantId: a
+		};
+		let s = U(o.currentRefreshTokenHash, i), c = o.previousRefreshTokenHash !== null && U(o.previousRefreshTokenHash, i);
+		if (!s && !c) return this.revokeGrant(a, r), {
+			ok: !1,
+			reason: "refresh_token_replay",
+			grantId: a
+		};
+		let l = Pe(), u = B(l, this.#r);
+		return u ? (o.scopes = [...n.scopes ?? o.scopes], o.previousRefreshTokenHash = s ? o.currentRefreshTokenHash : null, o.currentRefreshTokenHash = u, o.rotatedAt = r, this.#t.set(u, a), this.#n.get(a)?.add(u), {
+			ok: !0,
+			grant: {
+				...o,
+				scopes: [...o.scopes]
+			},
+			refreshToken: l,
+			expiresIn: Math.max(0, Math.floor((o.expiresAt - r) / 1e3))
+		}) : {
+			ok: !1,
+			reason: "unknown_refresh_token"
+		};
+	}
+	revokeRefreshToken(e, t = Date.now()) {
+		let n = B(e, this.#r);
+		if (!n) return;
+		let r = this.#t.get(n);
+		if (r) return this.revokeGrant(r, t), r;
+	}
+	revokeGrant(e, t = Date.now()) {
+		let n = this.#e.get(e);
+		return n ? n.revokedAt === null ? (n.revokedAt = t, this.#a(n), !0) : !0 : !1;
+	}
+	#i(e) {
+		for (let [t, n] of this.#e) n.expiresAt > e && n.revokedAt === null || (this.#e.delete(t), this.#a(n));
+	}
+	#a(e) {
+		let t = this.#n.get(e.grantId);
+		if (t) {
+			for (let e of t) this.#t.delete(e);
+			this.#n.delete(e.grantId);
+			return;
+		}
+		this.#t.delete(e.currentRefreshTokenHash), e.previousRefreshTokenHash && this.#t.delete(e.previousRefreshTokenHash);
+	}
+};
+function ye() {
+	return new he();
+}
+function be() {
+	return new ge();
+}
+function xe() {
+	return new _e();
+}
+function Se() {
+	return new ve();
+}
+function Ce(e) {
+	let t = Ee(L(e.mcpUrl));
+	return {
+		...s({
+			provider: Ie(e.clientsStore),
+			issuerUrl: t,
+			baseUrl: t
+		}),
+		grant_types_supported: ["authorization_code", "refresh_token"],
+		token_endpoint_auth_methods_supported: ["none"],
+		scopes_supported: j,
+		service_documentation: M,
+		revocation_endpoint: new URL("/revoke", t).href,
+		revocation_endpoint_auth_methods_supported: ["none"],
+		client_id_metadata_document_supported: !1
+	};
+}
+function we(e) {
+	let t = L(e), n = {
+		resource: t.href,
+		authorization_servers: [Ee(t).href],
+		scopes_supported: j,
+		bearer_methods_supported: ["header"],
+		resource_name: ae,
+		resource_documentation: M
+	};
+	return D.parse(n);
+}
+function Te(e, t) {
+	let n = e.get("client_id") ?? "", r = e.get("redirect_uri") ?? "", i = e.get("response_type") ?? "", a = e.get("code_challenge") ?? "", o = e.get("code_challenge_method") ?? "", s = e.get("resource"), c = Me(e.get("scope")), l = e.get("state");
+	if (i !== "code") return R("unsupported_response_type");
+	if (o !== "S256") return R("invalid_request", "PKCE code_challenge_method=S256 is required");
+	if (!me.test(a)) return R("invalid_request", "Valid PKCE S256 code_challenge is required");
+	let u = Ne(t, n);
+	return u ? u.redirect_uris.includes(r) ? {
+		clientId: n,
+		redirectUri: r,
+		codeChallenge: a,
+		scopes: c,
+		resource: s,
+		state: l
+	} : R("invalid_request", "redirect_uri is not registered for this client") : R("invalid_client", "Unknown OAuth client_id");
+}
+function L(e) {
+	let t;
+	try {
+		t = new URL(e);
+	} catch {
+		throw Error("Invalid MCP HTTP public URL; expected an HTTPS /mcp URL");
+	}
+	if (t.protocol !== "https:" && !Ae(t)) throw Error("Invalid MCP HTTP public URL; use HTTPS for non-loopback URLs");
+	if (t.username || t.password || t.search || t.hash) throw Error("Invalid MCP HTTP public URL; credentials, query strings, and fragments are not allowed");
+	if (t.pathname === "/" && (t.pathname = "/mcp"), t.pathname !== "/mcp") throw Error("Invalid MCP HTTP public URL; expected /mcp path");
+	return t;
+}
+function Ee(e) {
+	return new URL(e.origin);
+}
+function De(e) {
+	for (let t of e) {
+		let e = new URL(t);
+		if (e.username || e.password || e.hash) return `Invalid redirect URI: ${t}`;
+		if (e.href !== oe && !ke(e)) return `Unsupported redirect URI: ${t}`;
+	}
+	return null;
+}
+function Oe(e, t) {
+	return e.length > 0 && e.every((e) => t.has(e));
+}
+function ke(e) {
+	return e.protocol === "http:" && N.has(je(e.hostname)) && e.pathname === "/callback" && e.search === "";
+}
+function Ae(e) {
+	let t = je(e.hostname);
+	return e.protocol === "http:" && N.has(t);
+}
+function je(e) {
+	return e.replace(/^\[(.*)]$/, "$1").toLowerCase();
+}
+function Me(e) {
+	return e?.split(/\s+/).map((e) => e.trim()).filter(Boolean) ?? [];
+}
+function R(e, t) {
+	return {
+		status: 400,
+		body: t ? {
+			error: e,
+			error_description: t
+		} : { error: e }
+	};
+}
+function Ne(e, t) {
+	let n = e.getClient(t);
+	if (n instanceof Promise) throw Error("Asynchronous OAuth client stores are not supported by this HTTP bootstrap yet");
+	return n;
+}
+function z(e) {
+	if (typeof e != "string" || e.length !== fe || !pe.test(e)) return null;
+	let t = Buffer.from(e, "base64url");
+	return t.length === I ? t : null;
+}
+function Pe() {
+	return m(I).toString("base64url");
+}
+function B(e, t) {
+	let n = z(e);
+	return n ? H(n, t) : null;
+}
+function V(e, t) {
+	return H(e, t);
+}
+function H(e, t) {
+	return f("sha256", t).update(e).digest("base64url");
+}
+function U(e, t) {
+	let n = Buffer.from(e), r = Buffer.from(t);
+	return n.length === r.length && g(n, r);
+}
+function Fe(e, t) {
+	let n = new Set(t);
+	return e.every((e) => n.has(e));
+}
+function Ie(e) {
+	return {
+		clientsStore: e,
+		async authorize() {
+			throw Error("OAuth authorize is not implemented yet");
+		},
+		async challengeForAuthorizationCode() {
+			throw Error("OAuth token exchange is not implemented yet");
+		},
+		async exchangeAuthorizationCode() {
+			throw Error("OAuth token exchange is not implemented yet");
+		},
+		async exchangeRefreshToken() {
+			throw Error("OAuth refresh is not implemented yet");
+		},
+		async verifyAccessToken() {
+			throw Error("OAuth bearer verification is not implemented yet");
+		}
+	};
+}
+//#endregion
+//#region src/oidc.ts
+var Le = "CODEMEM_MCP_OIDC_ISSUER_URL", Re = "CODEMEM_MCP_OIDC_CLIENT_ID", ze = "CODEMEM_MCP_OIDC_CLIENT_SECRET", Be = "CODEMEM_MCP_OAUTH_ALLOWED_SUBJECT", Ve = "CODEMEM_MCP_OAUTH_ALLOWED_EMAIL", He = 300 * 1e3, Ue = 100, We = 300 * 1e3, Ge = class {
+	#e = /* @__PURE__ */ new Map();
+	issue(e, t = Date.now()) {
+		if (this.#t(t), this.#e.size >= Ue) return;
+		let n = h();
+		return this.#e.set(n, {
+			...e,
+			expiresAt: t + He
+		}), n;
+	}
+	consume(e) {
+		let t = this.#e.get(e);
+		return this.#e.delete(e), t;
+	}
+	#t(e) {
+		for (let [t, n] of this.#e) n.expiresAt <= e && this.#e.delete(t);
+	}
+};
+function Ke() {
+	return new Ge();
+}
+function qe(e = process.env) {
+	let t = e[Le]?.trim(), n = e[Re]?.trim(), r = e[ze]?.trim(), i = e[Be]?.trim(), a = e[Ve]?.trim().toLowerCase();
+	if (!(!t && !n && !r && !i && !a)) {
+		if (!t || !n || !r) throw Error("Incomplete MCP OIDC configuration");
+		if (q(t, "issuer", { allowLoopbackHttp: !0 }), !i && !a) throw Error("MCP OIDC requires CODEMEM_MCP_OAUTH_ALLOWED_SUBJECT or CODEMEM_MCP_OAUTH_ALLOWED_EMAIL");
+		return {
+			issuerUrl: t,
+			clientId: n,
+			clientSecret: r,
+			allowedSubject: i,
+			allowedEmail: a
+		};
+	}
+}
+async function Je(e, t, n, r, i, a = Date.now()) {
+	if (!r) return J("temporarily_unavailable", "OIDC is not configured");
+	let o = Te(e, t);
+	if ("status" in o) return o;
+	let s = await G(r.issuerUrl), c = h(), l = n.issue({
+		oauthParams: e.toString(),
+		nonce: c
+	}, a);
+	if (!l) return J("temporarily_unavailable", "Too many pending OIDC authorizations");
+	let u = W(i), d = new URL(s.authorization_endpoint);
+	return d.searchParams.set("response_type", "code"), d.searchParams.set("client_id", r.clientId), d.searchParams.set("redirect_uri", u), d.searchParams.set("scope", "openid email"), d.searchParams.set("state", l), d.searchParams.set("nonce", c), {
+		status: 302,
+		location: d.href
+	};
+}
+async function Ye(e, t, n, r, i = Date.now()) {
+	try {
+		let a = e.get("code") ?? "", o = e.get("state") ?? "";
+		if (!o) return J("invalid_request", "Missing OIDC state");
+		let s = t.consume(o);
+		if (!s || s.expiresAt <= i) return J("invalid_request", "Expired or unknown OIDC state");
+		if (!a) return J("invalid_request", "Missing OIDC code");
+		let c = await G(n.issuerUrl), l = await Xe(c.token_endpoint, n, W(r), a);
+		return l.id_token ? et(await Ze(l.id_token, c, n.clientId, s.nonce, i), n) ? { oauthParams: new URLSearchParams(s.oauthParams) } : J("access_denied", "OIDC identity is not allowed") : J("invalid_request", "OIDC token exchange failed");
+	} catch {
+		return J("access_denied", "OIDC identity verification failed");
+	}
+}
+function W(e) {
+	let t = new URL(e);
+	return new URL("/oauth/callback", t.origin).href;
+}
+async function G(e) {
+	let t = new URL(e);
+	if (t.search || t.hash) throw Error("OIDC issuer must not include query or fragment");
+	if (t.username || t.password) throw Error("OIDC issuer must not include credentials");
+	let n = new URL(`${t.pathname.replace(/\/$/, "")}/.well-known/openid-configuration`, t.origin), r = await fetch(n);
+	if (!r.ok) throw Error("OIDC discovery request failed");
+	let i = await r.json();
+	if (i.issuer !== t.href && i.issuer !== t.href.replace(/\/$/, "")) throw Error("OIDC discovery issuer mismatch");
+	if (!i.authorization_endpoint || !i.token_endpoint || !i.jwks_uri) throw Error("OIDC discovery metadata is incomplete");
+	let a = t.protocol === "http:" && tt(t.hostname);
+	return q(i.authorization_endpoint, "authorization endpoint", { allowLoopbackHttp: a }), q(i.token_endpoint, "token endpoint", { allowLoopbackHttp: a }), q(i.jwks_uri, "JWKS URI", { allowLoopbackHttp: a }), i;
+}
+async function Xe(e, t, n, r) {
+	let i = new URLSearchParams({
+		grant_type: "authorization_code",
+		code: r,
+		redirect_uri: n,
+		client_id: t.clientId,
+		client_secret: t.clientSecret
+	}), a = await fetch(e, {
+		method: "POST",
+		headers: { "content-type": "application/x-www-form-urlencoded" },
+		body: i
+	});
+	if (!a.ok) throw Error("OIDC token request failed");
+	return await a.json();
+}
+async function Ze(e, t, n, r, i) {
+	let [a, o, s] = e.split(".");
+	if (!a || !o || !s) throw Error("Invalid OIDC id_token");
+	let c = K(a), l = K(o);
+	if (c.alg !== "RS256" || !c.kid) throw Error("Unsupported OIDC id_token signature");
+	if (l.iss !== t.issuer) throw Error("OIDC id_token issuer mismatch");
+	if (!Qe(l.aud, n)) throw Error("OIDC id_token audience mismatch");
+	if (!$e(l.aud, l.azp, n)) throw Error("OIDC id_token authorized party mismatch");
+	if (typeof l.exp != "number" || !Number.isFinite(l.exp) || l.exp * 1e3 <= i) throw Error("OIDC id_token is expired");
+	if (typeof l.iat != "number" || !Number.isFinite(l.iat)) throw Error("OIDC id_token issued-at time is missing");
+	if (l.iat * 1e3 > i + We) throw Error("OIDC id_token issued-at time is in the future");
+	if (l.nonce !== r) throw Error("OIDC id_token nonce mismatch");
+	if (!l.sub) throw Error("OIDC id_token subject is missing");
+	let u = await fetch(t.jwks_uri);
+	if (!u.ok) throw Error("OIDC JWKS request failed");
+	let d = (await u.json()).keys?.find((e) => e.kid === c.kid && e.kty === "RSA");
+	if (!d) throw Error("OIDC signing key not found");
+	let f = p({
+		key: d,
+		format: "jwk"
+	}), m = `${a}.${o}`;
+	if (!_("RSA-SHA256", Buffer.from(m), f, Buffer.from(s, "base64url"))) throw Error("OIDC id_token signature verification failed");
+	return l;
+}
+function K(e) {
+	return JSON.parse(Buffer.from(e, "base64url").toString("utf8"));
+}
+function Qe(e, t) {
+	return Array.isArray(e) ? e.includes(t) : e === t;
+}
+function $e(e, t, n) {
+	return t && t !== n ? !1 : !Array.isArray(e) || e.length <= 1 || t === n;
+}
+function et(e, t) {
+	return t.allowedSubject && e.sub === t.allowedSubject ? !0 : t.allowedEmail ? e.email_verified === !0 && e.email?.toLowerCase() === t.allowedEmail : !1;
+}
+function q(e, t, n = {}) {
+	let r = new URL(e);
+	if (r.username || r.password) throw Error(`OIDC ${t} must not include credentials`);
+	if (r.protocol !== "https:" && !(n.allowLoopbackHttp && r.protocol === "http:" && tt(r.hostname))) throw Error(`OIDC ${t} must use HTTPS`);
+}
+function tt(e) {
+	let t = e.replace(/^\[(.*)]$/, "$1").toLowerCase();
+	return t === "localhost" || t === "127.0.0.1" || t === "::1";
+}
+function J(e, t) {
+	return {
+		status: 400,
+		body: t ? {
+			error: e,
+			error_description: t
+		} : { error: e }
+	};
+}
+//#endregion
+//#region src/provider.ts
+var nt = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s;
+	constructor(e) {
+		this.#e = e.clientsStore, this.#t = e.codeStore, this.#n = e.tokenStore, this.#r = e.refreshTokenStore ?? Se(), this.#i = e.publicMcpUrl, this.#a = new URL(e.publicMcpUrl).href, this.#o = e.oidc, this.#s = e.now ?? Date.now;
+	}
+	get clientsStore() {
+		return this.#e;
+	}
+	async authorize(e, t, n) {
+		if (!this.#o) throw new T("OIDC is not configured");
+		let r = await Je(rt(e, t), this.#e, this.#o.pendingStore, this.#o.config, this.#i, this.#s());
+		if (r.status === 302) {
+			n.redirect(302, r.location);
+			return;
+		}
+		throw it(r.body);
+	}
+	async challengeForAuthorizationCode(e, t) {
+		let n = this.#t.peekCode(t);
+		if (!n) throw new x("Invalid or already used code");
+		if (n.clientId !== e.client_id) throw new x("Code does not match client");
+		if (n.expiresAt <= this.#s()) throw this.#t.consumeCode(t), new x("Expired code");
+		return n.codeChallenge;
+	}
+	async exchangeAuthorizationCode(e, t, n, r, i) {
+		let a = this.#s(), o = this.#t.peekCode(t);
+		if (!o) throw new x("Invalid or already used code");
+		if (o.expiresAt <= a) throw this.#t.consumeCode(t), new x("Expired code");
+		if (o.clientId !== e.client_id) throw this.#t.consumeCode(t), new x("Code does not match client");
+		if (r === void 0 || o.redirectUri !== r) throw this.#t.consumeCode(t), new x("Code does not match redirect_uri");
+		if ((o.resource ?? null) !== (i?.href ?? null)) throw this.#t.consumeCode(t), new x("Code does not match resource");
+		let s = ot(o.scopes) ?? [], c = this.#r.issueGrant({
+			clientId: e.client_id,
+			scopes: s,
+			resource: o.resource
+		}, a);
+		if (!c) throw new T("Too many active refresh grants");
+		let l = this.#n.issueToken(e.client_id, a, o.resource, c.grant.grantId, s);
+		if (!l) throw this.#r.revokeGrant(c.grant.grantId, a), new T("Too many active access tokens");
+		if (!this.#t.consumeCode(t)) throw this.#n.revokeToken(l.token, a), this.#r.revokeGrant(c.grant.grantId, a), new x("Authorization code already used");
+		return O.parse({
+			access_token: l.token,
+			token_type: "Bearer",
+			expires_in: l.expiresIn,
+			refresh_token: c.refreshToken
+		});
+	}
+	async exchangeRefreshToken(e, t, n, r) {
+		let i = this.#s(), a = this.#r.rotateRefreshToken(e.client_id, t, {
+			scopes: ot(n),
+			...r ? { resource: r.href } : {}
+		}, i);
+		if (!a.ok) throw a.reason === "refresh_token_replay" && a.grantId && this.#n.revokeTokensForGrant?.(a.grantId, i), new x(at(a.reason));
+		let o = this.#n.issueToken(e.client_id, i, a.grant.resource, a.grant.grantId, a.grant.scopes);
+		if (!o) throw new T("Too many active access tokens");
+		return O.parse({
+			access_token: o.token,
+			token_type: "Bearer",
+			expires_in: o.expiresIn,
+			refresh_token: a.refreshToken
+		});
+	}
+	async verifyAccessToken(e) {
+		let t = this.#n.verifyToken(e, this.#s());
+		if (!t.ok) throw new C(t.reason === "expired_token" ? "Token has expired" : t.reason === "revoked_token" ? "Token has been revoked" : "Token is invalid");
+		let n = {
+			token: e,
+			clientId: t.record.clientId,
+			scopes: t.record.scopes,
+			expiresAt: Math.floor(t.record.expiresAt / 1e3)
+		};
+		if (t.record.resource) {
+			if (new URL(t.record.resource).href !== this.#a) throw new C("Token audience does not match this resource server");
+			n.resource = new URL(t.record.resource);
+		}
+		return n;
+	}
+	async revokeToken(e, t) {
+		let n = this.#s();
+		this.#n.revokeToken(t.token, n);
+		let r = this.#r.revokeRefreshToken(t.token, n);
+		r && this.#n.revokeTokensForGrant?.(r, n);
+	}
+};
+function rt(e, t) {
+	let n = new URLSearchParams();
+	return n.set("client_id", e.client_id), n.set("redirect_uri", t.redirectUri), n.set("response_type", "code"), n.set("code_challenge", t.codeChallenge), n.set("code_challenge_method", "S256"), t.state && n.set("state", t.state), t.scopes?.length && n.set("scope", t.scopes.join(" ")), t.resource && n.set("resource", t.resource.href), n;
+}
+function it(e) {
+	let t = e.error_description ?? e.error;
+	switch (e.error) {
+		case "temporarily_unavailable": return new T(t);
+		case "invalid_request": return new S(t);
+		case "invalid_client": return new y(t);
+		case "access_denied": return new v(t);
+		case "unsupported_response_type": return new E(t);
+		default: return new w(t);
+	}
+}
+function at(e) {
+	switch (e) {
+		case "expired_refresh_token": return "Refresh token has expired";
+		case "revoked_refresh_token": return "Refresh token has been revoked";
+		case "client_mismatch": return "Refresh token does not match client";
+		case "scope_mismatch": return "Refresh token scope cannot be expanded";
+		case "resource_mismatch": return "Refresh token does not match resource";
+		case "refresh_token_replay": return "Refresh token replay detected";
+		default: return "Invalid refresh token";
+	}
+}
+function ot(e) {
+	let t = e?.map((e) => e.trim()).filter(Boolean).map((e) => e === "memory:read_access" ? "memory:read" : e === "memory:write_access" ? "memory:write" : e);
+	return t && t.length > 0 ? t : void 0;
+}
+//#endregion
+//#region src/http.ts
+var st = "127.0.0.1", Y = 38889, ct = 80, lt = /^[a-zA-Z0-9.-]+$/, ut = new Set([
+	"127.0.0.1",
+	"::1",
+	"localhost"
+]);
+function dt(e, t = !1) {
+	let r = e?.trim() || "127.0.0.1";
+	if (r.includes("://") || r.includes("/") || r.includes("\\") || !(n(r) || r === "localhost" || lt.test(r))) throw Error(`Invalid MCP HTTP host: ${e}`);
+	if (!t && !X(r)) throw Error(`Refusing unsafe MCP HTTP host ${r}; set CODEMEM_MCP_HTTP_UNSAFE_PUBLIC=1 to allow non-loopback binding`);
+	return r;
+}
+function X(e) {
+	return ut.has(Z(e));
+}
+function ft(e = process.env.CODEMEM_MCP_HTTP_UNSAFE_PUBLIC) {
+	return e === "1" || e?.toLowerCase() === "true" || e?.toLowerCase() === "yes";
+}
+function pt(e, t) {
+	let n = gt(e);
+	return !n || !X(n.host) ? !1 : n.port === null ? t === ct : n.port === t;
+}
+function mt(e, t) {
+	if (!e) return !0;
+	try {
+		let n = new URL(e), r = n.port ? Number(n.port) : n.protocol === "https:" ? 443 : 80;
+		return (n.protocol === "http:" || n.protocol === "https:") && n.username === "" && n.password === "" && n.pathname === "/" && n.search === "" && n.hash === "" && X(n.hostname) && r === t;
+	} catch {
+		return !1;
+	}
+}
+function ht(e) {
+	return e ? X(e.replace(/^::ffff:/, "")) : !1;
+}
+function Z(e) {
+	return e.replace(/^\[(.*)]$/, "$1").toLowerCase();
+}
+function gt(e) {
+	if (!e) return null;
+	if (e.startsWith("[")) {
+		let t = /^\[([^\]]+)]:(\d+)$/.exec(e);
+		if (t?.[1] && t[2]) return {
+			host: t[1],
+			port: Number(t[2])
+		};
+		let n = /^\[([^\]]+)]$/.exec(e);
+		return n?.[1] ? {
+			host: n[1],
+			port: null
+		} : null;
+	}
+	let t = e.lastIndexOf(":");
+	if (t < 0) return {
+		host: e,
+		port: null
+	};
+	let n = e.slice(0, t), r = Number(e.slice(t + 1));
+	return Number.isInteger(r) ? {
+		host: n,
+		port: r
+	} : null;
+}
+function Q(e) {
+	if (e === void 0 || e === "") return Y;
+	let t = typeof e == "number" ? e : Number(e);
+	if (!Number.isInteger(t) || t < 0 || t > 65535) throw Error(`Invalid MCP HTTP port: ${e}`);
+	return t;
+}
+async function _t(n = {}) {
+	let r = dt(n.host ?? process.env.CODEMEM_MCP_HTTP_HOST, n.allowUnsafePublic ?? ft()), s = Q(n.port ?? process.env.CODEMEM_MCP_HTTP_PORT), f = n.publicUrl ?? process.env.CODEMEM_MCP_HTTP_PUBLIC_URL, p = f ? L(f) : void 0, m = new i(n.dbPath ?? a()), h = ye(), g = be(), _ = n.oauthAccessTokenStore ?? xe(), v = qe(), y = Ke(), b = p !== void 0 || v !== void 0, x = te(n.auditEmitter ?? ie()), S = /* @__PURE__ */ new Set(), C = null, w = d();
+	w.disable("x-powered-by"), w.set("trust proxy", "loopback");
+	let T = t(w);
+	await new Promise((e, t) => {
+		T.once("error", t), T.listen({
+			host: r,
+			port: s
+		}, () => {
+			T.off("error", t), e();
+		});
+	});
+	let E = p?.href ?? wt(T, r), D = new URL(E), O = Tt(D, $(T)), k = new nt({
+		clientsStore: h,
+		codeStore: g,
+		tokenStore: _,
+		publicMcpUrl: E,
+		...v ? { oidc: {
+			config: v,
+			pendingStore: y
+		} } : {}
+	}), ee = c(D);
+	w.use((e, t, n) => {
+		let r = $(T), i = Dt(e.path);
+		if (i === "/mcp") {
+			if (vt(e, r, p)) return n();
+			t.status(403).type("text/plain").send("Forbidden");
+			return;
+		}
+		if (Et(i)) {
+			if (bt(e, r, p)) return n();
+			t.status(403).type("text/plain").send("Forbidden");
+			return;
+		}
+		n();
+	}), w.use(Ot(x)), w.get("/oauth/callback", async (e, t) => {
+		let n = e.socket.remoteAddress ?? void 0;
+		if (!v) {
+			x(A("oidc_callback", {
+				outcome: "denied",
+				reason: "oidc_not_configured",
+				remoteAddress: n
+			})), t.status(400).json({
+				error: "temporarily_unavailable",
+				error_description: "OIDC is not configured"
+			});
+			return;
+		}
+		let r = await Ye(new URLSearchParams(e.query), y, v, E);
+		if ("status" in r) {
+			x(A("oidc_callback", {
+				outcome: "denied",
+				reason: r.body.error,
+				remoteAddress: n
+			})), t.status(r.status).json(r.body);
+			return;
+		}
+		let i = r.oauthParams.get("client_id") ?? void 0, a = g.issueCode({
+			clientId: r.oauthParams.get("client_id") ?? "",
+			redirectUri: r.oauthParams.get("redirect_uri") ?? "",
+			codeChallenge: r.oauthParams.get("code_challenge") ?? "",
+			scopes: Lt(r.oauthParams.get("scope")),
+			...r.oauthParams.get("resource") ? { resource: r.oauthParams.get("resource") ?? void 0 } : {},
+			expiresAt: Date.now() + 300 * 1e3
+		});
+		if (!a) {
+			x(A("oidc_callback", {
+				outcome: "denied",
+				reason: "temporarily_unavailable",
+				clientId: i,
+				remoteAddress: n
+			})), t.status(400).json({
+				error: "temporarily_unavailable",
+				error_description: "Too many active authorization codes"
+			});
+			return;
+		}
+		let o = new URL(r.oauthParams.get("redirect_uri") ?? "");
+		o.searchParams.set("code", a);
+		let s = r.oauthParams.get("state");
+		s && o.searchParams.set("state", s), x(A("oidc_callback", {
+			outcome: "success",
+			reason: "code_issued",
+			clientId: i,
+			remoteAddress: n
+		})), t.redirect(302, o.href);
+	}), w.get("/.well-known/oauth-authorization-server", (e, t) => {
+		t.status(200).json(Ce({
+			mcpUrl: E,
+			clientsStore: h
+		}));
+	}), w.get("/.well-known/oauth-protected-resource/mcp", (e, t) => {
+		t.status(200).json(we(E));
+	}), w.use(l({
+		provider: k,
+		issuerUrl: O,
+		baseUrl: O,
+		resourceServerUrl: D,
+		resourceName: ae,
+		scopesSupported: j,
+		serviceDocumentationUrl: new URL(M),
+		clientRegistrationOptions: { clientSecretExpirySeconds: 0 }
+	}));
+	let ne = b ? o({
+		verifier: k,
+		resourceMetadataUrl: ee
+	}) : (e, t, n) => n(), re = b ? Ft(x, _) : (e, t, n) => n();
+	return w.post("/mcp", re, ne, async (t, n) => {
+		t.auth && x(A("bearer", {
+			outcome: "success",
+			clientId: t.auth.clientId,
+			remoteAddress: t.socket.remoteAddress ?? void 0
+		}));
+		let r = e(m), i = new u({ sessionIdGenerator: void 0 }), a = { mcpServer: r };
+		S.add(a);
+		try {
+			await r.connect(i), await i.handleRequest(t, n);
+		} finally {
+			S.delete(a), await r.close();
+		}
+	}), w.all("/mcp", (e, t) => {
+		t.setHeader("Allow", "POST"), t.status(405).type("text/plain").send("Method not allowed");
+	}), w.use((e, t) => {
+		t.status(404).type("text/plain").send("Not found");
+	}), {
+		server: T,
+		store: m,
+		url: `http://${Ct(r)}:${$(T)}/mcp`,
+		close: () => (C ??= (async () => {
+			await Promise.allSettled([...S].map(({ mcpServer: e }) => e.close())), await new Promise((e, t) => {
+				T.close((n) => {
+					if (!n || n.code === "ERR_SERVER_NOT_RUNNING") {
+						e();
+						return;
+					}
+					t(n);
+				}), T.closeAllConnections();
+			}), m.close();
+		})(), C)
+	};
+}
+function vt(e, t, n) {
+	return yt(e, t) ? !0 : n ? St(e.headers.host, n) && xt(e.headers.origin, n) : !1;
+}
+function yt(e, t) {
+	return ht(e.socket.remoteAddress) && pt(e.headers.host, t) && mt(e.headers.origin, t);
+}
+function bt(e, t, n) {
+	return yt(e, t) ? !0 : n ? St(e.headers.host, n) && xt(e.headers.origin, n) : !1;
+}
+function xt(e, t) {
+	if (!e) return !0;
+	try {
+		return new URL(e).origin === t.origin;
+	} catch {
+		return !1;
+	}
+}
+function St(e, t) {
+	let n = gt(e);
+	if (!n) return !1;
+	let r = t.port ? Number(t.port) : t.protocol === "https:" ? 443 : 80, i = n.port ?? r;
+	return Z(n.host) === Z(t.hostname) && i === r;
+}
+function $(e) {
+	let t = e.address();
+	return !t || typeof t == "string" ? Y : t.port;
+}
+function Ct(e) {
+	return n(e) === 6 ? `[${e}]` : e;
+}
+function wt(e, t) {
+	return `http://${Ct(t)}:${$(e)}/mcp`;
+}
+function Tt(e, t) {
+	return e.protocol === "https:" || X(e.hostname) && Z(e.hostname) !== "::1" ? new URL(e.origin) : new URL(`http://localhost:${t}/`);
+}
+function Et(e) {
+	return e === "/register" || e === "/authorize" || e === "/token" || e === "/revoke" || e === "/oauth/callback" || e === "/.well-known/oauth-authorization-server" || e === "/.well-known/oauth-protected-resource/mcp";
+}
+function Dt(e) {
+	return e.length > 1 ? e.replace(/\/+$/, "") : e;
+}
+function Ot(e) {
+	return (t, n, r) => {
+		let i = t.path;
+		if (!kt(i)) return r();
+		let a, o = n.json.bind(n);
+		n.json = ((e) => (a = e, o(e))), n.on("finish", () => {
+			if (i === "/oauth/callback") return;
+			let r = At(i, t);
+			if (!r) return;
+			let o = Mt(n, a), s = Pt(t, a);
+			e(A(r, {
+				outcome: o ? "denied" : "success",
+				...o ? { reason: o } : {},
+				...s ? { clientId: s } : {},
+				remoteAddress: t.socket.remoteAddress ?? void 0
+			}));
+		}), r();
+	};
+}
+function kt(e) {
+	return jt(e) !== null;
+}
+function At(e, t) {
+	return e === "/token" && t.body?.grant_type === "refresh_token" ? "refresh" : jt(e);
+}
+function jt(e) {
+	return e === "/register" ? "registration" : e === "/authorize" ? "authorize" : e === "/token" ? "token" : e === "/revoke" ? "revocation" : null;
+}
+function Mt(e, t) {
+	let n = Nt(t);
+	if (n) return n;
+	let r = e.getHeader("location");
+	if (typeof r == "string") try {
+		return new URL(r).searchParams.get("error") ?? void 0;
+	} catch {
+		return;
+	}
+}
+function Nt(e) {
+	if (typeof e == "object" && e && "error" in e && typeof e.error == "string") return e.error;
+}
+function Pt(e, t) {
+	return typeof t == "object" && t && "client_id" in t && typeof t.client_id == "string" ? t.client_id : (typeof e.body?.client_id == "string" ? e.body.client_id : void 0) || (typeof e.query.client_id == "string" ? e.query.client_id : void 0);
+}
+function Ft(e, t) {
+	return (n, r, i) => {
+		let a = It(n.headers.authorization, t);
+		a && e(A("bearer", {
+			outcome: "denied",
+			reason: a,
+			remoteAddress: n.socket.remoteAddress ?? void 0
+		})), i();
+	};
+}
+function It(e, t) {
+	if (!e) return "missing_authorization_header";
+	let [n, r, i] = e.trim().split(/\s+/);
+	if (!n || !r || i || n.toLowerCase() !== "bearer") return "malformed_authorization_header";
+	let a = t.verifyToken(r);
+	return a.ok ? null : a.reason;
+}
+function Lt(e) {
+	return e?.split(/\s+/).map((e) => e.trim()).filter(Boolean) ?? [];
+}
+function Rt() {
+	let e = process.argv[1];
+	return e ? import.meta.url === r(e).href : !1;
+}
+async function zt() {
+	let e = await _t();
+	console.error(`codemem MCP HTTP server listening at ${e.url}`);
+	let t = async () => {
+		try {
+			await e.close();
+		} catch {}
+		process.exit(0);
+	};
+	process.on("SIGINT", t), process.on("SIGTERM", t);
+}
+Rt() && zt().catch((e) => {
+	console.error("codemem MCP HTTP server failed to start:", e), process.exit(1);
+});
+//#endregion
+export { st as DEFAULT_MCP_HTTP_HOST, Y as DEFAULT_MCP_HTTP_PORT, pt as isAllowedMcpHttpRequestHost, mt as isAllowedMcpHttpRequestOrigin, ht as isAllowedMcpHttpRequestRemoteAddress, X as isLoopbackHost, ft as isUnsafePublicBindAllowed, Q as parseMcpHttpPort, _t as startCodememMcpHttpServer, dt as validateMcpHttpHost };
+
+//# sourceMappingURL=http.js.map