@cdxgen/cdxgen 13.0.1 → 13.2.0

package/lib/inventory/mcpConfigParser.js

@@ -1,6 +1,8 @@
 import { readFileSync } from "node:fs";
 import { basename } from "node:path";
 
+import * as toml from "smol-toml";
+
 import {
   sanitizeBomPropertyValue,
   sanitizeBomUrl,
@@ -30,6 +32,16 @@ const MCP_CONFIG_PATTERNS = [
   "**/opencode.json",
   "opencode.jsonc",
   "**/opencode.jsonc",
+  ".gemini/settings.json",
+  "**/.gemini/settings.json",
+  ".windsurf/mcp_config.json",
+  "**/.windsurf/mcp_config.json",
+  ".zed/settings.json",
+  "**/.zed/settings.json",
+  ".roo/mcp.json",
+  "**/.roo/mcp.json",
+  ".codex/config.toml",
+  "**/.codex/config.toml",
 ];
 
 const LOCAL_TUNNEL_HOST_PATTERNS = [
@@ -92,11 +104,32 @@ function configFormat(filePath) {
   ) {
     return "cursor";
   }
+  if (lowerPath.includes("/.gemini/")) {
+    return "gemini";
+  }
+  if (lowerPath.includes("/.windsurf/")) {
+    return "windsurf";
+  }
+  if (lowerPath.includes("/.zed/")) {
+    return "zed";
+  }
+  if (lowerPath.includes("/.roo/")) {
+    return "roo";
+  }
+  if (
+    lowerPath.includes("/.codex/") ||
+    lowerPath.endsWith(".codex/config.toml")
+  ) {
+    return "codex";
+  }
   return "generic-mcp-json";
 }
 
 function syntaxForFile(filePath) {
   const lowerPath = filePath.toLowerCase();
+  if (lowerPath.endsWith(".toml")) {
+    return "toml";
+  }
   return lowerPath.endsWith(".json") || lowerPath.endsWith(".jsonc")
     ? "json"
     : "text";
@@ -105,7 +138,15 @@ function syntaxForFile(filePath) {
 function extractServerMaps(config) {
   const serverMaps = [];
   for (const [key, value] of Object.entries(config || {})) {
-    if (["mcpServers", "context_servers", "servers", "mcp"].includes(key)) {
+    if (
+      [
+        "mcpServers",
+        "context_servers",
+        "servers",
+        "mcp",
+        "mcp_servers",
+      ].includes(key)
+    ) {
       if (value && typeof value === "object" && !Array.isArray(value)) {
         serverMaps.push({ configKey: key, servers: Object.entries(value) });
       } else if (Array.isArray(value)) {
@@ -382,6 +423,106 @@ function trustProfile(officialSdk, exposureType, authPosture) {
   return officialSdk ? "official-sdk+unknown" : "review-needed";
 }
 
+/**
+ * Extract an explicit MCP protocol version literal from a server config.
+ *
+ * @param {Object} serverConfig Parsed server configuration
+ * @returns {string|undefined} protocol version such as `2026-07-28`
+ */
+function protocolVersionForConfig(serverConfig) {
+  const candidate =
+    serverConfig?.protocolVersion ||
+    serverConfig?.protocol_version ||
+    serverConfig?.["MCP-Protocol-Version"] ||
+    serverConfig?.mcpProtocolVersion;
+  if (typeof candidate === "string" && /^\d{4}-\d{2}-\d{2}$/u.test(candidate)) {
+    return candidate;
+  }
+  return undefined;
+}
+
+/**
+ * Detect MCP features deprecated by the 2026-07-28 specification that a config
+ * still references.
+ *
+ * Detection is structural rather than free-text: the transport type, an
+ * explicit dynamic client registration endpoint, and declared capability
+ * objects are reliable signals, whereas substring scans over a stringified
+ * config fire on server names and unrelated blocks. Wire-level method names
+ * (`roots/list`, `sampling/createMessage`) are exchanged at runtime and never
+ * appear in a client config stanza, so they are intentionally not matched
+ * here; source analysis is the right place for those.
+ *
+ * @param {Object} serverConfig Parsed server configuration
+ * @param {string} transport Resolved transport
+ * @returns {string[]} sorted list of deprecated feature labels
+ */
+function deprecatedFeaturesForConfig(serverConfig, transport) {
+  const found = new Set();
+  // Legacy HTTP+SSE transport.
+  if (transport === "sse") {
+    found.add("sse-transport");
+  }
+  // Dynamic client registration, detected from an explicit endpoint or flag.
+  if (
+    serverConfig?.registration_endpoint ||
+    serverConfig?.auth?.registration_endpoint ||
+    serverConfig?.oauth?.registration_endpoint ||
+    serverConfig?.dynamicClientRegistration === true ||
+    serverConfig?.supportsDCR === true
+  ) {
+    found.add("dynamic-client-registration");
+  }
+  // Capability objects the client explicitly declares. A capabilities block is
+  // the structured place these appear; a bare declaration of them is the
+  // deprecated shape under 2026-07-28.
+  const capabilities = serverConfig?.capabilities;
+  if (capabilities && typeof capabilities === "object") {
+    for (const feature of ["sampling", "logging", "roots"]) {
+      if (capabilities[feature] && typeof capabilities[feature] === "object") {
+        found.add(feature);
+      }
+    }
+  }
+  return Array.from(found).sort();
+}
+
+/**
+ * Detect Client ID Metadata Document (CIMD) usage in a server config.
+ *
+ * @param {Object} serverConfig Parsed server configuration
+ * @returns {boolean} true when CIMD is configured
+ */
+function usesClientIdMetadataDocument(serverConfig) {
+  return Boolean(
+    serverConfig?.clientIdMetadataDocument ||
+      serverConfig?.client_id_metadata_document ||
+      serverConfig?.clientIdMetadataDocumentEnabled ||
+      serverConfig?.client_id_metadata_document_enabled ||
+      serverConfig?.oauth?.clientIdMetadataDocument,
+  );
+}
+
+/**
+ * Detect whether a config binds tokens to a specific resource audience, per the
+ * hardened MCP 2026-07-28 authorization model.
+ *
+ * @param {Object} serverConfig Parsed server configuration
+ * @returns {boolean} true when audience-bound resource metadata is present
+ */
+function usesAudienceBoundTokens(serverConfig) {
+  const resourceMetadata =
+    serverConfig?.resourceMetadata || serverConfig?.oauth?.resourceMetadata;
+  if (resourceMetadata && typeof resourceMetadata === "object") {
+    return Boolean(
+      resourceMetadata.resource &&
+        (Array.isArray(resourceMetadata.authorization_servers) ||
+          resourceMetadata.authorizationServers),
+    );
+  }
+  return false;
+}
+
 function createServiceFromConfig(
   filePath,
   format,
@@ -511,6 +652,27 @@ function createServiceFromConfig(
   if (authHints.has("oauth")) {
     addUniqueProperty(properties, "cdx:mcp:auth:requiresOAuth", "true");
   }
+  if (usesClientIdMetadataDocument(serverConfig)) {
+    addUniqueProperty(properties, "cdx:mcp:auth:cimd", "true");
+  }
+  if (usesAudienceBoundTokens(serverConfig)) {
+    addUniqueProperty(properties, "cdx:mcp:auth:audienceBound", "true");
+  }
+  const protocolVersion = protocolVersionForConfig(serverConfig);
+  if (protocolVersion) {
+    addUniqueProperty(properties, "cdx:mcp:protocolVersion", protocolVersion);
+  }
+  const deprecatedFeatures = deprecatedFeaturesForConfig(
+    serverConfig,
+    transport,
+  );
+  if (deprecatedFeatures.length) {
+    addUniqueProperty(
+      properties,
+      "cdx:mcp:deprecatedFeatures",
+      deprecatedFeatures.join(","),
+    );
+  }
   if (
     serverConfig?.protectedResourceMetadata ||
     serverConfig?.resourceServerUrl ||
@@ -650,7 +812,9 @@ export const mcpConfigParser = {
       }
       let configJson;
       try {
-        configJson = parseJsonLike(raw);
+        configJson = filePath.toLowerCase().endsWith(".toml")
+          ? toml.parse(raw)
+          : parseJsonLike(raw);
       } catch {
         continue;
       }

package/lib/inventory/mcpDiscovery.js

@@ -6,6 +6,17 @@ const PROVIDER_TEXT_PATTERNS = [
   ["deepseek", /\bdeepseek\b/i],
   ["ollama", /\bollama\b/i],
   ["groq", /\bgroq\b/i],
+  ["xai", /\bgrok\b|\bx\.ai\b/i],
+  ["openrouter", /\bopenrouter\b/i],
+  // "bedrock" alone is also a WordPress stack and a Minecraft edition, so
+  // require AWS context before attributing it to Amazon Bedrock.
+  ["aws-bedrock", /\b(?:aws|amazon)[\s-]?bedrock\b|\bbedrock[\s-]?runtime\b/i],
+  ["cerebras", /\bcerebras\b/i],
+  // Drop the bare "kimi" alias (a common given name); keep the distinctive
+  // "moonshot" vendor token.
+  ["moonshot", /\bmoonshot\b/i],
+  ["zhipu", /\bzhipu\b|\bglm-[0-9]/i],
+  ["qwen", /\bqwen\b|\bdashscope\b/i],
 ];
 
 const INLINE_CREDENTIAL_PATTERNS = [

package/lib/inventory/mcpServerManifest.js

@@ -0,0 +1,389 @@
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+
+import { sanitizeBomPropertyValue } from "../core/propertySanitizer.js";
+import { parseJsonLike } from "./jsonLike.js";
+import { isLocalHost, sanitizeMcpRefToken } from "./mcpDiscovery.js";
+import { tryBuildPurl } from "./purl.js";
+import { scanTextForHiddenUnicode } from "./unicodeScan.js";
+
+const SERVER_MANIFEST_PATTERNS = ["server.json", "**/server.json"];
+
+// registryType values understood by the official MCP Registry, mapped to the
+// package-url ecosystem cdxgen uses when a component purl can be built.
+const REGISTRY_TYPE_PURL_TYPES = {
+  npm: "npm",
+  pypi: "pypi",
+  nuget: "nuget",
+  oci: "oci",
+  mcpb: undefined,
+};
+
+function addUniqueProperty(properties, name, value) {
+  const sanitizedValue = sanitizeBomPropertyValue(name, value);
+  if (
+    sanitizedValue === undefined ||
+    sanitizedValue === null ||
+    sanitizedValue === ""
+  ) {
+    return;
+  }
+  if (
+    properties.some(
+      (property) =>
+        property.name === name && property.value === String(sanitizedValue),
+    )
+  ) {
+    return;
+  }
+  properties.push({ name, value: String(sanitizedValue) });
+}
+
+/**
+ * Determine whether a parsed object looks like an MCP Registry server manifest.
+ *
+ * The heuristic keeps unrelated `server.json` files (for example dev-server
+ * configuration) out of the MCP inventory by requiring the manifest to carry a
+ * server name plus at least one `packages[]` or `remotes[]` entry, or an
+ * explicit MCP Registry `$schema` reference.
+ *
+ * @param {Object} manifest Parsed JSON object
+ * @returns {boolean} true when the object resembles a registry manifest
+ */
+function looksLikeServerManifest(manifest) {
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+    return false;
+  }
+  const schema = String(manifest.$schema || "").toLowerCase();
+  if (schema.includes("modelcontextprotocol")) {
+    return true;
+  }
+  const hasName = typeof manifest.name === "string" && manifest.name.length > 0;
+  const hasPackages =
+    Array.isArray(manifest.packages) && manifest.packages.length > 0;
+  const hasRemotes =
+    Array.isArray(manifest.remotes) && manifest.remotes.length > 0;
+  return hasName && (hasPackages || hasRemotes);
+}
+
+/**
+ * Build a package-url string for a registry package entry when the
+ * registryType maps to a supported ecosystem and enough coordinates exist.
+ *
+ * @param {Object} pkg Registry package entry
+ * @returns {string|undefined} purl string, or undefined when not derivable
+ */
+function purlForPackage(pkg) {
+  const registryType = String(pkg?.registryType || pkg?.registry_type || "")
+    .trim()
+    .toLowerCase();
+  const purlType = REGISTRY_TYPE_PURL_TYPES[registryType];
+  if (!purlType) {
+    return undefined;
+  }
+  const identifier = String(pkg?.identifier || pkg?.name || "").trim();
+  if (!identifier) {
+    return undefined;
+  }
+  const version = pkg?.version ? String(pkg.version) : undefined;
+  let namespace;
+  let name = identifier;
+  const parts = { type: purlType, version };
+  if (purlType === "npm" && identifier.startsWith("@")) {
+    const [scope, unscoped] = identifier.split("/");
+    namespace = scope;
+    name = unscoped || identifier;
+  } else if (purlType === "pypi") {
+    // PyPI purls require the normalized project name: lowercase with runs of
+    // [-_.] collapsed to a single hyphen.
+    name = identifier.toLowerCase().replace(/[-_.]+/gu, "-");
+  } else if (purlType === "oci") {
+    // OCI purls are only meaningful with a lowercase name, a digest version,
+    // and a repository_url qualifier. A tag-only reference is not resolvable,
+    // so skip the purl rather than emit a misleading one.
+    const digest =
+      pkg?.digest || (version?.startsWith("sha256:") ? version : undefined);
+    const repositoryUrl = pkg?.registryBaseUrl || pkg?.repository_url;
+    if (!digest || !repositoryUrl) {
+      return undefined;
+    }
+    name = identifier.toLowerCase().split("/").pop();
+    parts.version = digest;
+    parts.qualifiers = { repository_url: String(repositoryUrl) };
+  }
+  parts.namespace = namespace;
+  parts.name = name;
+  return tryBuildPurl(parts)?.toString() || undefined;
+}
+
+/**
+ * Convert one registry package entry into a CycloneDX component describing the
+ * distributable that hosts the MCP server.
+ *
+ * @param {string} filePath Manifest path
+ * @param {string} serverName MCP server name
+ * @param {Object} pkg Registry package entry
+ * @param {number} index Package index for stable identity
+ * @returns {Object|undefined} component or undefined when not usable
+ */
+function componentForPackage(filePath, serverName, pkg, index) {
+  const registryType = String(pkg?.registryType || pkg?.registry_type || "")
+    .trim()
+    .toLowerCase();
+  const identifier = String(pkg?.identifier || pkg?.name || "").trim();
+  if (!registryType && !identifier) {
+    return undefined;
+  }
+  const purl = purlForPackage(pkg);
+  const properties = [
+    { name: "internal:SrcFile", value: filePath },
+    { name: "cdx:mcp:inventorySource", value: "server-manifest" },
+    { name: "cdx:registry:server:packageRegistryType", value: registryType },
+  ];
+  if (pkg?.transport?.type || pkg?.transport) {
+    addUniqueProperty(
+      properties,
+      "cdx:registry:server:packageTransport",
+      typeof pkg.transport === "string" ? pkg.transport : pkg.transport?.type,
+    );
+  }
+  // Record only the counts and field names the server will be handed at launch,
+  // never their values. These describe the launch surface without leaking
+  // secrets that a registry manifest may reference through them.
+  const secretInputFields = new Set();
+  for (const [inputKey, property] of [
+    ["environmentVariables", "cdx:registry:server:environmentVariableCount"],
+    ["runtimeArguments", "cdx:registry:server:runtimeArgumentCount"],
+    ["packageArguments", "cdx:registry:server:packageArgumentCount"],
+  ]) {
+    const entries = pkg?.[inputKey];
+    if (Array.isArray(entries) && entries.length) {
+      addUniqueProperty(properties, property, String(entries.length));
+      for (const entry of entries) {
+        const fieldName = entry?.name || entry?.variable;
+        if (
+          entry?.isSecret === true ||
+          entry?.secret === true ||
+          (typeof fieldName === "string" &&
+            /(token|secret|password|api[_-]?key|credential)/iu.test(fieldName))
+        ) {
+          secretInputFields.add(String(fieldName || "secret"));
+        }
+      }
+    }
+  }
+  if (secretInputFields.size) {
+    addUniqueProperty(
+      properties,
+      "cdx:registry:server:secretInputCount",
+      String(secretInputFields.size),
+    );
+  }
+  const component = {
+    "bom-ref":
+      purl ||
+      `urn:mcp:server-package:${sanitizeMcpRefToken(serverName)}:${sanitizeMcpRefToken(identifier || registryType)}:${index}`,
+    type: "application",
+    name: identifier || `${serverName}-package-${index}`,
+    properties,
+  };
+  if (purl) {
+    component.purl = purl;
+  }
+  if (pkg?.version) {
+    component.version = String(pkg.version);
+  }
+  return component;
+}
+
+/**
+ * Convert one registry remote entry into a CycloneDX service describing the
+ * remotely hosted MCP endpoint.
+ *
+ * @param {string} filePath Manifest path
+ * @param {string} serverName MCP server name
+ * @param {Object} remote Registry remote entry
+ * @param {number} index Remote index for stable identity
+ * @returns {Object|undefined} service or undefined when no URL is present
+ */
+function serviceForRemote(filePath, serverName, remote, index) {
+  const url = typeof remote?.url === "string" ? remote.url : undefined;
+  if (!url) {
+    return undefined;
+  }
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    return undefined;
+  }
+  const transport = String(remote?.type || remote?.transport || "")
+    .trim()
+    .toLowerCase();
+  const exposureType = isLocalHost(hostname)
+    ? "local-only"
+    : "networked-public";
+  const properties = [
+    { name: "internal:SrcFile", value: filePath },
+    { name: "cdx:mcp:serviceType", value: "registry-remote" },
+    { name: "cdx:mcp:inventorySource", value: "server-manifest" },
+    { name: "cdx:mcp:exposureType", value: exposureType },
+    // A remote server has no resolvable local package, so its composition
+    // cannot be verified from the manifest alone.
+    { name: "cdx:mcp:composition", value: "unknown" },
+    { name: "cdx:mcp:reviewNeeded", value: "true" },
+  ];
+  if (transport) {
+    addUniqueProperty(
+      properties,
+      "cdx:mcp:transport",
+      transport.includes("sse")
+        ? "sse"
+        : transport.includes("stream") || transport.includes("http")
+          ? "streamable-http"
+          : transport,
+    );
+  }
+  return {
+    "bom-ref": `urn:service:mcp:${sanitizeMcpRefToken(serverName)}:remote:${index}`,
+    group: "mcp",
+    name: serverName,
+    endpoints: [url],
+    properties,
+  };
+}
+
+/**
+ * Build the file component that represents the discovered manifest itself and
+ * summarizes the packages and remotes it declares.
+ *
+ * @param {string} filePath Manifest path
+ * @param {Object} manifest Parsed manifest
+ * @param {string} raw Raw file contents
+ * @param {number} packageCount Number of package components emitted
+ * @param {number} remoteCount Number of remote services emitted
+ * @returns {Object} file component
+ */
+function manifestFileComponent(
+  filePath,
+  manifest,
+  raw,
+  packageCount,
+  remoteCount,
+) {
+  const properties = [
+    { name: "internal:SrcFile", value: filePath },
+    { name: "cdx:file:kind", value: "mcp-server-manifest" },
+    { name: "cdx:mcp:inventorySource", value: "server-manifest" },
+    {
+      name: "cdx:registry:server:packageCount",
+      value: String(packageCount),
+    },
+    { name: "cdx:registry:server:remoteCount", value: String(remoteCount) },
+  ];
+  addUniqueProperty(
+    properties,
+    "cdx:registry:server:name",
+    typeof manifest.name === "string" ? manifest.name : undefined,
+  );
+  addUniqueProperty(
+    properties,
+    "cdx:registry:server:version",
+    manifest.version ? String(manifest.version) : undefined,
+  );
+  const hiddenUnicodeScan = scanTextForHiddenUnicode(raw, { syntax: "json" });
+  if (hiddenUnicodeScan.hasHiddenUnicode) {
+    addUniqueProperty(properties, "cdx:file:hasHiddenUnicode", "true");
+    addUniqueProperty(
+      properties,
+      "cdx:file:hiddenUnicodeCodePoints",
+      hiddenUnicodeScan.codePoints.join(","),
+    );
+  }
+  return {
+    "bom-ref": `file:${filePath}`,
+    type: "file",
+    name: basename(filePath),
+    properties,
+  };
+}
+
+/**
+ * Parser for MCP Registry server manifests (`server.json`).
+ *
+ * Converts each declared distributable package into a CycloneDX component
+ * (with a purl when the registry type maps to a supported ecosystem) and each
+ * remotely hosted endpoint into a service, alongside a file component that
+ * summarizes the manifest.
+ *
+ * @type {{id: string, patterns: string[], parse(files: string[], options?: Object): {components: Object[], services: Object[]}}}
+ */
+export const mcpServerManifestParser = {
+  id: "mcp-server-manifest",
+  patterns: SERVER_MANIFEST_PATTERNS,
+  parse(files, _options = {}) {
+    const components = [];
+    const services = [];
+    for (const filePath of [...new Set(files || [])]) {
+      let raw;
+      try {
+        raw = readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      let manifest;
+      try {
+        manifest = parseJsonLike(raw);
+      } catch {
+        continue;
+      }
+      if (!looksLikeServerManifest(manifest)) {
+        continue;
+      }
+      const serverName =
+        typeof manifest.name === "string" && manifest.name.length
+          ? manifest.name
+          : basename(filePath);
+      const packageComponents = [];
+      const packages = Array.isArray(manifest.packages)
+        ? manifest.packages
+        : [];
+      for (let index = 0; index < packages.length; index++) {
+        const component = componentForPackage(
+          filePath,
+          serverName,
+          packages[index],
+          index,
+        );
+        if (component) {
+          packageComponents.push(component);
+        }
+      }
+      const remoteServices = [];
+      const remotes = Array.isArray(manifest.remotes) ? manifest.remotes : [];
+      for (let index = 0; index < remotes.length; index++) {
+        const service = serviceForRemote(
+          filePath,
+          serverName,
+          remotes[index],
+          index,
+        );
+        if (service) {
+          remoteServices.push(service);
+        }
+      }
+      components.push(
+        manifestFileComponent(
+          filePath,
+          manifest,
+          raw,
+          packageComponents.length,
+          remoteServices.length,
+        ),
+      );
+      components.push(...packageComponents);
+      services.push(...remoteServices);
+    }
+    return { components, services };
+  },
+};