@upstash/context7-mcp 4.0.2 → 4.0.4

package/dist/index.js

@@ -10,9 +10,8 @@ import express from "express";
 import { Command } from "commander";
 import { AsyncLocalStorage } from "async_hooks";
 import { randomUUID } from "node:crypto";
-import { SERVER_VERSION, RESOURCE_URL, AUTH_SERVER_URL, OPENAI_APPS_CHALLENGE_TOKEN, } from "./lib/constants.js";
+import { SERVER_VERSION, RESOURCE_URL, OAUTH_AUTH_SERVER_URL, EMA_ISSUER, OPENAI_APPS_CHALLENGE_TOKEN, } from "./lib/constants.js";
 import { maybeElicitAuthSignIn } from "./lib/auth/auth-prompt.js";
-import { getClientIp } from "./lib/client-ip.js";
 /** Default HTTP server port */
 const DEFAULT_PORT = 3000;
 // Parse CLI arguments using commander
@@ -242,6 +241,9 @@ async function main() {
     if (TRANSPORT_TYPE === "http") {
         const initialPort = CLI_PORT ?? DEFAULT_PORT;
         const app = express();
+        // Only private/local infrastructure may supply forwarding headers. Express
+        // then walks the chain right-to-left and ignores attacker-added prefixes.
+        app.set("trust proxy", ["loopback", "linklocal", "uniquelocal", "100.64.0.0/10"]);
         app.use(express.json());
         app.use((req, res, next) => {
             res.setHeader("Access-Control-Allow-Origin", "*");
@@ -273,6 +275,7 @@ async function main() {
         };
         const extractApiKey = (req) => {
             return (extractBearerToken(req.headers.authorization) ||
+                extractHeaderValue(req.headers["x-context7-api-key"]) ||
                 extractHeaderValue(req.headers["context7-api-key"]) ||
                 extractHeaderValue(req.headers["x-api-key"]) ||
                 extractHeaderValue(req.headers["context7_api_key"]) ||
@@ -336,7 +339,7 @@ async function main() {
                     }
                 }
                 const context = {
-                    clientIp: getClientIp(req),
+                    clientIp: req.ip,
                     apiKey: apiKey,
                     clientInfo: extractClientInfoFromUserAgent(req.headers["user-agent"]),
                     transport: "http",
@@ -372,13 +375,16 @@ async function main() {
         app.get("/.well-known/oauth-protected-resource", (_req, res) => {
             res.json({
                 resource: RESOURCE_URL,
-                authorization_servers: [AUTH_SERVER_URL],
+                // Each entry is an independent authorization server. Clerk handles
+                // regular authorization-code flows; Context7 handles only the
+                // enterprise-managed id-jag exchange.
+                authorization_servers: Array.from(new Set([OAUTH_AUTH_SERVER_URL, EMA_ISSUER])),
                 scopes_supported: ["profile", "email"],
                 bearer_methods_supported: ["header"],
             });
         });
         app.get("/.well-known/oauth-authorization-server", async (_req, res) => {
-            const authServerUrl = AUTH_SERVER_URL;
+            const authServerUrl = OAUTH_AUTH_SERVER_URL;
             try {
                 const response = await fetch(`${authServerUrl}/.well-known/oauth-authorization-server`);
                 if (!response.ok) {

package/dist/lib/constants.js

@@ -6,12 +6,20 @@ const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-
 export const SERVER_VERSION = pkg.version;
 const CONTEXT7_BASE_URL = "https://context7.com";
 const MCP_RESOURCE_URL = "https://mcp.context7.com";
-export const CLERK_DOMAIN = "clerk.context7.com";
+const DEFAULT_OAUTH_AUTH_SERVER_URL = "https://clerk.context7.com";
 export const CONTEXT7_API_BASE_URL = process.env.CONTEXT7_API_URL || `${CONTEXT7_BASE_URL}/api`;
 export const RESOURCE_URL = process.env.RESOURCE_URL || MCP_RESOURCE_URL;
-export const AUTH_SERVER_URL = process.env.AUTH_SERVER_URL || CONTEXT7_BASE_URL;
+// Clerk owns the interactive OAuth flow and is the issuer returned in the
+// authorization response. Advertising Clerk directly keeps RFC 8414 discovery
+// and RFC 9207 response-issuer validation on the same authorization-server
+// identity.
+export const OAUTH_AUTH_SERVER_URL = (process.env.OAUTH_AUTH_SERVER_URL || DEFAULT_OAUTH_AUTH_SERVER_URL).replace(/\/+$/, "");
+export const OAUTH_JWKS_URL = process.env.OAUTH_JWKS_URL || `${OAUTH_AUTH_SERVER_URL}/.well-known/jwks.json`;
 // Enterprise-Managed Auth (id-jag): access tokens minted by the Context7
 // authorization server, validated against its public JWKS.
-export const EMA_ISSUER = AUTH_SERVER_URL;
+// AUTH_SERVER_URL remains a backwards-compatible alias for local EMA setups;
+// it does not move interactive user OAuth. Local end-to-end OAuth environments
+// must set OAUTH_AUTH_SERVER_URL separately when Clerk is not the intended issuer.
+export const EMA_ISSUER = process.env.EMA_ISSUER || process.env.AUTH_SERVER_URL || CONTEXT7_BASE_URL;
 export const EMA_JWKS_URL = process.env.EMA_JWKS_URL || `${CONTEXT7_API_BASE_URL}/oauth/ema-jwks`;
 export const OPENAI_APPS_CHALLENGE_TOKEN = process.env.OPENAI_APPS_CHALLENGE_TOKEN;

package/dist/lib/encryption.js

@@ -1,27 +1,59 @@
 import { createCipheriv, randomBytes } from "crypto";
+import { isIP } from "node:net";
 import { SERVER_VERSION } from "./constants.js";
-const DEFAULT_ENCRYPTION_KEY = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
-const ENCRYPTION_KEY = process.env.CLIENT_IP_ENCRYPTION_KEY || DEFAULT_ENCRYPTION_KEY;
-const ALGORITHM = "aes-256-cbc";
+const LEGACY_ALGORITHM = "aes-256-cbc";
+const ASSERTION_ALGORITHM = "aes-256-gcm";
+const ASSERTION_VERSION = "v1";
+let reportedInvalidAssertionKey = false;
 function validateEncryptionKey(key) {
     // Must be exactly 64 hex characters (32 bytes)
     return /^[0-9a-fA-F]{64}$/.test(key);
 }
-function encryptClientIp(clientIp) {
-    if (!validateEncryptionKey(ENCRYPTION_KEY)) {
-        console.error("Invalid encryption key format. Must be 64 hex characters.");
-        return clientIp; // Fallback to unencrypted
-    }
+function encryptionKey(name) {
+    const key = process.env[name];
+    return key && validateEncryptionKey(key) ? Buffer.from(key, "hex") : null;
+}
+/**
+ * Temporary compatibility header for API deployments that predate authenticated assertions.
+ * This header is ignored by patched API deployments. Removal is tracked by CTX7-2536.
+ */
+function encryptLegacyClientIp(clientIp, key) {
     try {
         const iv = randomBytes(16);
-        const cipher = createCipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY, "hex"), iv);
-        let encrypted = cipher.update(clientIp, "utf8", "hex");
-        encrypted += cipher.final("hex");
-        return iv.toString("hex") + ":" + encrypted;
+        const cipher = createCipheriv(LEGACY_ALGORITHM, key, iv);
+        const encrypted = Buffer.concat([cipher.update(clientIp, "utf8"), cipher.final()]);
+        return `${iv.toString("hex")}:${encrypted.toString("hex")}`;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create a short-lived, authenticated client-IP assertion.
+ * Format: v1:<unix timestamp seconds>:<12-byte nonce hex>:<ciphertext + tag hex>
+ */
+export function createClientIpAssertion(clientIp, nowMs = Date.now(), nonce = randomBytes(12)) {
+    const key = encryptionKey("MCP_CLIENT_IP_ASSERTION_KEY");
+    if (!key) {
+        if (!reportedInvalidAssertionKey) {
+            reportedInvalidAssertionKey = true;
+            console.error("MCP_CLIENT_IP_ASSERTION_KEY is missing or invalid; client IP assertions are disabled.");
+        }
+        return null;
+    }
+    if (nonce.length !== 12 || isIP(clientIp) === 0)
+        return null;
+    try {
+        const timestamp = Math.floor(nowMs / 1000).toString();
+        const aad = `${ASSERTION_VERSION}:${timestamp}`;
+        const cipher = createCipheriv(ASSERTION_ALGORITHM, key, nonce);
+        cipher.setAAD(Buffer.from(aad, "utf8"));
+        const ciphertext = Buffer.concat([cipher.update(clientIp, "utf8"), cipher.final()]);
+        const ciphertextAndTag = Buffer.concat([ciphertext, cipher.getAuthTag()]);
+        return `${aad}:${nonce.toString("hex")}:${ciphertextAndTag.toString("hex")}`;
     }
-    catch (error) {
-        console.error("Error encrypting client IP:", error);
-        return clientIp; // Fallback to unencrypted
+    catch {
+        return null;
     }
 }
 /**
@@ -34,7 +66,15 @@ export function generateHeaders(context) {
         "X-Context7-Server-Version": SERVER_VERSION,
     };
     if (context.clientIp) {
-        headers["mcp-client-ip"] = encryptClientIp(context.clientIp);
+        const assertion = createClientIpAssertion(context.clientIp);
+        if (assertion) {
+            headers["mcp-client-ip-assertion"] = assertion;
+            // Producer-first rollout compatibility. Removal is tracked by CTX7-2536.
+            const key = encryptionKey("CLIENT_IP_ENCRYPTION_KEY");
+            const legacyValue = key ? encryptLegacyClientIp(context.clientIp, key) : null;
+            if (legacyValue)
+                headers["mcp-client-ip"] = legacyValue;
+        }
     }
     if (context.sessionId) {
         headers["mcp-session-id"] = context.sessionId;

package/dist/lib/jwt.js

@@ -1,7 +1,6 @@
 import * as jose from "jose";
-import { CLERK_DOMAIN, CONTEXT7_API_BASE_URL, EMA_ISSUER, EMA_JWKS_URL, RESOURCE_URL, } from "./constants.js";
-const CLERK_ISSUER = `https://${CLERK_DOMAIN}`;
-const clerkJwks = jose.createRemoteJWKSet(new URL(`https://${CLERK_DOMAIN}/.well-known/jwks.json`));
+import { CONTEXT7_API_BASE_URL, EMA_ISSUER, EMA_JWKS_URL, OAUTH_AUTH_SERVER_URL, OAUTH_JWKS_URL, RESOURCE_URL, } from "./constants.js";
+const oauthJwks = jose.createRemoteJWKSet(new URL(OAUTH_JWKS_URL));
 const emaJwks = jose.createRemoteJWKSet(new URL(EMA_JWKS_URL));
 const ENTRA_V2_ISSUER_RE = /^https:\/\/login\.microsoftonline\.com\/[0-9a-f-]{36}\/v2\.0$/;
 const jwksByTenant = new Map();
@@ -70,7 +69,7 @@ export async function validateJWT(token) {
             await jose.jwtVerify(token, emaJwks, { issuer: EMA_ISSUER, audience: RESOURCE_URL });
             return { valid: true };
         }
-        await jose.jwtVerify(token, clerkJwks, { issuer: CLERK_ISSUER });
+        await jose.jwtVerify(token, oauthJwks, { issuer: OAUTH_AUTH_SERVER_URL });
         return { valid: true };
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@upstash/context7-mcp",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "mcpName": "io.github.upstash/context7",
   "description": "MCP server for Context7",
   "repository": {

package/dist/lib/client-ip.js

@@ -1,60 +0,0 @@
-function stripIpv4MappedPrefix(ip) {
-    return ip.replace(/^::ffff:/i, "");
-}
-/**
- * Returns true for RFC1918, CGNAT, loopback, link-local, and IPv6 private ranges.
- */
-export function isPrivateOrLocalIp(ip) {
-    const plainIp = stripIpv4MappedPrefix(ip).toLowerCase();
-    if (plainIp.includes(".")) {
-        return (plainIp.startsWith("10.") ||
-            plainIp.startsWith("192.168.") ||
-            /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(plainIp) ||
-            /^100\.(6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7])\./.test(plainIp) ||
-            plainIp.startsWith("127.") ||
-            plainIp.startsWith("169.254."));
-    }
-    // ::1 loopback in any textual form (e.g. "0::1", "0:0:0:0:0:0:0:1")
-    if (/^[0:]+1$/.test(plainIp)) {
-        return true;
-    }
-    // First hextets in fe80::/10 and fc00::/7 start with a non-zero digit, so a
-    // valid textual form always spells out all 4 digits.
-    // fe80::/10 link-local
-    if (/^fe[89ab][0-9a-f]:/.test(plainIp)) {
-        return true;
-    }
-    // fc00::/7 unique local
-    if (/^f[cd][0-9a-f]{2}:/.test(plainIp)) {
-        return true;
-    }
-    return false;
-}
-function pickClientIpFromForwardedList(ipList) {
-    for (const ip of ipList) {
-        const plainIp = stripIpv4MappedPrefix(ip);
-        if (!isPrivateOrLocalIp(plainIp)) {
-            return plainIp;
-        }
-    }
-    if (ipList.length === 0) {
-        return undefined;
-    }
-    return stripIpv4MappedPrefix(ipList[0]);
-}
-/**
- * Extract client IP address from request headers.
- * Handles X-Forwarded-For header for proxied requests.
- */
-export function getClientIp(req) {
-    const forwardedFor = req.headers["x-forwarded-for"] || req.headers["X-Forwarded-For"];
-    if (forwardedFor) {
-        const ips = Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor;
-        const ipList = ips.split(",").map((ip) => ip.trim());
-        return pickClientIpFromForwardedList(ipList);
-    }
-    if (req.socket?.remoteAddress) {
-        return stripIpv4MappedPrefix(req.socket.remoteAddress);
-    }
-    return undefined;
-}