echelongraph-mcp 2.6.0 → 2.6.1

package/CHANGELOG.md

@@ -6,6 +6,14 @@ with a provenance attestation by the release workflow of
 [github.com/echelongraph/echelongraph-mcp](https://github.com/echelongraph/echelongraph-mcp),
 from the commit tagged `v<version>`.
 
+## 2.6.1 — 2026-10-04
+
+- Hosted endpoint only: when the production synthetic calls `https://mcp.echelongraph.io/mcp`, the
+  endpoint marks its own API calls with a fixed `echelongraph-mcp-synthetic/1.0` token, so the
+  synthetic is never counted as hosted use. The client's own text is never passed through. The
+  `mcp_request` log line gains `client_public` (#2737).
+- stdio behaviour is unchanged.
+
 ## 2.6.0 — 2026-10-04
 
 - `check_sbom` checks up to 2,000 distinct purls per call, instead of refusing more than 200: it

package/dist/http.js

@@ -23,7 +23,7 @@
 // token fatal at start-up, because without it every remote user would share one API budget.
 import http from "node:http";
 import { createMcpHandler } from "@modelcontextprotocol/server";
-import { forwardToken, markHttpEntrypoint, withClient } from "./runtime.js";
+import { forwardToken, markHttpEntrypoint, SYNTHETIC_UA_FAMILY, withClient } from "./runtime.js";
 import { BODY_TOO_LARGE_CODE, DEFAULT_RATE_LIMIT_PER_MIN, FixedWindowLimiter, ORIGIN_REFUSED_CODE, RATE_LIMITED_CODE, bodyFacts, originVerdict, resolveClient, revisionLabel, rpcError, uaFamily, } from "./httpPolicy.js";
 // Must run before index.ts is evaluated: it is how index.ts knows not to start stdio.
 markHttpEntrypoint();
@@ -158,7 +158,11 @@ async function serveMcp(req, res, pathname) {
         body: body && body.length > 0 ? new Uint8Array(body) : undefined,
         signal: abort.signal,
     });
-    const response = await withClient(client.forwardAddress, () => handler.fetch(request));
+    // #2737: the production synthetic names itself by its user-agent family; its API calls then
+    // carry the synthetic's fixed token (runtime.ts upstreamUserAgent), so they are never counted
+    // as hosted adoption.
+    const synthetic = uaFamily(req.headers["user-agent"]) === SYNTHETIC_UA_FAMILY;
+    const response = await withClient(client.forwardAddress, () => handler.fetch(request), { synthetic });
     const out = { ...cors };
     response.headers.forEach((v, k) => {
         out[k] = v;
@@ -169,7 +173,7 @@ async function serveMcp(req, res, pathname) {
             res.write(chunk);
     }
     res.end();
-    return { status: response.status, body };
+    return { status: response.status, body, clientPublic: client.forwardAddress !== undefined };
 }
 const server = http.createServer((req, res) => {
     const start = process.hrtime.bigint();
@@ -196,6 +200,7 @@ const server = http.createServer((req, res) => {
             throttled: o.throttled === true,
             refused: o.refused ?? "",
             ua_family: uaFamily(req.headers["user-agent"]),
+            client_public: o.clientPublic === true,
         });
     };
     if (pathname === HEALTH_PATH) {

package/dist/index.js

@@ -52,7 +52,7 @@ import { registerCheckAffected } from "./tools/check_affected.js";
 import { registerCheckSbom } from "./tools/check_sbom.js";
 import { registerCveIntel } from "./tools/cve_intel.js";
 import { registerGetCwe } from "./tools/get_cwe.js";
-import { isHttpEntrypoint, upstreamHeaders } from "./runtime.js";
+import { isHttpEntrypoint, upstreamHeaders, upstreamUserAgent } from "./runtime.js";
 import { registerVendorAdvisoryTools } from "./tools/vendor_advisories.js";
 import { registerPrompts } from "./prompts.js";
 import { registerResources } from "./resources.js";
@@ -186,8 +186,9 @@ export async function api(path, init) {
                 method: init?.method,
                 body: init?.body,
                 // upstreamHeaders: empty on stdio; on the hosted endpoint, the forward token and the
-                // end client's address (runtime.ts, #2316).
-                headers: { ...upstreamHeaders(`${BASE}${path}`), ...(init?.headers ?? {}), "User-Agent": UA, Accept: "application/json" },
+                // end client's address (runtime.ts, #2316). upstreamUserAgent: UA, unless the hosted
+                // endpoint is answering the production synthetic (#2737).
+                headers: { ...upstreamHeaders(`${BASE}${path}`), ...(init?.headers ?? {}), "User-Agent": upstreamUserAgent(UA), Accept: "application/json" },
                 signal: ctrl.signal,
             });
         }

package/dist/runtime.js

@@ -22,8 +22,25 @@ export function isHttpEntrypoint() {
 // withClient(), and the SDK dispatches the tool handler inside that same async context, so
 // api() can read it without the tool module passing it through every function.
 const clientStore = new AsyncLocalStorage();
-export function withClient(clientIp, fn) {
-    return clientStore.run({ clientIp }, fn);
+export function withClient(clientIp, fn, opts = {}) {
+    return clientStore.run({ clientIp, synthetic: opts.synthetic === true }, fn);
+}
+// #2737: the production MCP synthetic probes this endpoint too, and its calls must reach the API
+// under its own family, never as hosted MCP adoption. The synthetic names itself to this service
+// with this family as its User-Agent's leading token; http.ts marks such a request (synthetic:
+// true) and upstreamUserAgent() then puts this FIXED token ahead of the service's own user-agent,
+// exactly as ECHELONGRAPH_MCP_UA does for the npm package. The client's text is never relayed: a
+// request either carries this one constant or nothing. Anyone can claim the family, as anyone can
+// send it to the API directly; the consequence is an undercounted adoption number, never a bypass
+// (core-backend: user-agent classification is for counting only).
+export const SYNTHETIC_UA_FAMILY = "echelongraph-mcp-synthetic";
+export const SYNTHETIC_UA_TOKEN = `${SYNTHETIC_UA_FAMILY}/1.0`;
+/** The User-Agent for one API call: `ua`, led by the synthetic's token when the request is the synthetic's. */
+export function upstreamUserAgent(ua) {
+    if (!httpEntrypoint || clientStore.getStore()?.synthetic !== true)
+        return ua;
+    const lead = ua.split(/[/\s]/, 1)[0];
+    return lead === SYNTHETIC_UA_FAMILY ? ua : `${SYNTHETIC_UA_TOKEN} ${ua}`;
 }
 /** The header that carries the forward token, and the one that names the client (core-backend waf/mcpforward.go). */
 export const FORWARD_TOKEN_HEADER = "X-EG-MCP-Forward";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "echelongraph-mcp",
-  "version": "2.6.0",
+  "version": "2.6.1",
   "mcpName": "io.echelongraph/echelongraph-mcp",
   "description": "EchelonGraph CVE and internet-exposure data as an MCP server: CVEs with EchelonGraph multi-source scores, CISA-KEV and EPSS, plus a per-CVE internet-exposure footprint derived from Shodan data. Shodan data is owned by Shodan, which holds its copyright (© Shodan). Free and keyless, for Claude, Cursor and any MCP client.",
   "type": "module",

package/server.json

@@ -17,7 +17,7 @@
       ]
     }
   ],
-  "version": "2.6.0",
+  "version": "2.6.1",
   "remotes": [
     {
       "type": "streamable-http",
@@ -28,7 +28,7 @@
     {
       "registryType": "npm",
       "identifier": "echelongraph-mcp",
-      "version": "2.6.0",
+      "version": "2.6.1",
       "transport": {
         "type": "stdio"
       },