@cyclonedx/cdxgen 12.3.0 → 12.3.2

package/lib/evinser/evinser.js

@@ -17,6 +17,9 @@ import {
   getTmpDir,
   PROJECT_TYPE_ALIASES,
   safeExistsSync,
+  safeMkdtempSync,
+  safeRmSync,
+  safeWriteSync,
 } from "../helpers/utils.js";
 import { postProcess } from "../stages/postgen/postgen.js";
 import { createOrLoad } from "./db.js";
@@ -192,7 +195,7 @@ export async function createAndStoreSlice(
     });
   }
   if (retMap?.tempDir?.startsWith(getTmpDir())) {
-    fs.rmSync(retMap.tempDir, { recursive: true, force: true });
+    safeRmSync(retMap.tempDir, { recursive: true, force: true });
   }
   return sliceData;
 }
@@ -234,7 +237,7 @@ export async function createSlice(
     return {};
   }
 
-  let sliceOutputDir = fs.mkdtempSync(join(getTmpDir(), `atom-${sliceType}-`));
+  let sliceOutputDir = safeMkdtempSync(join(getTmpDir(), `atom-${sliceType}-`));
   if (options?.output) {
     sliceOutputDir =
       safeExistsSync(options.output) &&
@@ -256,7 +259,7 @@ export async function createSlice(
     const slicesData = createSemanticsSlices(resolve(filePath), options);
     // Write the semantics slices data
     if (slicesData) {
-      fs.writeFileSync(
+      safeWriteSync(
         slicesFile,
         JSON.stringify(slicesData, null, options.jsonPretty ? 2 : null),
       );
@@ -1523,7 +1526,7 @@ export function createEvinseFile(sliceArtefacts, options) {
   delete bomJson.signature;
   // Redo post-processing with evinse data
   const bomNSData = postProcess({ bomJson }, options);
-  fs.writeFileSync(
+  safeWriteSync(
     evinseOutFile,
     JSON.stringify(bomNSData.bomJson, null, options.jsonPretty ? 2 : null),
   );
@@ -1555,7 +1558,7 @@ export function createEvinseFile(sliceArtefacts, options) {
     }
   }
   if (tempDir?.startsWith(getTmpDir())) {
-    fs.rmSync(tempDir, { recursive: true, force: true });
+    safeRmSync(tempDir, { recursive: true, force: true });
   }
   return bomNSData?.bomJson;
 }

package/lib/helpers/agentFormulationParser.js

@@ -0,0 +1,318 @@
+import { readFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+
+import {
+  credentialIndicatorsForText,
+  isLocalHost,
+  providerNamesForText,
+  sanitizeMcpRefToken,
+} from "./mcpDiscovery.js";
+import { scanTextForHiddenUnicode } from "./unicodeScan.js";
+
+const AGENT_FILE_PATTERNS = [
+  "AGENTS.md",
+  "agents.md",
+  "CLAUDE.md",
+  "Cursor.md",
+  ".github/copilot-instructions.md",
+  ".github/instructions/**/*.{md,mdx,markdown,txt}",
+  ".github/workflows/copilot-setup-steps.yml",
+  "**/*.{prompt,mdc}",
+];
+
+const MCP_PACKAGE_REF_PATTERN =
+  /@modelcontextprotocol\/[a-z0-9._/-]+|@[a-z0-9._-]+\/mcp[a-z0-9._/-]*/giu;
+const URL_PATTERN = /https?:\/\/[^\s<>"')\]}]+/giu;
+const AUTH_HINT_PATTERNS = [
+  ["bearer", /\bbearer\b/i],
+  ["oauth", /\boauth\b|authorization_endpoint|token_endpoint|issuer/i],
+  ["api-key", /\bapi[_ -]?key\b/i],
+  ["token", /\btoken\b|authorization:/i],
+];
+const TUNNEL_HOST_PATTERNS = [
+  /\.ngrok(?:-free)?\.app$/i,
+  /\.ngrok\.io$/i,
+  /\.trycloudflare\.com$/i,
+  /\.localhost\.run$/i,
+  /\.serveo\.net$/i,
+];
+
+function syntaxForFile(filePath) {
+  const extension = extname(filePath).toLowerCase();
+  if ([".md", ".mdx", ".markdown"].includes(extension)) {
+    return "markdown";
+  }
+  if ([".yaml", ".yml"].includes(extension)) {
+    return "yaml";
+  }
+  return "text";
+}
+
+function kindForFile(filePath) {
+  const lowerPath = filePath.toLowerCase();
+  if (lowerPath.endsWith("copilot-setup-steps.yml")) {
+    return "copilot-setup-workflow";
+  }
+  if (lowerPath.endsWith("copilot-instructions.md")) {
+    return "copilot-instructions";
+  }
+  if (lowerPath.endsWith("agents.md") || lowerPath.endsWith("claude.md")) {
+    return "agent-instructions";
+  }
+  if (lowerPath.endsWith(".prompt") || lowerPath.endsWith(".mdc")) {
+    return "skill-file";
+  }
+  return "ai-agent-file";
+}
+
+function authHintsForText(text) {
+  return AUTH_HINT_PATTERNS.flatMap(([name, pattern]) =>
+    pattern.test(text) ? [name] : [],
+  );
+}
+
+function packageRefsForText(text) {
+  return [...new Set(text.match(MCP_PACKAGE_REF_PATTERN) || [])].sort();
+}
+
+function mcpUrlsForText(text) {
+  const urls = [];
+  for (const match of text.match(URL_PATTERN) || []) {
+    try {
+      const parsed = new URL(match);
+      if (
+        parsed.pathname.toLowerCase().includes("/mcp") ||
+        parsed.hostname.toLowerCase().includes("modelcontextprotocol")
+      ) {
+        urls.push(parsed.toString());
+      }
+    } catch {
+      // Ignore malformed URLs in untrusted agent instructions.
+    }
+  }
+  return [...new Set(urls)].sort();
+}
+
+function buildInferredMcpServices(filePath, mcpUrls, authHints, providerNames) {
+  return mcpUrls.map((urlValue, index) => {
+    const parsed = new URL(urlValue);
+    const hostname = parsed.hostname.toLowerCase();
+    const exposureType = isLocalHost(hostname)
+      ? "local-only"
+      : "networked-public";
+    const properties = [
+      { name: "SrcFile", value: filePath },
+      { name: "cdx:mcp:serviceType", value: "inferred-endpoint" },
+      { name: "cdx:mcp:inventorySource", value: "agent-file" },
+      { name: "cdx:mcp:usageConfidence", value: "medium" },
+      { name: "cdx:mcp:reviewNeeded", value: "true" },
+      { name: "cdx:mcp:exposureType", value: exposureType },
+      { name: "cdx:mcp:agentReference", value: "true" },
+    ];
+    if (providerNames.length) {
+      properties.push({
+        name: "cdx:mcp:providerNames",
+        value: providerNames.join(","),
+      });
+    }
+    if (authHints.length) {
+      properties.push({
+        name: "cdx:mcp:authMode",
+        value: authHints.join(","),
+      });
+    }
+    return {
+      "bom-ref": `urn:service:agent-mcp:${sanitizeMcpRefToken(hostname || basename(filePath))}:${index + 1}`,
+      group: "mcp",
+      name: hostname || `${basename(filePath)}-mcp-endpoint`,
+      endpoints: [urlValue],
+      properties,
+      version: "inferred",
+    };
+  });
+}
+
+/**
+ * Discover AI agent instruction and skill files that can hide MCP/runtime
+ * surfaces from package-only inventory.
+ */
+export const agentFormulationParser = {
+  id: "agent-formulation",
+  patterns: AGENT_FILE_PATTERNS,
+  parse(files, _options = {}) {
+    const components = [];
+    const services = [];
+    for (const filePath of files || []) {
+      let raw;
+      try {
+        raw = readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      const hiddenUnicodeScan = scanTextForHiddenUnicode(raw, {
+        syntax: syntaxForFile(filePath),
+      });
+      const packageRefs = packageRefsForText(raw);
+      const providerNames = providerNamesForText(raw);
+      const mcpUrls = mcpUrlsForText(raw);
+      const authHints = authHintsForText(raw);
+      const credentialIndicators = credentialIndicatorsForText(raw);
+      const mcpHosts = mcpUrls.map((urlValue) => new URL(urlValue).hostname);
+      const hasPublicMcpEndpoint = mcpHosts.some((host) => !isLocalHost(host));
+      const hasTunnelReference = mcpHosts.some((host) =>
+        TUNNEL_HOST_PATTERNS.some((pattern) => pattern.test(host)),
+      );
+      const hasMcpReferences =
+        mcpUrls.length > 0 ||
+        packageRefs.length > 0 ||
+        /\bmcp\b/i.test(raw) ||
+        /modelcontextprotocol/i.test(raw);
+      // Inventory all matched agent/instruction files, even when they do not
+      // yet contain hidden Unicode or explicit MCP references, so shipped files
+      // such as CLAUDE.md and AGENTS.md still surface in build/post-build BOMs.
+      if (!raw.trim().length) {
+        continue;
+      }
+      const hiddenComponentKinds = [];
+      if (mcpUrls.length) {
+        hiddenComponentKinds.push("mcp-endpoint");
+      }
+      if (providerNames.length) {
+        hiddenComponentKinds.push("provider");
+      }
+      if (packageRefs.length) {
+        hiddenComponentKinds.push("mcp-package-reference");
+      }
+      const properties = [
+        { name: "SrcFile", value: filePath },
+        { name: "cdx:file:kind", value: kindForFile(filePath) },
+        { name: "cdx:agent:inventorySource", value: "agent-file" },
+        { name: "cdx:agent:hasMcpReferences", value: String(hasMcpReferences) },
+        {
+          name: "cdx:agent:hiddenEndpointCount",
+          value: String(mcpUrls.length),
+        },
+      ];
+      if (hiddenUnicodeScan.hasHiddenUnicode) {
+        properties.push(
+          { name: "cdx:file:hasHiddenUnicode", value: "true" },
+          {
+            name: "cdx:file:hiddenUnicodeCodePoints",
+            value: hiddenUnicodeScan.codePoints.join(","),
+          },
+          {
+            name: "cdx:file:hiddenUnicodeLineNumbers",
+            value: hiddenUnicodeScan.lineNumbers.join(","),
+          },
+        );
+        if (hiddenUnicodeScan.inComments) {
+          properties.push(
+            {
+              name: "cdx:file:hiddenUnicodeInComments",
+              value: "true",
+            },
+            {
+              name: "cdx:file:hiddenUnicodeCommentCodePoints",
+              value: hiddenUnicodeScan.commentCodePoints.join(","),
+            },
+          );
+        }
+      }
+      if (packageRefs.length) {
+        properties.push({
+          name: "cdx:agent:mcpPackageRefs",
+          value: packageRefs.join(","),
+        });
+        if (
+          packageRefs.some((ref) => !ref.startsWith("@modelcontextprotocol/"))
+        ) {
+          properties.push({
+            name: "cdx:agent:hasNonOfficialMcpReference",
+            value: "true",
+          });
+        }
+      }
+      if (mcpUrls.length) {
+        properties.push(
+          {
+            name: "cdx:agent:hiddenMcpUrls",
+            value: mcpUrls.join(","),
+          },
+          {
+            name: "cdx:agent:hiddenMcpHosts",
+            value: [...new Set(mcpHosts)].sort().join(","),
+          },
+        );
+      }
+      if (providerNames.length) {
+        properties.push({
+          name: "cdx:agent:providerNames",
+          value: providerNames.join(","),
+        });
+      }
+      if (authHints.length) {
+        properties.push({
+          name: "cdx:agent:authHints",
+          value: authHints.join(","),
+        });
+      }
+      if (credentialIndicators.length) {
+        properties.push(
+          {
+            name: "cdx:agent:credentialExposure",
+            value: "true",
+          },
+          {
+            name: "cdx:agent:credentialRiskIndicators",
+            value: credentialIndicators.join(","),
+          },
+        );
+      }
+      if (hasPublicMcpEndpoint) {
+        properties.push({
+          name: "cdx:agent:hasPublicMcpEndpoint",
+          value: "true",
+        });
+      }
+      if (hasTunnelReference) {
+        properties.push({
+          name: "cdx:agent:hasTunnelReference",
+          value: "true",
+        });
+      }
+      if (hiddenComponentKinds.length) {
+        properties.push({
+          name: "cdx:agent:hiddenComponentKinds",
+          value: hiddenComponentKinds.join(","),
+        });
+      }
+      if (
+        hiddenUnicodeScan.hasHiddenUnicode ||
+        hasPublicMcpEndpoint ||
+        hasTunnelReference ||
+        packageRefs.length > 0 ||
+        credentialIndicators.length > 0
+      ) {
+        properties.push({
+          name: "cdx:agent:reviewNeeded",
+          value: "true",
+        });
+      }
+      components.push({
+        "bom-ref": `file:${filePath}`,
+        name: basename(filePath),
+        properties,
+        type: "file",
+      });
+      services.push(
+        ...buildInferredMcpServices(
+          filePath,
+          mcpUrls,
+          authHints,
+          providerNames,
+        ),
+      );
+    }
+    return { components, services };
+  },
+};

package/lib/helpers/aiInventory.js

@@ -0,0 +1,262 @@
+import { agentFormulationParser } from "./agentFormulationParser.js";
+import { communityAiConfigParser } from "./communityAiConfigParser.js";
+import { mergeServices, trimComponents } from "./depsUtils.js";
+import { classifyMcpReference } from "./mcp.js";
+import { mcpConfigParser } from "./mcpConfigParser.js";
+import { getAllFiles } from "./utils.js";
+
+export const AI_INVENTORY_PROJECT_TYPES = ["mcp", "ai-skill"];
+export const AI_INSTRUCTION_FILE_KINDS = new Set([
+  "agent-config",
+  "agent-definition",
+  "agent-instructions",
+  "ai-agent-file",
+  "copilot-instructions",
+  "copilot-setup-workflow",
+  "crew-agent",
+  "crew-task",
+  "crew-tool",
+  "custom-command",
+  "custom-tool",
+  "graph-definition",
+]);
+export const AI_SKILL_FILE_KIND = "skill-file";
+export const MCP_CONFIG_FILE_KIND = "mcp-config";
+
+const AI_INVENTORY_FILE_KINDS = new Set([
+  "agent-config",
+  "agent-definition",
+  "agent-instructions",
+  "ai-agent-file",
+  "copilot-instructions",
+  "copilot-setup-workflow",
+  "crew-agent",
+  "crew-task",
+  "crew-tool",
+  "custom-command",
+  "custom-tool",
+  "graph-definition",
+  AI_SKILL_FILE_KIND,
+]);
+
+const AI_INVENTORY_PARSERS = [
+  {
+    id: agentFormulationParser.id,
+    parser: agentFormulationParser,
+    types: ["mcp", "ai-skill"],
+  },
+  {
+    id: mcpConfigParser.id,
+    parser: mcpConfigParser,
+    types: ["mcp"],
+  },
+  {
+    id: communityAiConfigParser.id,
+    parser: communityAiConfigParser,
+    types: ["ai-skill"],
+  },
+];
+
+export function inventoryPropertyValue(subject, name) {
+  return subject?.properties?.find((property) => property.name === name)?.value;
+}
+
+function hasPropertyPrefix(subject, prefix) {
+  return (subject?.properties || []).some((property) =>
+    property?.name?.startsWith(prefix),
+  );
+}
+
+function uniqueNonEmptyTypes(types) {
+  return [...new Set((types || []).filter(Boolean))];
+}
+
+export function optionIncludesAiInventoryProjectType(optionValue, type) {
+  const values = Array.isArray(optionValue)
+    ? optionValue
+    : optionValue
+      ? [optionValue]
+      : [];
+  return values.some((value) => {
+    const normalizedValue = String(value).toLowerCase();
+    if (type === "ai-skill") {
+      return ["ai-skill", "skill", "skills"].includes(normalizedValue);
+    }
+    return normalizedValue === type;
+  });
+}
+
+export function inventoryTypesForSubject(subject) {
+  const types = new Set();
+  const fileKind = inventoryPropertyValue(subject, "cdx:file:kind");
+  if (
+    subject?.group === "mcp" ||
+    classifyMcpReference(subject).isMcp ||
+    hasPropertyPrefix(subject, "cdx:mcp:") ||
+    (subject?.tags || []).some((tag) => String(tag || "").startsWith("mcp"))
+  ) {
+    types.add("mcp");
+  }
+  if (
+    AI_INVENTORY_FILE_KINDS.has(fileKind) ||
+    hasPropertyPrefix(subject, "cdx:agent:") ||
+    hasPropertyPrefix(subject, "cdx:skill:") ||
+    hasPropertyPrefix(subject, "cdx:tool:") ||
+    hasPropertyPrefix(subject, "cdx:langgraph:") ||
+    hasPropertyPrefix(subject, "cdx:crewai:")
+  ) {
+    types.add("ai-skill");
+  }
+  if (
+    inventoryPropertyValue(subject, "cdx:mcp:inventorySource") === "agent-file"
+  ) {
+    types.add("ai-skill");
+  }
+  return Array.from(types);
+}
+
+export function matchesAiInventoryType(subject, type) {
+  return inventoryTypesForSubject(subject).includes(type);
+}
+
+export function matchesAiInventoryExcludeType(subject, type) {
+  if (type === "mcp") {
+    const fileKind = inventoryPropertyValue(subject, "cdx:file:kind");
+    return (
+      fileKind === MCP_CONFIG_FILE_KIND ||
+      subject?.group === "mcp" ||
+      inventoryPropertyValue(subject, "cdx:mcp:inventorySource") !==
+        undefined ||
+      inventoryPropertyValue(subject, "cdx:mcp:role") !== undefined
+    );
+  }
+  return matchesAiInventoryType(subject, type);
+}
+
+export function filterInventorySubjectsByTypes(subjects, types) {
+  const allowedTypes = uniqueNonEmptyTypes(types);
+  if (!allowedTypes.length) {
+    return [];
+  }
+  return (subjects || []).filter((subject) =>
+    inventoryTypesForSubject(subject).some((type) =>
+      allowedTypes.includes(type),
+    ),
+  );
+}
+
+export function filterInventoryDependencies(
+  dependencies,
+  components,
+  services,
+) {
+  const allowedRefs = new Set(
+    []
+      .concat(components || [])
+      .concat(services || [])
+      .map((subject) => subject?.["bom-ref"])
+      .filter(Boolean),
+  );
+  return (dependencies || [])
+    .filter((dependency) => allowedRefs.has(dependency.ref))
+    .map((dependency) => {
+      const filteredDependency = {
+        ref: dependency.ref,
+      };
+      if (dependency.dependsOn?.length) {
+        filteredDependency.dependsOn = dependency.dependsOn.filter((ref) =>
+          allowedRefs.has(ref),
+        );
+      }
+      if (dependency.provides?.length) {
+        filteredDependency.provides = dependency.provides.filter((ref) =>
+          allowedRefs.has(ref),
+        );
+      }
+      return filteredDependency;
+    });
+}
+
+export function collectAiInventory(discoveryPath, options, types) {
+  const requestedTypes = uniqueNonEmptyTypes(types);
+  if (!requestedTypes.length) {
+    return { components: [], dependencies: [], services: [] };
+  }
+  let components = [];
+  const dependencies = [];
+  let services = [];
+  for (const parserEntry of AI_INVENTORY_PARSERS) {
+    if (!parserEntry.types.some((type) => requestedTypes.includes(type))) {
+      continue;
+    }
+    const matchedFiles = [];
+    for (const pattern of parserEntry.parser.patterns) {
+      const found = getAllFiles(discoveryPath, pattern, options);
+      if (found?.length) {
+        matchedFiles.push(...found);
+      }
+    }
+    const uniqueMatchedFiles = [...new Set(matchedFiles)];
+    if (!uniqueMatchedFiles.length) {
+      continue;
+    }
+    let result;
+    try {
+      result = parserEntry.parser.parse(uniqueMatchedFiles, options);
+    } catch (err) {
+      console.warn(
+        `[aiInventory] Parser "${parserEntry.id}" threw an error:`,
+        err.message,
+      );
+      continue;
+    }
+    if (result?.components?.length) {
+      components = components.concat(result.components);
+    }
+    if (result?.services?.length) {
+      services = mergeServices(services, result.services);
+    }
+    if (result?.dependencies?.length) {
+      dependencies.push(...result.dependencies);
+    }
+  }
+  components = trimComponents(
+    filterInventorySubjectsByTypes(components, requestedTypes),
+  );
+  services = mergeServices(
+    [],
+    filterInventorySubjectsByTypes(services, requestedTypes),
+  );
+  return {
+    components,
+    dependencies: filterInventoryDependencies(
+      dependencies,
+      components,
+      services,
+    ),
+    services,
+  };
+}
+
+export function summarizeAiInventory(inventory) {
+  const components = inventory?.components || [];
+  const services = inventory?.services || [];
+  return {
+    instructionCount: components.filter((component) =>
+      AI_INSTRUCTION_FILE_KINDS.has(
+        inventoryPropertyValue(component, "cdx:file:kind"),
+      ),
+    ).length,
+    mcpConfigCount: components.filter(
+      (component) =>
+        inventoryPropertyValue(component, "cdx:file:kind") ===
+        MCP_CONFIG_FILE_KIND,
+    ).length,
+    mcpServiceCount: services.length,
+    skillCount: components.filter(
+      (component) =>
+        inventoryPropertyValue(component, "cdx:file:kind") ===
+        AI_SKILL_FILE_KIND,
+    ).length,
+  };
+}