@upstash/context7-mcp 4.0.4 → 4.0.6

package/README.md

@@ -1621,6 +1621,34 @@ Stay updated and join our community:
 - [AICodeKing: "Context7 + Cline & RooCode: This MCP Server Makes CLINE 100X MORE EFFECTIVE!"](https://www.youtube.com/watch?v=qZfENAPMnyo)
 - [Sean Kochel: "5 MCP Servers For Vibe Coding Glory (Just Plug-In & Go)"](https://www.youtube.com/watch?v=LqTQi8qexJM)
 
+## Vercel Marketplace OIDC
+
+Vercel Marketplace resources can call the remote MCP server without a
+long-lived Context7 API key. Obtain a fresh per-resource access token from
+Vercel's Marketplace integration runtime and send it as the bearer credential:
+
+```ts
+import { getIntegrationToken } from "@vercel/integrations";
+
+const authorization = `Bearer ${await getIntegrationToken("context7")}`;
+```
+
+The `getIntegrationToken` signature is based on Vercel's current provider
+specification and may change before Marketplace OIDC is generally available.
+
+Use `authorization` as the `Authorization` header when creating the MCP HTTP
+transport. Create the transport inside the request that uses it so a short-lived
+token is not retained across function invocations. Its `resource` claim must
+match the Context7 resource created during Marketplace provisioning.
+
+The hosted MCP service must be configured with the exact issuer and audience
+assigned by Vercel when the Context7 Marketplace product is created:
+
+```sh
+VERCEL_MARKETPLACE_OIDC_ISSUER=https://integrations.vercel.com/oac_...
+VERCEL_MARKETPLACE_OIDC_AUDIENCE=https://integrations.vercel.com/context7/icfg_...
+```
+
 ## 📄 License
 
 MIT

package/dist/index.js

@@ -12,8 +12,18 @@ import { AsyncLocalStorage } from "async_hooks";
 import { randomUUID } from "node:crypto";
 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 { getMaxSubscriptions } from "./lib/subscriptions.js";
+import { mcpBodyErrorHandler } from "./lib/mcp-body-error-handler.js";
 /** Default HTTP server port */
 const DEFAULT_PORT = 3000;
+const CLAUDE_CODE_PLUGIN = "claude-code-plugin";
+function getPluginFromRequest(req) {
+    return req.query.client === CLAUDE_CODE_PLUGIN ? CLAUDE_CODE_PLUGIN : undefined;
+}
+function requiresAuthentication(req, plugin) {
+    // The MCP routes live on a router mounted at /mcp, so req.path is relative to it.
+    return `${req.baseUrl}${req.path}` === "/mcp/oauth" || Boolean(plugin);
+}
 // Parse CLI arguments using commander
 const program = new Command()
     .version(SERVER_VERSION, "-v, --version", "output the current version")
@@ -244,7 +254,9 @@ async function main() {
         // 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());
+        // Registered ahead of the MCP router so its error responses carry the CORS
+        // headers too; browser clients would otherwise see a CORS failure instead
+        // of the status.
         app.use((req, res, next) => {
             res.setHeader("Access-Control-Allow-Origin", "*");
             res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,DELETE");
@@ -296,6 +308,7 @@ async function main() {
         // go idle and the gateway reaps them at streamIdleTimeout (300s).
         const mcpHandler = createMcpHandler(() => createMcpServer(), {
             keepAliveMs: 0,
+            maxSubscriptions: getMaxSubscriptions(),
             onerror: (error) => console.error("MCP handler error:", error),
         });
         // Without onerror, request-conversion / handler.fetch throws are answered
@@ -303,8 +316,9 @@ async function main() {
         const nodeHandler = toNodeHandler(mcpHandler, {
             onerror: (error) => console.error("MCP node adapter error:", error),
         });
-        const handleMcpRequest = async (req, res, requireAuth) => {
+        const handleMcpRequest = async (req, res) => {
             try {
+                const plugin = getPluginFromRequest(req);
                 const apiKey = extractApiKey(req);
                 const baseUrl = new URL(RESOURCE_URL).origin;
                 // OAuth discovery info header, used by MCP clients to discover the authorization server
@@ -313,7 +327,7 @@ async function main() {
                 // oauthMetadataResponse) — replace this hand-rolled header and the
                 // /.well-known/oauth-protected-resource route with them.
                 res.set("WWW-Authenticate", `Bearer resource_metadata="${baseUrl}/.well-known/oauth-protected-resource"`);
-                if (requireAuth) {
+                if (requiresAuthentication(req, plugin)) {
                     if (!apiKey) {
                         return res.status(401).json({
                             jsonrpc: "2.0",
@@ -340,8 +354,9 @@ async function main() {
                 }
                 const context = {
                     clientIp: req.ip,
-                    apiKey: apiKey,
+                    apiKey,
                     clientInfo: extractClientInfoFromUserAgent(req.headers["user-agent"]),
+                    plugin,
                     transport: "http",
                 };
                 await requestContext.run(context, async () => {
@@ -359,14 +374,16 @@ async function main() {
                 }
             }
         };
-        // Anonymous access endpoint - no authentication required
-        app.all("/mcp", async (req, res) => {
-            await handleMcpRequest(req, res, false);
-        });
+        // JSON bodies and JSON-RPC error envelopes are the MCP contract only, so the
+        // parser and its error boundary live on the MCP router: every other route
+        // stays out of the parser and keeps its own response shape.
+        const mcpRouter = express.Router();
+        mcpRouter.use(express.json());
+        mcpRouter.use(mcpBodyErrorHandler);
+        mcpRouter.all("/", (req, res) => handleMcpRequest(req, res));
         // OAuth-protected endpoint - requires authentication
-        app.all("/mcp/oauth", async (req, res) => {
-            await handleMcpRequest(req, res, true);
-        });
+        mcpRouter.all("/oauth", (req, res) => handleMcpRequest(req, res));
+        app.use("/mcp", mcpRouter);
         app.get("/ping", (_req, res) => {
             res.json({ status: "ok", message: "pong" });
         });

package/dist/lib/encryption.js

@@ -1,7 +1,6 @@
 import { createCipheriv, randomBytes } from "crypto";
 import { isIP } from "node:net";
 import { SERVER_VERSION } from "./constants.js";
-const LEGACY_ALGORITHM = "aes-256-cbc";
 const ASSERTION_ALGORITHM = "aes-256-gcm";
 const ASSERTION_VERSION = "v1";
 let reportedInvalidAssertionKey = false;
@@ -9,31 +8,16 @@ function validateEncryptionKey(key) {
     // Must be exactly 64 hex characters (32 bytes)
     return /^[0-9a-fA-F]{64}$/.test(key);
 }
-function encryptionKey(name) {
-    const key = process.env[name];
+function assertionKey() {
+    const key = process.env.MCP_CLIENT_IP_ASSERTION_KEY;
     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(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");
+    const key = assertionKey();
     if (!key) {
         if (!reportedInvalidAssertionKey) {
             reportedInvalidAssertionKey = true;
@@ -67,14 +51,8 @@ export function generateHeaders(context) {
     };
     if (context.clientIp) {
         const assertion = createClientIpAssertion(context.clientIp);
-        if (assertion) {
+        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;
@@ -88,6 +66,9 @@ export function generateHeaders(context) {
     if (context.clientInfo?.version) {
         headers["X-Context7-Client-Version"] = context.clientInfo.version;
     }
+    if (context.plugin) {
+        headers["X-Context7-Plugin"] = context.plugin;
+    }
     if (context.transport) {
         headers["X-Context7-Transport"] = context.transport;
     }

package/dist/lib/jwt.js

@@ -1,5 +1,6 @@
 import * as jose from "jose";
 import { CONTEXT7_API_BASE_URL, EMA_ISSUER, EMA_JWKS_URL, OAUTH_AUTH_SERVER_URL, OAUTH_JWKS_URL, RESOURCE_URL, } from "./constants.js";
+import { isVercelMarketplaceIssuer, validateVercelMarketplaceJwt } from "./vercelMarketplaceJwt.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$/;
@@ -69,6 +70,9 @@ export async function validateJWT(token) {
             await jose.jwtVerify(token, emaJwks, { issuer: EMA_ISSUER, audience: RESOURCE_URL });
             return { valid: true };
         }
+        if (isVercelMarketplaceIssuer(iss)) {
+            return validateVercelMarketplaceJwt(token, iss);
+        }
         await jose.jwtVerify(token, oauthJwks, { issuer: OAUTH_AUTH_SERVER_URL });
         return { valid: true };
     }

package/dist/lib/mcp-body-error-handler.js

@@ -0,0 +1,23 @@
+// Error boundary for the MCP router's JSON body parser. express.json() reports
+// a body it will not accept via next(err); left unhandled, Express answers with
+// an HTML stack trace naming dependency versions and absolute paths.
+export const mcpBodyErrorHandler = (err, req, res, next) => {
+    const { status, type } = err;
+    // body-parser tags every rejection with a 4xx; anything else is not a body
+    // problem. Once a response has started, only Express can wind it down.
+    if (typeof status !== "number" || status < 400 || status >= 500 || res.headersSent) {
+        return next(err);
+    }
+    // Method, path and size only: the body is the rejected input, and the
+    // headers carry the API key.
+    console.error(`Rejected request body (${status}, ${String(type ?? "unknown")}): ${req.method} ${req.baseUrl}${req.path} bytes=${req.headers["content-length"] ?? "unknown"}`);
+    // Fixed messages: body-parser's own quote offsets into the body.
+    const parseFailure = err instanceof SyntaxError && type === "entity.parse.failed";
+    res.status(status).json({
+        jsonrpc: "2.0",
+        error: parseFailure
+            ? { code: -32700, message: "Parse error" }
+            : { code: -32600, message: "Invalid Request" },
+        id: null,
+    });
+};

package/dist/lib/subscriptions.js

@@ -0,0 +1,11 @@
+// 16k stayed near baseline latency in Docker; 32,768 raised tools/list p95 to ~39 ms.
+export const DEFAULT_MAX_SUBSCRIPTIONS = 16_000;
+export function getMaxSubscriptions(value = process.env.MCP_MAX_SUBSCRIPTIONS) {
+    if (value === undefined)
+        return DEFAULT_MAX_SUBSCRIPTIONS;
+    const parsed = Number(value);
+    if (Number.isSafeInteger(parsed) && parsed > 0)
+        return parsed;
+    console.warn(`Invalid MCP_MAX_SUBSCRIPTIONS; using the default of ${DEFAULT_MAX_SUBSCRIPTIONS}.`);
+    return DEFAULT_MAX_SUBSCRIPTIONS;
+}

package/dist/lib/vercelMarketplaceJwt.js

@@ -0,0 +1,54 @@
+import * as jose from "jose";
+const VERCEL_INTEGRATIONS_ORIGIN = "https://integrations.vercel.com";
+const VERCEL_ISSUER_PATH = /^\/oac_[A-Za-z0-9]+$/;
+const VERCEL_AUDIENCE_PATH = /^\/[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\/icfg_[A-Za-z0-9]+$/;
+let jwks;
+function isExpectedVercelUrl(value, pathPattern) {
+    try {
+        const url = new URL(value);
+        return (url.origin === VERCEL_INTEGRATIONS_ORIGIN &&
+            !url.username &&
+            !url.password &&
+            !url.search &&
+            !url.hash &&
+            pathPattern.test(url.pathname));
+    }
+    catch {
+        return false;
+    }
+}
+function getConfig() {
+    const issuer = process.env.VERCEL_MARKETPLACE_OIDC_ISSUER ?? "";
+    const audience = process.env.VERCEL_MARKETPLACE_OIDC_AUDIENCE ?? "";
+    if (!isVercelMarketplaceIssuer(issuer) || !isExpectedVercelUrl(audience, VERCEL_AUDIENCE_PATH)) {
+        return null;
+    }
+    return { issuer, audience };
+}
+function getJwks(issuer) {
+    if (!jwks) {
+        jwks = jose.createRemoteJWKSet(new URL(`${issuer}/.well-known/jwks`));
+    }
+    return jwks;
+}
+export function isVercelMarketplaceIssuer(issuer) {
+    return isExpectedVercelUrl(issuer, VERCEL_ISSUER_PATH);
+}
+export async function validateVercelMarketplaceJwt(token, tokenIssuer) {
+    const config = getConfig();
+    if (!config)
+        return { valid: false, error: "Vercel Marketplace OIDC not configured" };
+    if (tokenIssuer !== config.issuer) {
+        return { valid: false, error: "Untrusted Vercel Marketplace issuer" };
+    }
+    const { payload } = await jose.jwtVerify(token, getJwks(config.issuer), {
+        algorithms: ["RS256"],
+        audience: config.audience,
+        issuer: config.issuer,
+        clockTolerance: 60,
+    });
+    if (typeof payload.resource !== "string" || !payload.resource) {
+        return { valid: false, error: "Missing Vercel Marketplace resource" };
+    }
+    return { valid: true };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@upstash/context7-mcp",
-  "version": "4.0.4",
+  "version": "4.0.6",
   "mcpName": "io.github.upstash/context7",
   "description": "MCP server for Context7",
   "repository": {
@@ -45,6 +45,7 @@
   "devDependencies": {
     "@modelcontextprotocol/client": "2.0.0",
     "@types/node": "^25.0.3",
+    "esbuild": "^0.28.2",
     "typescript": "^5.8.2",
     "vitest": "^4.1.9"
   },
@@ -61,6 +62,7 @@
     "format:check": "prettier --check .",
     "dev": "tsc --watch",
     "start": "node dist/index.js --transport http",
-    "pack-mcpb": "pnpm install && pnpm run build && rm -rf node_modules && pnpm install --prod && cp mcpb/manifest.json manifest.json && cp mcpb/.mcpbignore .mcpbignore && cp ../../public/icon.png icon.png && mcpb validate manifest.json && mcpb pack . mcpb/context7.mcpb && rm manifest.json .mcpbignore icon.png && pnpm install"
+    "build:mcpb": "esbuild src/index.ts --bundle --platform=node --target=node20 --format=esm --outfile=mcpb/stage/server/dist/index.mjs --banner:js=\"import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);\"",
+    "pack-mcpb": "rm -rf mcpb/stage && pnpm run build:mcpb && cp package.json mcpb/stage/package.json && cp mcpb/manifest.json mcpb/stage/manifest.json && cp ../../public/icon.png mcpb/stage/icon.png && mcpb validate mcpb/stage/manifest.json && mcpb pack mcpb/stage mcpb/context7.mcpb && rm -rf mcpb/stage"
   }
 }