@cyclonedx/cdxgen 11.2.4 → 11.2.6

package/README.md

@@ -516,7 +516,7 @@ Please check out our [contribute to CycloneDX/cdxgen documentation][github-contr
 
 Before raising a PR, please run the following commands.
 
-```bash
+```shell
 corepack enable pnpm
 pnpm install --config.strict-dep-builds=true
 # Generate types using jsdoc syntax
@@ -527,6 +527,17 @@ pnpm run lint
 pnpm test
 ```
 
+### Testing main branch
+
+Use `pnpm add -g` command to quickly test the main branch.
+
+```shell
+corepack pnpm bin -g
+corepack pnpm setup
+corepack pnpm add -g --allow-build sqlite3 https://github.com/CycloneDX/cdxgen
+cdxgen --help
+```
+
 ## Sponsors
 
 <img src="./docs/_media/LevoLogo-LightBg.jpg" width="200" height="auto">

package/bin/cdxgen.js

@@ -196,17 +196,14 @@ const args = yargs(hideBin(process.argv))
   })
   .option("usages-slices-file", {
     description: "Path for the usages slices file created by atom.",
-    default: "usages.slices.json",
     hidden: true,
   })
   .option("data-flow-slices-file", {
     description: "Path for the data-flow slices file created by atom.",
-    default: "data-flow.slices.json",
     hidden: true,
   })
   .option("reachables-slices-file", {
     description: "Path for the reachables slices file created by atom.",
-    default: "reachables.slices.json",
     hidden: true,
   })
   .option("semantics-slices-file", {
@@ -214,6 +211,10 @@ const args = yargs(hideBin(process.argv))
     default: "semantics.slices.json",
     hidden: true,
   })
+  .option("openapi-spec-file", {
+    description: "Path for the openapi specification file (SaaSBOM).",
+    hidden: true,
+  })
   .option("spec-version", {
     description: "CycloneDX Specification version to use. Defaults to 1.6",
     default: 1.6,
@@ -989,6 +990,7 @@ const checkPermissions = (filePath, options) => {
       dataFlowSlicesFile: options.dataFlowSlicesFile,
       reachablesSlicesFile: options.reachablesSlicesFile,
       semanticsSlicesFile: options.semanticsSlicesFile,
+      openapiSpecFile: options.openapiSpecFile,
       includeCrypto: options.includeCrypto,
       specVersion: options.specVersion,
       profile: options.profile,

package/data/component-tags.json

@@ -231,7 +231,7 @@
     "sbom": [
       {
         "test": [
-          "(junit|xmlunit|testng|mocha|jest|test4j|xunit|coverlet|Test\\.Sdk)",
+          "(junit|xmlunit|testng|mocha|jest|test4j|xunit|coverlet|Test\\.Sdk|Moq)",
           "^(chai)$"
         ]
       },

package/data/frameworks-list.json

@@ -5,6 +5,16 @@
     "System.Data",
     "Microsoft.AspNetCore",
     "Microsoft.NETCore",
+    "Microsoft.EntityFrameworkCore",
+    "pkg:nuget/EntityFramework",
+    "pkg:nuget/Microsoft.Build.Framework",
+    "EntityFrameworkCore",
+    "Microsoft.Data.OData",
+    "Microsoft.NETCore.Targets",
+    "System.Diagnostics.DiagnosticSource",
+    "Microsoft.OData.",
+    "Google.Cloud.",
+    "PnP.Framework",
     "springframework",
     "pkg:maven/us.springett/alpine",
     "pkg:pypi/flask",

package/data/helpers/init.gradle

@@ -0,0 +1,5 @@
+gradle.taskGraph.whenReady {
+    gradle.includedBuilds.each { includedBuild ->
+        println "<CDXGEN:includedBuild>:${includedBuild.name}"
+    }
+}

package/lib/cli/index.js

@@ -15,7 +15,6 @@ import {
 import { platform as _platform, arch, homedir } from "node:os";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import process from "node:process";
-import { URL } from "node:url";
 import got from "got";
 import { load as loadYaml } from "js-yaml";
 import { PackageURL } from "packageurl-js";
@@ -33,8 +32,6 @@ import {
   listFiles,
 } from "../helpers/envcontext.js";
 import { thoughtLog } from "../helpers/logger.js";
-
-import { analyzeBuildSettings } from "../helpers/package_specific/gradleutils.js";
 import {
   CARGO_CMD,
   CLJ_CMD,
@@ -226,6 +223,14 @@ if (process.env.GRADLE_USER_HOME) {
   );
 }
 
+// Construct path to gradle init script
+const GRADLE_INIT_SCRIPT = resolve(
+  dirNameStr,
+  "data",
+  "helpers",
+  "init.gradle",
+);
+
 // Construct sbt cache directory
 const SBT_CACHE_DIR =
   process.env.SBT_CACHE_DIR || join(homedir(), ".ivy2", "cache");
@@ -1226,6 +1231,13 @@ function determinePackageType(pkg) {
       }
     }
   }
+  if (Object.prototype.hasOwnProperty.call(pkg, "tags")) {
+    for (const tag of pkg.tags) {
+      if (tag && tag.toLowerCase() === "framework") {
+        return "framework";
+      }
+    }
+  }
   return "library";
 }
 
@@ -1959,59 +1971,49 @@ export async function createJavaBom(path, options) {
       options,
     )
   ) {
-    let rootProjects = [null];
+    let includedBuilds = [];
     let allProjectsStr = [];
-    let rootGradleModule = {};
-    let includedProjectsFound = false;
     if (process.env.GRADLE_INCLUDED_BUILDS) {
-      // Automatically add the colon prefix
-      const includedBuilds = process.env.GRADLE_INCLUDED_BUILDS.split(",").map(
-        (b) => (!b.startsWith(":") ? `:${b}` : b),
+      includedBuilds = process.env.GRADLE_INCLUDED_BUILDS.split(",").map((b) =>
+        !b.startsWith(":") ? `:${b}` : b,
       );
-      rootProjects = rootProjects.concat(includedBuilds);
-      includedProjectsFound = true;
-    } else {
-      // Automatically detect included builds
-      // Only from the root path for now
-      for (const abuildFile of [
-        join(gradleRootPath, "build.gradle"),
-        join(gradleRootPath, "build.gradle.kts"),
-        join(gradleRootPath, "settings.gradle"),
-        join(gradleRootPath, "settings.gradle.kts"),
-      ]) {
-        if (!safeExistsSync(abuildFile)) {
-          continue;
+    }
+    let parallelPropTaskOut = executeParallelGradleProperties(
+      gradleRootPath,
+      [null].concat(includedBuilds),
+      process.env.GRADLE_INCLUDED_BUILDS
+        ? []
+        : ["--init-script", GRADLE_INIT_SCRIPT],
+    );
+    if (process.env.GRADLE_INCLUDED_BUILDS === undefined) {
+      const outputLines = parallelPropTaskOut.split("\n");
+      for (const [i, line] of outputLines.entries()) {
+        if (line.startsWith("Root project '") || line.startsWith("Project '")) {
+          break;
         }
-        const buildSettings = analyzeBuildSettings(abuildFile);
-        if (buildSettings?.includedBuilds?.length) {
-          for (const aib of buildSettings.includedBuilds) {
-            if (!rootProjects.includes(aib)) {
-              rootProjects.push(aib);
-              includedProjectsFound = true;
-            }
+        if (line.startsWith("<CDXGEN:includedBuild>")) {
+          const includedBuild = line.split(">");
+          if (!includedBuilds.includes(includedBuild[1].trim())) {
+            includedBuilds.push(includedBuild[1].trim());
           }
-          break;
         }
       }
-    }
-    if (includedProjectsFound) {
-      thoughtLog(
-        `Wait, this gradle project uses composite builds. I must carefully process these ${rootProjects.length} projects including the root.`,
-      );
-      if (DEBUG_MODE) {
-        console.log(
-          `Additional root projects: ${rootProjects.join(" ").trim()}.`,
+      if (includedBuilds.length > 0) {
+        thoughtLog(
+          `Wait, this gradle project uses composite builds. I must carefully process these ${includedBuilds.length} projects, in addition to the root.`,
+        );
+        if (DEBUG_MODE) {
+          console.log(`Composite builds: ${includedBuilds.join(" ").trim()}.`);
+        }
+        parallelPropTaskOut = parallelPropTaskOut.concat(
+          "\n",
+          executeParallelGradleProperties(gradleRootPath, includedBuilds),
         );
       }
     }
-    const parallelPropTaskOut = executeParallelGradleProperties(
-      gradleRootPath,
-      rootProjects,
-    );
     const splitPropTaskOut = splitOutputByGradleProjects(parallelPropTaskOut, [
       "properties",
     ]);
-
     for (const [key, propTaskOut] of splitPropTaskOut.entries()) {
       const retMap = parseGradleProperties(propTaskOut);
       const rootProject = retMap.rootProject;
@@ -2020,18 +2022,11 @@ export async function createJavaBom(path, options) {
           rootProject,
           retMap.metadata,
         );
+        if (!includedBuilds.includes(key)) {
+          parentComponent = rootComponent;
+        }
         gradleModules.set(key, rootComponent);
-        if (!rootProjects.includes(key)) {
-          if (rootGradleModule.name) {
-            if (DEBUG_MODE) {
-              console.log(
-                `Received new root component: ${rootComponent.name} with key ${key}. Please verify the value used for included builds. Using the name ${rootGradleModule.name}.`,
-              );
-            }
-          } else {
-            rootGradleModule = rootComponent;
-          }
-        } else if (!allProjectsAddedPurls.includes(rootComponent["purl"])) {
+        if (!allProjectsAddedPurls.includes(rootComponent["purl"])) {
           allProjects.push(rootComponent);
           rootDependsOn.add(rootComponent["bom-ref"]);
           allProjectsAddedPurls.push(rootComponent["purl"]);
@@ -2039,7 +2034,6 @@ export async function createJavaBom(path, options) {
         allProjectsStr = allProjectsStr.concat(retMap.projects);
       }
     }
-    parentComponent = rootGradleModule;
     // Get the sub-project properties and set the root dependencies
     if (allProjectsStr?.length) {
       const modulesToSkip = process.env.GRADLE_SKIP_MODULES
@@ -2129,32 +2123,36 @@ export async function createJavaBom(path, options) {
       process.env.GRADLE_ARGS_DEPENDENCIES
         ? process.env.GRADLE_ARGS_DEPENDENCIES.split(" ")
         : [],
+      gradleCmd.length,
     );
-    if (DEBUG_MODE) {
-      console.log(
-        "Executing",
-        gradleCmd,
-        `${gradleArguments.join(" ").substring(0, 150)} ...`,
-        "in",
-        gradleRootPath,
+    const allOutputs = [];
+    for (const gradleArg of gradleArguments) {
+      if (DEBUG_MODE) {
+        console.log(
+          `Executing ${gradleCmd} with arguments ${gradleArg.join(" ").substring(0, 150)}... in ${gradleRootPath}`,
+        );
+      }
+      thoughtLog(
+        `Let's invoke '${basename(gradleCmd)}' with the arguments '${gradleArg.join(" ").substring(0, 100)} ...'.`,
       );
-    }
-    thoughtLog(
-      `Let's invoke '${basename(gradleCmd)}' with the arguments '${gradleArguments.join(" ").substring(0, 100)} ...'.`,
-    );
-    const sresult = spawnSync(gradleCmd, gradleArguments, {
-      cwd: gradleRootPath,
-      encoding: "utf-8",
-      timeout: TIMEOUT_MS,
-      maxBuffer: MAX_BUFFER,
-    });
-    if (sresult.status !== 0 || sresult.error) {
-      if (options.failOnError || DEBUG_MODE) {
-        console.error(sresult.stdout, sresult.stderr);
+      const sresult = spawnSync(gradleCmd, gradleArg, {
+        cwd: gradleRootPath,
+        encoding: "utf-8",
+        shell: isWin,
+        timeout: TIMEOUT_MS,
+        maxBuffer: MAX_BUFFER,
+      });
+      if (sresult.status !== 0 || sresult.error) {
+        if (options.failOnError || DEBUG_MODE) {
+          console.error(sresult.stdout, sresult.stderr);
+        }
+        options.failOnError && process.exit(1);
+      }
+      if (sresult.stdout !== null) {
+        allOutputs.push(sresult.stdout);
       }
-      options.failOnError && process.exit(1);
     }
-    const sstdout = sresult.stdout;
+    const sstdout = allOutputs.join("\n");
     if (sstdout) {
       const cmdOutput = Buffer.from(sstdout).toString();
       const perProjectOutput = splitOutputByGradleProjects(cmdOutput, [
@@ -2213,6 +2211,29 @@ export async function createJavaBom(path, options) {
       }
       options.failOnError && process.exit(1);
     }
+    if (
+      (!process.env.GRADLE_STOP_DAEMON &&
+        (!process.env.GRADLE_USE_DAEMON ||
+          ["true", "1"].includes(process.env.GRADLE_USE_DAEMON))) ||
+      ["true", "1"].includes(process.env.GRADLE_STOP_DAEMON)
+    ) {
+      if (DEBUG_MODE) {
+        console.log("Stopping gradle daemon...");
+      }
+      const sresult = spawnSync(gradleCmd, ["--stop"], {
+        cwd: gradleRootPath,
+        encoding: "utf-8",
+        shell: isWin,
+        timeout: TIMEOUT_MS,
+        maxBuffer: MAX_BUFFER,
+      });
+      if (sresult.status !== 0 || sresult.error) {
+        if (options.failOnError || DEBUG_MODE) {
+          console.error(sresult.stdout, sresult.stderr);
+        }
+        options.failOnError && process.exit(1);
+      }
+    }
     // Should we attempt to resolve class names
     if (options.resolveClass || options.deep) {
       const tmpjarNSMapping = await collectJarNS(GRADLE_CACHE_DIR);
@@ -2581,14 +2602,16 @@ export async function createJavaBom(path, options) {
     );
     const millCmd = getMillCommand(millRootPath);
     const millCommonArgs = [
-      "--no-server",
-      "--silent",
-      "--disable-prompt",
-      "--disable-callgraph",
-      "-k",
       "--color",
       "false",
+      "--disable-callgraph",
+      "--disable-prompt",
+      "--keep-going",
+      "--silent",
     ];
+    if (!["true", "1"].includes(process.env.MILL_USE_SERVER)) {
+      millCommonArgs.unshift("--no-server");
+    }
     const millArgs = [...millCommonArgs, "__.ivyDepsTree"];
     if (DEBUG_MODE) {
       console.log("Executing", millCmd, millArgs.join(" "), "in", millRootPath);
@@ -2674,6 +2697,28 @@ export async function createJavaBom(path, options) {
         parentComponent,
       );
     }
+    if (
+      (!process.env.MILL_SHUTDOWN_SERVER &&
+        ["true", "1"].includes(process.env.MILL_USE_SERVER)) ||
+      ["true", "1"].includes(process.env.MILL_SHUTDOWN_SERVER)
+    ) {
+      if (DEBUG_MODE) {
+        console.log("Shutting down mill server...");
+      }
+      const sresult = spawnSync(millCmd, ["shutdown"], {
+        cwd: millRootPath,
+        encoding: "utf-8",
+        shell: isWin,
+        timeout: TIMEOUT_MS,
+        maxBuffer: MAX_BUFFER,
+      });
+      if (sresult.status !== 0 || sresult.error) {
+        if (options.failOnError || DEBUG_MODE) {
+          console.error(sresult.stdout, sresult.stderr);
+        }
+        options.failOnError && process.exit(1);
+      }
+    }
   }
 
   pkgList = trimComponents(pkgList);
@@ -2722,11 +2767,7 @@ export async function createNodejsBom(path, options) {
   let allImports = {};
   let allExports = {};
   if (
-    !hasAnyProjectType(
-      ["docker", "oci", "container", "os", "pnpm"],
-      options,
-      false,
-    ) &&
+    !hasAnyProjectType(["docker", "oci", "container", "os"], options, false) &&
     !options.noBabel
   ) {
     if (DEBUG_MODE) {

package/lib/evinser/evinser.js

@@ -235,6 +235,8 @@ export async function createSlice(
     language = "js";
   } else if (language.startsWith("python")) {
     language = "python";
+  } else if (PROJECT_TYPE_ALIASES.scala.includes(language)) {
+    language = "scala";
   }
   if (
     PROJECT_TYPE_ALIASES.swift.includes(language) &&
@@ -251,11 +253,13 @@ export async function createSlice(
         ? path.basename(options.output)
         : path.dirname(options.output);
   }
-  const slicesFile = join(sliceOutputDir, `${sliceType}.slices.json`);
+  const slicesFile =
+    options[`${sliceType}SlicesFile`] ||
+    join(sliceOutputDir, `${language}-${sliceType}.slices.json`);
   const openapiSpecFile = basename(
     options.openapiSpecFile ||
       process.env?.ATOM_TOOLS_OPENAPI_FILENAME ||
-      "openapi.json",
+      `${language}-openapi.json`,
   );
   // For some languages such as scala, semantics slices file would get created during usages slicing.
   let semanticsSlicesFile;
@@ -317,7 +321,7 @@ export async function createSlice(
     ATOM_TOOLS_OPENAPI_FILENAME: openapiSpecFile, // The file would get over-written
     ATOM_TOOLS_OPENAPI_FORMAT:
       process.env?.ATOM_TOOLS_OPENAPI_FORMAT || "openapi3.1.0", // editor.swagger.io doesn't support 3.1.0 yet
-    ATOM_TOOLS_WORK_DIR: resolve(filePath), // This must be the directory containing semantics.slices.json
+    ATOM_TOOLS_WORK_DIR: process.env?.ATOM_TOOLS_WORK_DIR || resolve(filePath), // This must be the directory containing semantics.slices.json
     OPENAPI_SERVER_URL: process.env?.OPENAPI_SERVER_URL,
   });
   if (!result || !safeExistsSync(slicesFile)) {
@@ -1408,7 +1412,6 @@ export function createEvinseFile(sliceArtefacts, options) {
     dataFlowFrames,
     cryptoComponents,
     cryptoGeneratePurls,
-    openapiSpecFile,
   } = sliceArtefacts;
   const bomFile = options.input;
   const evinseOutFile = options.output;

package/lib/helpers/envcontext.js

@@ -29,10 +29,10 @@ export const GIT_COMMAND = process.env.GIT_CMD || "git";
 
 // sdkman tool aliases
 export const SDKMAN_JAVA_TOOL_ALIASES = {
-  java8: process.env.JAVA8_TOOL || "8.0.442-amzn", // Temurin no longer offers java8 :(
-  java11: process.env.JAVA11_TOOL || "11.0.25-tem",
-  java17: process.env.JAVA17_TOOL || "17.0.14-tem",
-  java21: process.env.JAVA21_TOOL || "21.0.6-tem",
+  java8: process.env.JAVA8_TOOL || "8.0.452-amzn", // Temurin no longer offers java8 :(
+  java11: process.env.JAVA11_TOOL || "11.0.26-tem",
+  java17: process.env.JAVA17_TOOL || "17.0.15-tem",
+  java21: process.env.JAVA21_TOOL || "21.0.7-tem",
   java22: process.env.JAVA22_TOOL || "22.0.2-tem",
   java23: process.env.JAVA23_TOOL || "23.0.2-tem",
   java24: process.env.JAVA24_TOOL || "24-tem",

package/lib/helpers/utils.js

@@ -3998,74 +3998,88 @@ export function parseGradleProperties(rawOutput, gradleModuleName = null) {
  *
  * @param {string} dir Directory to execute the command
  * @param {array} allProjectsStr List of all sub-projects (including the preceding `:`)
+ * @param {array} extraArgs List of extra arguments to use when calling gradle
  *
  * @returns {string} The combined output for all subprojects of the Gradle properties task
  */
-export function executeParallelGradleProperties(dir, allProjectsStr) {
+export function executeParallelGradleProperties(
+  dir,
+  allProjectsStr,
+  extraArgs = [],
+) {
   const gradleCmd = getGradleCommand(dir, null);
   const gradleArgs = buildGradleCommandArguments(
-    process.env.GRADLE_ARGS ? process.env.GRADLE_ARGS.split(" ") : [],
+    extraArgs.concat(
+      process.env.GRADLE_ARGS ? process.env.GRADLE_ARGS.split(" ") : [],
+    ),
     allProjectsStr.map((project) =>
       project ? `${project}:properties` : "properties",
     ),
     process.env.GRADLE_ARGS_PROPERTIES
       ? process.env.GRADLE_ARGS_PROPERTIES.split(" ")
       : [],
+    gradleCmd.length,
   );
-  if (DEBUG_MODE) {
-    console.log(
-      `Executing ${gradleCmd} with arguments ${gradleArgs.join(" ").substring(0, 150)}... in ${dir}`,
-    );
-  }
-  const result = spawnSync(gradleCmd, gradleArgs, {
-    cwd: dir,
-    encoding: "utf-8",
-    shell: isWin,
-    maxBuffer: MAX_BUFFER,
-  });
-  if (result.status !== 0 || result.error) {
-    if (process.env?.CDXGEN_IN_CONTAINER === "true") {
-      thoughtLog(
-        "Gradle build has failed. Perhaps the user is using the wrong container image?",
-      );
-    } else {
-      thoughtLog(
-        "Gradle build has failed. I recommend using Java container images.",
-      );
-    }
-    if (result.stderr) {
-      console.group("*** GRADLE BUILD ERRORS ***");
-      console.error(result.stdout, result.stderr);
-      console.groupEnd();
-      console.log(
-        "1. Check if the correct version of java and gradle are installed and available in PATH. For example, some project might require Java 11 with gradle 7.\n cdxgen container image bundles Java 23 with gradle 8 which might be incompatible.",
-      );
+  const allOutputs = [];
+  for (const gradleArg of gradleArgs) {
+    if (DEBUG_MODE) {
       console.log(
-        "2. Try running cdxgen with the custom JDK11-based image `ghcr.io/cyclonedx/cdxgen-java11:v11`.",
+        `Executing ${gradleCmd} with arguments ${gradleArg.join(" ").substring(0, 150)}... in ${dir}`,
       );
-      if (result.stderr?.includes("not get unknown property")) {
-        console.log(
-          "3. Check if the SBOM is generated for the correct root project for your application.",
+    }
+    const result = spawnSync(gradleCmd, gradleArg, {
+      cwd: dir,
+      encoding: "utf-8",
+      shell: isWin,
+      maxBuffer: MAX_BUFFER,
+    });
+    if (result.status !== 0 || result.error) {
+      if (process.env?.CDXGEN_IN_CONTAINER === "true") {
+        thoughtLog(
+          "Gradle build has failed. Perhaps the user is using the wrong container image?",
         );
-      } else if (
-        result.stderr?.includes(
-          "In version catalog libs, import of external catalog file failed",
-        )
-      ) {
+      } else {
+        thoughtLog(
+          "Gradle build has failed. I recommend using Java container images.",
+        );
+      }
+      if (result.stderr) {
+        console.group("*** GRADLE BUILD ERRORS ***");
+        console.error(result.stdout, result.stderr);
+        console.groupEnd();
         console.log(
-          "3. Catalog file is required for gradle dependency resolution to succeed.",
+          "1. Check if the correct version of java and gradle are installed and available in PATH. For example, some project might require Java 11 with gradle 7.\n cdxgen container image bundles Java 23 with gradle 8 which might be incompatible.",
         );
-      } else if (result.stderr?.includes("Unrecognized option")) {
         console.log(
-          "3. Try removing the unrecognized options to improve compatibility with a range of Java versions. Refer to the error message above.",
+          "2. Try running cdxgen with the custom JDK11-based image `ghcr.io/cyclonedx/cdxgen-java11:v11`.",
         );
-      }
-      if (result.stderr.includes("does not exist")) {
-        return "";
+        if (result.stderr?.includes("not get unknown property")) {
+          console.log(
+            "3. Check if the SBOM is generated for the correct root project for your application.",
+          );
+        } else if (
+          result.stderr?.includes(
+            "In version catalog libs, import of external catalog file failed",
+          )
+        ) {
+          console.log(
+            "3. Catalog file is required for gradle dependency resolution to succeed.",
+          );
+        } else if (result.stderr?.includes("Unrecognized option")) {
+          console.log(
+            "3. Try removing the unrecognized options to improve compatibility with a range of Java versions. Refer to the error message above.",
+          );
+        }
+        if (result.stderr.includes("does not exist")) {
+          return "";
+        }
       }
     }
+    if (result.stdout !== null) {
+      allOutputs.push(result.stdout);
+    }
   }
-  const stdout = result.stdout;
+  const stdout = allOutputs.join("\n");
   if (stdout) {
     return Buffer.from(stdout).toString();
   }
@@ -10451,6 +10465,10 @@ export function parseSbtTree(sbtTreeFile) {
       name = pkgParts[0];
       version = pkgParts[1];
     }
+    if (!name?.length) {
+      console.log(pkgLine, "was not parsed correctly!");
+      return;
+    }
     const purlString = new PackageURL(
       "maven",
       group,
@@ -12119,25 +12137,63 @@ export function getMillCommand(srcPath) {
  * @param {string[]} gradleArguments The general gradle arguments, which must only be added once
  * @param {string[]} gradleSubCommands The sub-commands that are to be executed by gradle
  * @param {string[]} gradleSubCommandArguments The arguments specific to the sub-command(s), which much be added PER sub-command
+ * @param {int} gradleCommandLength The length of the full gradle-command
  *
- * @returns {string[]} Array of arguments to be added to the gradle command
+ * @returns {string[]} Array of arrays of arguments to be added to the gradle command
  */
 export function buildGradleCommandArguments(
   gradleArguments,
   gradleSubCommands,
   gradleSubCommandArguments,
+  gradleCommandLength,
 ) {
-  let allGradleArguments = [
+  const mainGradleArguments = [
     "--build-cache",
     "--console",
     "plain",
     "--no-parallel",
-  ].concat(gradleArguments);
+  ]
+    .concat(getGradleDaemonParameter())
+    .concat(gradleArguments);
+  const maxCliArgsLength = isWin
+    ? 7500 - gradleCommandLength - mainGradleArguments.join(" ").length - 2
+    : -1;
+  if (DEBUG_MODE && maxCliArgsLength !== -1) {
+    console.log(
+      "Running on Windows with a very long command -- splitting into multiple commands",
+    );
+  }
+  const splitArgs = [];
+  let allGradleArguments = [].concat(mainGradleArguments);
+  let remainingLength = maxCliArgsLength;
   for (const gradleSubCommand of gradleSubCommands) {
+    const subCommandLength =
+      [gradleSubCommand, ...gradleSubCommandArguments].join(" ").length + 1;
+    if (maxCliArgsLength !== -1 && remainingLength - subCommandLength < 0) {
+      splitArgs.push(allGradleArguments);
+      allGradleArguments = [].concat(mainGradleArguments);
+      remainingLength = maxCliArgsLength;
+    }
     allGradleArguments.push(gradleSubCommand);
     allGradleArguments = allGradleArguments.concat(gradleSubCommandArguments);
+    remainingLength -= subCommandLength;
+  }
+  if (allGradleArguments.length !== mainGradleArguments.length) {
+    splitArgs.push(allGradleArguments);
+  }
+  return splitArgs;
+}
+
+function getGradleDaemonParameter() {
+  switch (process.env.GRADLE_USE_DAEMON) {
+    case "default":
+      return [];
+    case "false":
+    case "1":
+      return ["--no-daemon"];
+    default:
+      return ["--daemon"];
   }
-  return allGradleArguments;
 }
 
 /**
@@ -12609,7 +12665,9 @@ function fullScanCocoaPod(dependency, component, options) {
     component.authors = [];
     if (podspec.authors.constructor === Object) {
       Object.entries(podspec.authors).forEach(([name, email]) =>
-        component.authors.push({ name, email }),
+        email.includes("@")
+          ? component.authors.push({ name, email })
+          : component.authors.push({ name }),
       );
     } else if (podspec.authors.constructor === Array) {
       podspec.authors.forEach((name) => component.authors.push({ name }));

package/lib/helpers/utils.test.js

@@ -1386,7 +1386,7 @@ describe("go data with licenses", () => {
     });
   }, 120000);
 
-  test("parseGoModData with licenses", async () => {
+  test.skip("parseGoModData with licenses", async () => {
     let retMap = await parseGoModData(null);
     expect(retMap).toEqual({});
     const gosumMap = {
@@ -2462,12 +2462,6 @@ test("parse github actions workflow data", () => {
     name: "checkout",
     version: "v4",
   });
-  dep_list = parseGitHubWorkflowData(
-    readFileSync("./.github/workflows/app-release.yml", {
-      encoding: "utf-8",
-    }),
-  );
-  expect(dep_list.length).toEqual(3);
 });
 
 test("parse cs pkg data", () => {

package/lib/helpers/validator.js

@@ -285,7 +285,7 @@ export const validateRefs = (bomJson) => {
             parentPurlType &&
             childPurlType &&
             parentPurlType !== childPurlType &&
-            !["oci", "generic"].includes(parentPurlType)
+            !["oci", "generic", "container"].includes(parentPurlType)
           ) {
             warningsList.push(
               `The parent package '${dep.ref}' (type ${parentPurlType}) depends on the child package '${don}' (type ${childPurlType}). This is a bug in cdxgen if this project is not a monorepo.`,

package/lib/managers/binary.js

@@ -9,7 +9,7 @@ import {
   statSync,
 } from "node:fs";
 import { arch as _arch, platform as _platform, homedir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
 import process from "node:process";
 import { PackageURL } from "packageurl-js";
 import {
@@ -28,8 +28,6 @@ import {
   safeMkdirSync,
 } from "../helpers/utils.js";
 
-import { URL } from "node:url";
-
 const dirName = dirNameStr;
 
 const isWin = _platform() === "win32";
@@ -60,6 +58,9 @@ switch (arch) {
     break;
 }
 
+// cdxgen plugins version
+const CDXGEN_PLUGINS_VERSION = "1.6.10";
+
 // Retrieve the cdxgen plugins directory
 let CDXGEN_PLUGINS_DIR = process.env.CDXGEN_PLUGINS_DIR;
 // Is there a non-empty local plugins directory
@@ -126,11 +127,54 @@ if (!CDXGEN_PLUGINS_DIR) {
       `cdxgen-plugins-bin${pluginsBinSuffix}`,
       "plugins",
     );
+    // pnpm add -g
+    let altGlobalPlugins;
+    if (dirName.includes(join("node_modules", ".pnpm", "@cyclonedx+cdxgen"))) {
+      const tmpA = dirName.split(join("node_modules", ".pnpm"));
+      altGlobalPlugins = join(
+        tmpA[0],
+        "node_modules",
+        ".pnpm",
+        `@cyclonedx+cdxgen-plugins-bin${pluginsBinSuffix}@${CDXGEN_PLUGINS_VERSION}`,
+        "node_modules",
+        "@cyclonedx",
+        `cdxgen-plugins-bin${pluginsBinSuffix}`,
+        "plugins",
+      );
+    } else if (dirName.includes(join(".pnpm", "@cyclonedx+cdxgen"))) {
+      // pnpm dlx
+      const tmpA = dirName.split(".pnpm");
+      altGlobalPlugins = join(
+        tmpA[0],
+        ".pnpm",
+        `@cyclonedx+cdxgen-plugins-bin${pluginsBinSuffix}@${CDXGEN_PLUGINS_VERSION}`,
+        "node_modules",
+        "@cyclonedx",
+        `cdxgen-plugins-bin${pluginsBinSuffix}`,
+        "plugins",
+      );
+    }
+    const extraNMBinPath = join(
+      globalNodePath,
+      "..",
+      ".pnpm",
+      "node_modules",
+      ".bin",
+    );
     if (existsSync(globalPlugins)) {
       CDXGEN_PLUGINS_DIR = globalPlugins;
       if (DEBUG_MODE) {
         console.log("Found global plugins", CDXGEN_PLUGINS_DIR);
       }
+    } else if (altGlobalPlugins && existsSync(altGlobalPlugins)) {
+      CDXGEN_PLUGINS_DIR = altGlobalPlugins;
+      // To help detect bin commands such as atom, astgen, etc, we need to set this to the PATH variable.
+      if (!process.env?.PATH?.includes(extraNMBinPath)) {
+        process.env.PATH = `${extraNMBinPath}${delimiter}${process.env.PATH}`;
+      }
+      if (DEBUG_MODE) {
+        console.log("Found global plugins", CDXGEN_PLUGINS_DIR);
+      }
     }
   }
 }
@@ -232,6 +276,7 @@ const OS_DISTRO_ALIAS = {
   "ubuntu-23.10": "mantic",
   "ubuntu-24.04": "noble",
   "ubuntu-24.10": "oracular",
+  "ubuntu-25.04": "plucky",
   "debian-14": "forky",
   "debian-14.5": "forky",
   "debian-13": "trixie",

package/lib/managers/docker.js

@@ -650,22 +650,44 @@ export const getImage = async (fullImageName) => {
         dockerCmd = "nerdctl";
       }
     }
-    let result = spawnSync(dockerCmd, ["pull", fullImageName], {
+    let needsPull = true;
+    // Let's check the local cache first
+    let result = spawnSync(dockerCmd, ["images", "--format=json"], {
       encoding: "utf-8",
     });
-    if (result.status !== 0 || result.error) {
-      if (result.stderr?.includes("docker daemon is not running")) {
-        console.log(
-          "Ensure Docker for Desktop is running as an administrator with 'Exposing daemon on TCP without TLS' setting turned on.",
-        );
-      } else if (result.stderr?.includes("not found")) {
-        console.log(
-          "Set the environment variable DOCKER_CMD to use an alternative command such as nerdctl or podman.",
-        );
-      } else {
-        console.log(result.stderr);
+    if (result.status === 0 && result.stdout) {
+      for (const imgLine of result.stdout.split("\n")) {
+        try {
+          const imgObj = JSON.parse(Buffer.from(imgLine).toString());
+          if (
+            imgObj.Repository === fullImageName ||
+            imgObj?.Name?.endsWith(fullImageName)
+          ) {
+            needsPull = false;
+            break;
+          }
+        } catch (err) {
+          // continue regardless of error
+        }
+      }
+    }
+    if (needsPull) {
+      result = spawnSync(dockerCmd, ["pull", fullImageName], {
+        encoding: "utf-8",
+      });
+      if (result.status !== 0 || result.error) {
+        if (result.stderr?.includes("docker daemon is not running")) {
+          console.log(
+            "Ensure Docker for Desktop is running as an administrator with 'Exposing daemon on TCP without TLS' setting turned on.",
+          );
+        } else if (result.stderr?.includes("not found")) {
+          console.log(
+            "Set the environment variable DOCKER_CMD to use an alternative command such as nerdctl or podman.",
+          );
+        } else {
+          console.log(result.stderr);
+        }
       }
-      return localData;
     }
     result = spawnSync(dockerCmd, ["inspect", fullImageName], {
       encoding: "utf-8",
@@ -901,22 +923,16 @@ export const extractTar = async (fullImageName, dir, options) => {
       return false;
     } else if (["EACCES"].includes(err.code)) {
       console.log(err);
-      /*
-       * We do not display errors messages for errors:
-       * 1) TAR_ENTRY_INFO is an informative error indicating that an entry is being modified.
-       * 2) TAR_ENTRY_INVALID indicates that a given entry is not valid tar archive entry and will be skipped.
-       */
-    } else if (
-      DEBUG_MODE &&
-      ["TAR_ENTRY_INFO", "TAR_ENTRY_INVALID"].includes(err.code)
-    ) {
+    } else if (["TAR_ENTRY_INFO", "TAR_ENTRY_INVALID"].includes(err.code)) {
       if (
         err?.header?.path?.includes("{") ||
         err?.message?.includes("linkpath required")
       ) {
         return false;
       }
-      console.log(err);
+      if (DEBUG_MODE) {
+        console.log(err);
+      }
     } else if (DEBUG_MODE) {
       console.log(err.code, "is not handled yet in extractTar method.");
     }

package/lib/server/server.js

@@ -1,10 +1,9 @@
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import http from "node:http";
-import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import url from "node:url";
+import { URL } from "node:url";
 import bodyParser from "body-parser";
 import connect from "connect";
 import { createBom, submitBom } from "../cli/index.js";
@@ -27,6 +26,24 @@ app.use(
 );
 app.use(compression());
 
+function isAllowedHost(hostname) {
+  if (!process.env.CDXGEN_SERVER_ALLOWED_HOSTS) {
+    return true;
+  }
+  return (process.env.CDXGEN_SERVER_ALLOWED_HOSTS || "")
+    .split(",")
+    .includes(hostname);
+}
+
+function isAllowedPath(p) {
+  if (!process.env.CDXGEN_SERVER_ALLOWED_PATHS) {
+    return true;
+  }
+  return (process.env.CDXGEN_SERVER_ALLOWED_PATHS || "")
+    .split(",")
+    .some((ap) => p.startsWith(ap));
+}
+
 const gitClone = (repoUrl, branch = null) => {
   const tempDir = fs.mkdtempSync(
     path.join(getTmpDir(), path.basename(repoUrl)),
@@ -172,7 +189,8 @@ const start = (options) => {
   });
 
   app.use("/sbom", async (req, res) => {
-    const q = url.parse(req.url, true).query;
+    const requestUrl = new URL(req.url, `http://${req.headers.host}`);
+    const q = Object.fromEntries(requestUrl.searchParams.entries());
     let cleanup = false;
     const reqOptions = parseQueryString(
       q,
@@ -190,9 +208,31 @@ const start = (options) => {
     }
     let srcDir = filePath;
     if (filePath.startsWith("http") || filePath.startsWith("git")) {
+      // Validate the hostnames
+      const gitUrlObj = new URL(filePath);
+      if (!isAllowedHost(gitUrlObj.hostname)) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        return res.end(
+          JSON.stringify({
+            error: "Host Not Allowed",
+            details: `The Git URL host is not allowed: '${gitUrlObj.hostname}'.`,
+          }),
+        );
+      }
       srcDir = gitClone(filePath, reqOptions.gitBranch);
       cleanup = true;
-    } else if (srcDir !== path.resolve(srcDir)) {
+    } else {
+      if (!isAllowedPath(path.resolve(srcDir))) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        return res.end(
+          JSON.stringify({
+            error: "Path Not Allowed",
+            details: `Path is not allowed: '${srcDir}'.`,
+          }),
+        );
+      }
+    }
+    if (srcDir !== path.resolve(srcDir)) {
       console.log(
         `Invoke the API with an absolute path '${path.resolve(srcDir)}' instead of '${srcDir}' to reduce security risks.`,
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyclonedx/cdxgen",
-  "version": "11.2.4",
+  "version": "11.2.6",
   "description": "Creates CycloneDX Software Bill of Materials (SBOM) from source or container image",
   "homepage": "http://github.com/cyclonedx/cdxgen",
   "author": "Prabhu Subramanian <prabhu@appthreat.com>",
@@ -34,6 +34,10 @@
     {
       "name": "Adam Setch",
       "url": "https://github.com/setchy"
+    },
+    {
+      "name": "Roland Asmann",
+      "url": "https://github.com/malice00"
     }
   ],
   "type": "module",
@@ -97,7 +101,7 @@
     "yoctocolors": "^2.1.1"
   },
   "optionalDependencies": {
-    "@appthreat/atom": "2.1.14",
+    "@appthreat/atom": "2.1.16",
     "@appthreat/cdx-proto": "1.0.1",
     "@cyclonedx/cdxgen-plugins-bin": "1.6.10",
     "@cyclonedx/cdxgen-plugins-bin-linux-arm": "1.6.10",
@@ -136,7 +140,7 @@
     "negotiator": "^0.6.4"
   },
   "scripts": {
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --inject-globals false lib/managers/docker.test.js lib/helpers/package_specific/gradleutils.test.js lib/helpers/utils.test.js lib/helpers/display.test.js lib/stages/postgen/postgen.test.js lib/evinser/swiftsem.test.js",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --inject-globals false lib/managers/docker.test.js lib/helpers/utils.test.js lib/helpers/display.test.js lib/stages/postgen/postgen.test.js lib/evinser/swiftsem.test.js",
     "watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch --inject-globals false",
     "lint:check": "biome check",
     "lint": "biome check --fix",

package/types/lib/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/cli/index.js"],"names":[],"mappings":"AAk7BA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AAuXD;;;;;;;GAOG;AACH,mCALW,MAAM,qBAyEhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM;;;;EAKhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM;;;;EAkBhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BA+sChB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAuvBhB;AAED;;;;;;;;;;GAUG;AACH,+DAsEC;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAkehB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BA+YhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAuIhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAkEhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBA+KhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBAsHhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,qBAuBhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,8BAqDhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,8BA4ChB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BA8IhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BAmJhB;AAED;;;;;GAKG;AACH,iDAHW,MAAM,qBAmUhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAiJhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAwNhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA8ZhB;AAED;;;;;GAKG;AACH,2CAHW,MAAM;;;;;;;;;;;;;;;;;;;;GAoChB;AAED;;;;;;;;KA+DC;AAED;;;;;;GAMG;AACH,yDA+FC;AAED;;;;;;;;;GASG;AACH,2GAuCC;AAED;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,8BA6vBlB;AAED;;;;;GAKG;AACH,iCAHW,MAAM,8BAqUhB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,qBA2QhB;AAED;;;;;;;GAOG;AACH,wDAHY,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CA2HjD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/cli/index.js"],"names":[],"mappings":"AAu7BA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AA8XD;;;;;;;GAOG;AACH,mCALW,MAAM,qBAyEhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM;;;;EAKhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM;;;;EAkBhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAgvChB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAmvBhB;AAED;;;;;;;;;;GAUG;AACH,+DAsEC;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAkehB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BA+YhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAuIhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAkEhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBA+KhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBAsHhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,qBAuBhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,8BAqDhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,8BA4ChB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BA8IhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BAmJhB;AAED;;;;;GAKG;AACH,iDAHW,MAAM,qBAmUhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAiJhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAwNhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA8ZhB;AAED;;;;;GAKG;AACH,2CAHW,MAAM;;;;;;;;;;;;;;;;;;;;GAoChB;AAED;;;;;;;;KA+DC;AAED;;;;;;GAMG;AACH,yDA+FC;AAED;;;;;;;;;GASG;AACH,2GAuCC;AAED;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,8BA6vBlB;AAED;;;;;GAKG;AACH,iCAHW,MAAM,8BAqUhB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,qBA2QhB;AAED;;;;;;;GAOG;AACH,wDAHY,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CA2HjD"}

package/types/lib/helpers/utils.d.ts

@@ -294,10 +294,11 @@ export function parseGradleProperties(rawOutput: string, gradleModuleName?: stri
  *
  * @param {string} dir Directory to execute the command
  * @param {array} allProjectsStr List of all sub-projects (including the preceding `:`)
+ * @param {array} extraArgs List of extra arguments to use when calling gradle
  *
  * @returns {string} The combined output for all subprojects of the Gradle properties task
  */
-export function executeParallelGradleProperties(dir: string, allProjectsStr: any[]): string;
+export function executeParallelGradleProperties(dir: string, allProjectsStr: any[], extraArgs?: any[]): string;
 /**
  * Parse bazel action graph output
  * @param {string} rawOutput Raw string output
@@ -1154,10 +1155,11 @@ export function getMillCommand(srcPath: string): string;
  * @param {string[]} gradleArguments The general gradle arguments, which must only be added once
  * @param {string[]} gradleSubCommands The sub-commands that are to be executed by gradle
  * @param {string[]} gradleSubCommandArguments The arguments specific to the sub-command(s), which much be added PER sub-command
+ * @param {int} gradleCommandLength The length of the full gradle-command
  *
- * @returns {string[]} Array of arguments to be added to the gradle command
+ * @returns {string[]} Array of arrays of arguments to be added to the gradle command
  */
-export function buildGradleCommandArguments(gradleArguments: string[], gradleSubCommands: string[], gradleSubCommandArguments: string[]): string[];
+export function buildGradleCommandArguments(gradleArguments: string[], gradleSubCommands: string[], gradleSubCommandArguments: string[], gradleCommandLength: int): string[];
 /**
  * Method to split the output produced by Gradle using parallel processing by project
  *

package/types/lib/helpers/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/helpers/utils.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/helpers/utils.js"],"names":[],"mappings":"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"}

package/types/lib/managers/binary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../lib/managers/binary.js"],"names":[],"mappings":"AA2SA,wDAkBC;AAED;;;;;GAKG;AACH,kDAFa,SAAS,MAAO,CAqB5B;AAED;;;;;;;GAOG;AACH,kEAqaC;AAsDD,gDAoDC;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,cACN,MAAM,WA0ChB;AAED;;;;;;;;GAQG;AACH,kCANW,MAAM,iBACN,MAAM,YACN,OAAO,GAEN,OAAO,CA8BlB"}
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../lib/managers/binary.js"],"names":[],"mappings":"AAwVA,wDAkBC;AAED;;;;;GAKG;AACH,kDAFa,SAAS,MAAO,CAqB5B;AAED;;;;;;;GAOG;AACH,kEAqaC;AAsDD,gDAoDC;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,cACN,MAAM,WA0ChB;AAED;;;;;;;;GAQG;AACH,kCANW,MAAM,iBACN,MAAM,YACN,OAAO,GAEN,OAAO,CA8BlB"}

package/types/lib/managers/docker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../../../lib/managers/docker.js"],"names":[],"mappings":"AAiFA;;GAEG;AACH,oCAmBC;AAED;;GAEG;AACH,4CA6CC;AA7HD,4BAA6C;AAC7C,kCAAmC,WAAW,CAAC;AAmCxC,kDAeN;AAqFM,iCAHI,MAAM,WACN,MAAM,iDAehB;AAqBM,6DAmBN;AAgLM,4EAsGN;AAEM,oFAwBN;AAUM;;;;;;;;EAyEN;AAsBM,2DAgLN;AAgBM,yFA2GN;AAMM;;;;;;;;;;;;;;GAwDN;AAEM;;;;;;;;GAyGN;AAMM,4EA+IN;AAKM,4EA2GN;AAEM,+EAEN;AAEM,4EAyCN;AAEM,iFA0BN"}
+{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../../../lib/managers/docker.js"],"names":[],"mappings":"AAiFA;;GAEG;AACH,oCAmBC;AAED;;GAEG;AACH,4CA6CC;AA7HD,4BAA6C;AAC7C,kCAAmC,WAAW,CAAC;AAmCxC,kDAeN;AAqFM,iCAHI,MAAM,WACN,MAAM,iDAehB;AAqBM,6DAmBN;AAgLM,4EAsGN;AAEM,oFAwBN;AAUM;;;;;;;;EAyEN;AAsBM,2DAsMN;AAgBM,yFAqGN;AAMM;;;;;;;;;;;;;;GAwDN;AAEM;;;;;;;;GAyGN;AAMM,4EA+IN;AAKM,4EA2GN;AAEM,+EAEN;AAEM,4EAyCN;AAEM,iFA0BN"}

package/types/lib/server/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../lib/server/server.js"],"names":[],"mappings":"AA6HA,yDAKC;AAED,0CAyHC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../lib/server/server.js"],"names":[],"mappings":"AA8IA,yDAKC;AAED,0CAgJC"}

package/lib/helpers/package_specific/gradleutils.js

@@ -1,48 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-
-/**
- * Function to parse the given gradle build file to identify properties such as included builds
- *
- * @param buildFile {build,settings}.gradle(.kts)? Build file in groovy or kotlin format
- * @param buildContent String content to parse directly.
- */
-export function analyzeBuildSettings(buildFile, buildContent) {
-  const includedBuilds = new Set();
-  if (!buildContent && !existsSync(buildFile)) {
-    return undefined;
-  }
-  const data = buildContent || readFileSync(buildFile, "utf-8");
-  let pluginManagementMode = false;
-  for (let aline of data.split("\n")) {
-    aline = aline.replaceAll("\r", "").trim();
-    if (aline.includes("pluginManagement {")) {
-      pluginManagementMode = true;
-    }
-    if (pluginManagementMode && aline === "}") {
-      pluginManagementMode = false;
-    }
-    if (!pluginManagementMode) {
-      if (aline.includes("includeBuild")) {
-        aline = aline.replace("includeBuild", "").replaceAll(/[ "'()]/g, "");
-        // Ignore relative includes for now
-        if (!aline.startsWith(".")) {
-          includedBuilds.add(`:${aline.trim()}`);
-        }
-      } else if (aline.includes("includedBuild(")) {
-        aline = aline
-          .split("includedBuild(")[1]
-          .split(")")[0]
-          .replaceAll(/[ "'()]/g, "");
-        if (!aline.startsWith(".")) {
-          includedBuilds.add(`:${aline.trim()}`);
-        }
-      }
-    }
-  }
-  if (!includedBuilds.size) {
-    return undefined;
-  }
-  return {
-    includedBuilds: Array.from(includedBuilds),
-  };
-}

package/lib/helpers/package_specific/gradleutils.test.js

@@ -1,65 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "@jest/globals";
-import { analyzeBuildSettings } from "./gradleutils.js";
-
-test("analyzeBuildSettings tests", () => {
-  expect(analyzeBuildSettings()).toBeUndefined();
-  expect(
-    analyzeBuildSettings(
-      undefined,
-      `rootProject.name = "my-composite"
-
-includeBuild("my-app")
-includeBuild("my-utils")`,
-    ),
-  ).toEqual({
-    includedBuilds: [":my-app", ":my-utils"],
-  });
-  expect(
-    analyzeBuildSettings(
-      undefined,
-      `rootProject.name = 'my-composite'
-
-includeBuild 'my-app'
-includeBuild 'my-utils'`,
-    ),
-  ).toEqual({
-    includedBuilds: [":my-app", ":my-utils"],
-  });
-  expect(
-    analyzeBuildSettings(
-      undefined,
-      `tasks.register("run") {
-    dependsOn(gradle.includedBuild("my-app").task(":app:run"))
-}`,
-    ),
-  ).toEqual({
-    includedBuilds: [":my-app"],
-  });
-  expect(
-    analyzeBuildSettings(
-      undefined,
-      `tasks.register('run') {
-    dependsOn gradle.includedBuild('my-app').task(':app:run')
-}`,
-    ),
-  ).toEqual({
-    includedBuilds: [":my-app"],
-  });
-
-  expect(
-    analyzeBuildSettings(
-      undefined,
-      `pluginManagement {
-    includeBuild("../url-verifier-plugin")
-}`,
-    ),
-  ).toBeUndefined();
-  expect(
-    analyzeBuildSettings(
-      undefined,
-      `pluginManagement {
-    includeBuild '../url-verifier-plugin'
-}`,
-    ),
-  ).toBeUndefined();
-});