@coana-tech/cli 14.12.160 → 14.12.162

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coana-tech/cli",
-  "version": "14.12.160",
+  "version": "14.12.162",
   "description": "Coana CLI",
   "type": "module",
   "bin": {

package/reachability-analyzers-cli.mjs

@@ -75394,7 +75394,7 @@ var {
 } = import_index.default;
 
 // dist/reachability-analyzers-cli.js
-import { readFile as readFile14, writeFile as writeFile10 } from "fs/promises";
+import { readFile as readFile15, writeFile as writeFile10 } from "fs/promises";
 
 // ../web-compat-utils/src/logger-singleton.ts
 var import_winston = __toESM(require_winston(), 1);
@@ -80900,6 +80900,7 @@ import { execFile as execFile2 } from "child_process";
 
 // ../utils/src/telemetry/telemetry-collector.ts
 import { execFile } from "child_process";
+import { readFile as readFile3 } from "fs/promises";
 import { platform } from "process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -80907,14 +80908,44 @@ var TelemetryCollector = class _TelemetryCollector {
   constructor(pid) {
     this.pid = pid;
   }
+  previousCpuState;
+  clockTicksPerSecond;
+  pageSize;
+  isCollecting = false;
   static create(pid) {
-    if (!Number.isInteger(pid) || pid <= 0 || !["darwin", "linux"].includes(platform)) return void 0;
+    if (!Number.isInteger(pid) || pid <= 0 || !["darwin", "linux", "win32"].includes(platform)) return void 0;
     return new _TelemetryCollector(pid);
   }
   /**
-   * Collect metrics for a Unix-like system (macOS, Linux) using ps command.
+   * Collect metrics for the child process.
+   * Uses OS-specific methods to query memory and CPU usage.
    */
   async collectChildProcessMetrics() {
+    if (this.isCollecting) {
+      return void 0;
+    }
+    this.isCollecting = true;
+    try {
+      if (platform === "darwin") {
+        return await this.collectDarwinProcessMetrics();
+      }
+      if (platform === "linux") {
+        return await this.collectLinuxProcessMetrics();
+      }
+      if (platform === "win32") {
+        return await this.collectWindowsProcessMetrics();
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    } finally {
+      this.isCollecting = false;
+    }
+  }
+  /**
+   * Collect metrics on macOS using ps command.
+   */
+  async collectDarwinProcessMetrics() {
     try {
       const { stdout } = await execFileAsync("ps", ["-o", "rss=,pcpu=", "-p", String(this.pid)], {
         timeout: 5e3
@@ -80934,6 +80965,142 @@ var TelemetryCollector = class _TelemetryCollector {
       return void 0;
     }
   }
+  /**
+   * Collect metrics on Linux using /proc filesystem.
+   * This works on all Linux distributions including Alpine (BusyBox).
+   */
+  async collectLinuxProcessMetrics() {
+    try {
+      const statmContent = await readFile3(`/proc/${this.pid}/statm`, "utf-8");
+      const statmParts = statmContent.trim().split(/\s+/);
+      if (statmParts.length < 2) {
+        return void 0;
+      }
+      const residentPages = parseInt(statmParts[1], 10);
+      if (isNaN(residentPages)) {
+        return void 0;
+      }
+      const pageSize = await this.getPageSize();
+      const rssBytes = residentPages * pageSize;
+      const statContent = await readFile3(`/proc/${this.pid}/stat`, "utf-8");
+      const cpuPercent = await this.calculateCpuPercent(statContent);
+      return {
+        rss: rssBytes,
+        cpuPercent
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Collect metrics on Windows using PowerShell.
+   * Uses Get-Process for memory and CPU time tracking for CPU%.
+   */
+  async collectWindowsProcessMetrics() {
+    try {
+      const psScript = "$p = Get-Process -Id $args[0] -ErrorAction Stop; @{WorkingSet64=$p.WorkingSet64; TotalMs=$p.TotalProcessorTime.TotalMilliseconds} | ConvertTo-Json";
+      const { stdout } = await execFileAsync(
+        "powershell",
+        ["-NoProfile", "-Command", psScript, String(this.pid)],
+        { timeout: 5e3 }
+      );
+      const trimmed = stdout.trim();
+      if (!trimmed) {
+        return void 0;
+      }
+      const data2 = JSON.parse(trimmed);
+      const rssBytes = data2.WorkingSet64;
+      const totalCpuMs = data2.TotalMs;
+      if (typeof rssBytes !== "number" || typeof totalCpuMs !== "number") {
+        return void 0;
+      }
+      const now = Date.now();
+      const currentState = { totalCpuTime: totalCpuMs, timestamp: now };
+      let cpuPercent = 0;
+      if (this.previousCpuState) {
+        const timeDeltaMs = now - this.previousCpuState.timestamp;
+        const cpuTimeDelta = totalCpuMs - this.previousCpuState.totalCpuTime;
+        if (timeDeltaMs > 0 && cpuTimeDelta >= 0) {
+          cpuPercent = Math.max(0, cpuTimeDelta / timeDeltaMs * 100);
+        }
+      }
+      this.previousCpuState = currentState;
+      return {
+        rss: rssBytes,
+        cpuPercent
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Calculate CPU percentage from /proc/<pid>/stat.
+   * Requires tracking state between calls to compute the delta.
+   */
+  async calculateCpuPercent(statContent) {
+    try {
+      const lastParen = statContent.lastIndexOf(")");
+      if (lastParen === -1) {
+        return 0;
+      }
+      const fieldsAfterComm = statContent.slice(lastParen + 2).split(/\s+/);
+      const utime = parseInt(fieldsAfterComm[11], 10);
+      const stime = parseInt(fieldsAfterComm[12], 10);
+      if (isNaN(utime) || isNaN(stime)) {
+        return 0;
+      }
+      const totalCpuTime = utime + stime;
+      const now = Date.now();
+      const clockTicks = await this.getClockTicksPerSecond();
+      const currentState = { totalCpuTime, timestamp: now };
+      if (!this.previousCpuState) {
+        this.previousCpuState = currentState;
+        return 0;
+      }
+      const timeDeltaMs = now - this.previousCpuState.timestamp;
+      const cpuTimeDelta = totalCpuTime - this.previousCpuState.totalCpuTime;
+      this.previousCpuState = currentState;
+      if (timeDeltaMs <= 0 || cpuTimeDelta < 0) {
+        return 0;
+      }
+      const cpuPercent = cpuTimeDelta * 1e3 * 100 / (clockTicks * timeDeltaMs);
+      return Math.max(0, cpuPercent);
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Get the system page size in bytes (cached after first call).
+   */
+  async getPageSize() {
+    if (this.pageSize !== void 0) {
+      return this.pageSize;
+    }
+    try {
+      const { stdout } = await execFileAsync("getconf", ["PAGE_SIZE"], { timeout: 1e3 });
+      const parsed = parseInt(stdout.trim(), 10);
+      this.pageSize = isNaN(parsed) ? 4096 : parsed;
+    } catch {
+      this.pageSize = 4096;
+    }
+    return this.pageSize;
+  }
+  /**
+   * Get the number of clock ticks per second (used for CPU time conversion).
+   */
+  async getClockTicksPerSecond() {
+    if (this.clockTicksPerSecond !== void 0) {
+      return this.clockTicksPerSecond;
+    }
+    try {
+      const { stdout } = await execFileAsync("getconf", ["CLK_TCK"], { timeout: 1e3 });
+      const ticks = parseInt(stdout.trim(), 10);
+      this.clockTicksPerSecond = isNaN(ticks) ? 100 : ticks;
+    } catch {
+      this.clockTicksPerSecond = 100;
+    }
+    return this.clockTicksPerSecond;
+  }
 };
 
 // ../utils/src/telemetry/analyzer-telemetry-server.ts
@@ -87921,7 +88088,7 @@ import { resolve as resolve19 } from "path";
 
 // ../utils/src/pip-utils.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 import { dirname, resolve as resolve3 } from "node:path";
 import util4 from "node:util";
 
@@ -87930,7 +88097,7 @@ var import_lodash4 = __toESM(require_lodash(), 1);
 var import_semver = __toESM(require_semver4(), 1);
 import { execFileSync } from "child_process";
 import { constants as constants2 } from "fs";
-import { access as access2, readFile as readFile3 } from "fs/promises";
+import { access as access2, readFile as readFile4 } from "fs/promises";
 import { join as join5, resolve as resolve2 } from "path";
 import util3 from "util";
 var { once } = import_lodash4.default;
@@ -87978,7 +88145,7 @@ var PythonVersionsManager = class _PythonVersionsManager {
     const absPath = resolve2(this.projectDir, workspacePath);
     for (const parent2 of parents(absPath))
       try {
-        return [(await readFile3(join5(parent2, ".python-version"), "utf-8")).split("\n")[0].trim()];
+        return [(await readFile4(join5(parent2, ".python-version"), "utf-8")).split("\n")[0].trim()];
       } catch (e) {
         if (e.code !== "ENOENT") logger.warn("Failed to read python version file with error", e);
       }
@@ -88338,7 +88505,7 @@ function addPathToTrie(root3, vulnPath) {
 var import_lodash14 = __toESM(require_lodash(), 1);
 import assert6 from "assert";
 import { existsSync as existsSync13 } from "fs";
-import { cp as cp7, readdir as readdir4, readFile as readFile11, rm as rm5 } from "fs/promises";
+import { cp as cp7, readdir as readdir4, readFile as readFile12, rm as rm5 } from "fs/promises";
 var import_semver3 = __toESM(require_semver2(), 1);
 import { basename as basename11, dirname as dirname15, join as join17, resolve as resolve17, sep as sep5 } from "path";
 import util5 from "util";
@@ -94010,7 +94177,7 @@ var CocoaHeuristics = {
 
 // dist/whole-program-code-aware-vulnerability-scanner/dotnet/dotnet-code-aware-vulnerability-scanner.js
 var import_adm_zip = __toESM(require_adm_zip(), 1);
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
 import { randomUUID } from "node:crypto";
 
 // dist/whole-program-code-aware-vulnerability-scanner/dotnet/constants.js
@@ -94028,7 +94195,7 @@ function getClassGraphAnalysisCliPath() {
 
 // ../utils/src/nuget-project-utils.ts
 var import_parse_xml2 = __toESM(require_dist(), 1);
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { dirname as dirname9, join as join12, relative as relative5, resolve as resolve8, basename as basename6, extname as extname2 } from "node:path";
 
 // ../utils/src/xml-utils.ts
@@ -95688,7 +95855,7 @@ async function loadNuGetProjectOrTarget(rootDir, projectFile, mainProject, visit
   if (!validatedProjectPath || !existsSync6(validatedProjectPath)) return void 0;
   if (visited.has(validatedProjectPath)) return void 0;
   visited.set(validatedProjectPath);
-  const sourceText = await readFile5(validatedProjectPath, "utf-8");
+  const sourceText = await readFile6(validatedProjectPath, "utf-8");
   const xml2 = (0, import_parse_xml2.parseXml)(sourceText, { includeOffsets: true });
   const indentation = inferIndentationFromParsedXml(xml2, sourceText);
   const currentProject = {
@@ -96194,7 +96361,7 @@ var DotnetCodeAwareVulnerabilityScanner = class _DotnetCodeAwareVulnerabilitySca
       const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runDotnetDirectDependencyAnalysis -i ${inputFile} -o ${outputFile} --cocoa ${getCocoaPath()} --tree-sitter-c-sharp ${getTreeSitterCSharpPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.dotnet });
       if (result.error)
         return void 0;
-      const packageIds = JSON.parse(await readFile6(outputFile, "utf-8")).result;
+      const packageIds = JSON.parse(await readFile7(outputFile, "utf-8")).result;
       return packageIds?.map((packageId) => this.depIdToPurl.get(packageId)).filter((purl) => purl !== void 0).map((purl) => purl.name ?? "");
     });
   }
@@ -96233,7 +96400,7 @@ var DotnetCodeAwareVulnerabilityScanner = class _DotnetCodeAwareVulnerabilitySca
       const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runDotnetReachabilityAnalysis -i ${inputFile} -o ${outputFile} --cocoa ${getCocoaPath()} --tree-sitter-c-sharp ${getTreeSitterCSharpPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.dotnet, telemetryHandler, analyzerTelemetryHandler });
       if (result.error)
         return { type: "error", message: result.error.message ?? "unknown error" };
-      const { success, error, analysisDiagnostics: diagnostics, vulnerablePaths, reachablePackageIds } = JSON.parse(await readFile6(outputFile, "utf-8")).result;
+      const { success, error, analysisDiagnostics: diagnostics, vulnerablePaths, reachablePackageIds } = JSON.parse(await readFile7(outputFile, "utf-8")).result;
       if (!success)
         return { type: "error", message: error ?? "unknown error" };
       const affectedPurls = reachablePackageIds.map((packageId) => this.depIdToPurl.get(packageId)).filter((purl) => purl !== void 0);
@@ -96383,7 +96550,7 @@ async function convertSocketArtifacts(artifacts, tmpDir) {
 var import_lodash8 = __toESM(require_lodash(), 1);
 var import_adm_zip2 = __toESM(require_adm_zip(), 1);
 import { existsSync as existsSync9 } from "node:fs";
-import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile6 } from "node:fs/promises";
 import { basename as basename8, dirname as dirname11, resolve as resolve10 } from "node:path";
 
 // ../../node_modules/.pnpm/cheerio@1.0.0-rc.12/node_modules/cheerio/lib/esm/options.js
@@ -110170,7 +110337,7 @@ var JavaCodeAwareVulnerabilityScanner = class _JavaCodeAwareVulnerabilityScanner
       const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runJvmDirectDependencyAnalysis -i ${inputFile} -o ${outputFile} --javap-service ${getJavapServicePath()} --tree-sitter-java ${getTreeSitterJavaPath()} --tree-sitter-kotlin ${getTreeSitterKotlinPath()} --tree-sitter-scala ${getTreeSitterScalaPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.java });
       if (result.error)
         return void 0;
-      const packageIds = JSON.parse(await readFile7(outputFile, "utf-8")).result;
+      const packageIds = JSON.parse(await readFile8(outputFile, "utf-8")).result;
       return packageIds?.map((packageId) => this.depIdToPurl.get(packageId)).filter((purl) => purl !== void 0).map((purl) => `${purl.namespace}:${purl.name}}`);
     });
   }
@@ -110209,7 +110376,7 @@ var JavaCodeAwareVulnerabilityScanner = class _JavaCodeAwareVulnerabilityScanner
       const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runJvmReachabilityAnalysis -i ${inputFile} -o ${outputFile} --javap-service ${getJavapServicePath()} --tree-sitter-java ${getTreeSitterJavaPath()} --tree-sitter-kotlin ${getTreeSitterKotlinPath()} --tree-sitter-scala ${getTreeSitterScalaPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.java, telemetryHandler, analyzerTelemetryHandler });
       if (result.error)
         return { type: "error", message: result.error.message ?? "unknown error" };
-      const { success, error, analysisDiagnostics: diagnostics, vulnerablePaths, reachablePackageIds } = JSON.parse(await readFile7(outputFile, "utf-8")).result;
+      const { success, error, analysisDiagnostics: diagnostics, vulnerablePaths, reachablePackageIds } = JSON.parse(await readFile8(outputFile, "utf-8")).result;
       if (!success)
         return { type: "error", message: error ?? "unknown error" };
       const affectedPurls = reachablePackageIds.map((packageId) => this.depIdToPurl.get(packageId)).filter((purl) => purl !== void 0);
@@ -110790,7 +110957,7 @@ function computePackagesOnVulnPath(vulnerabilities, { includeLeafPackages = fals
 // dist/whole-program-code-aware-vulnerability-scanner/js/jelly-runner.js
 var import_lodash10 = __toESM(require_lodash(), 1);
 import assert4 from "assert";
-import { readFile as readFile8, realpath as realpath2, rm as rm2, writeFile as writeFile7 } from "fs/promises";
+import { readFile as readFile9, realpath as realpath2, rm as rm2, writeFile as writeFile7 } from "fs/promises";
 import { relative as relative6, resolve as resolve13 } from "path";
 var { map: map2, uniq: uniq4 } = import_lodash10.default;
 var PRINT_JELLY_COMMAND = false;
@@ -110848,8 +111015,8 @@ async function runJellyAnalysis(mainProjectRoot, projectRoot, jellyOptions, reac
     );
     if (reachabilityAnalysisOptions.printLogFile)
       logger.info("JS analysis log file:", logFile);
-    const analysisDiagnostics = JSON.parse(await readFile8(diagnosticsFile, "utf-8"));
-    const callStacks = JSON.parse(await readFile8(callStackFile, "utf-8"));
+    const analysisDiagnostics = JSON.parse(await readFile9(diagnosticsFile, "utf-8"));
+    const callStacks = JSON.parse(await readFile9(callStackFile, "utf-8"));
     const matches = {};
     const realProjectRoot = await realpath2(projectRoot);
     for (const { vulnerability: { npm: { url: url2 } }, paths } of callStacks) {
@@ -110859,7 +111026,7 @@ async function runJellyAnalysis(mainProjectRoot, projectRoot, jellyOptions, reac
       else
         matches[url2] = transformedStacks;
     }
-    const affectedPackages = JSON.parse(await readFile8(affectedPackagesFile, "utf-8")).packages;
+    const affectedPackages = JSON.parse(await readFile9(affectedPackagesFile, "utf-8")).packages;
     const affectedPurls = affectedJSPackagesToPurl(affectedPackages);
     return {
       matches,
@@ -110892,7 +111059,7 @@ async function runJellyPhantomDependencyAnalysis(projectRoot, options, telemetry
       telemetryHandler,
       analyzerTelemetryHandler
     });
-    return JSON.parse(await readFile8(reachablePackagesFile, "utf-8")).packages;
+    return JSON.parse(await readFile9(reachablePackagesFile, "utf-8")).packages;
   } finally {
     await rm2(tmpFolder, { recursive: true });
   }
@@ -110915,7 +111082,7 @@ async function runJellyImportReachabilityAnalysis(mainProjectRoot, projectRoot,
       telemetryHandler,
       analyzerTelemetryHandler
     });
-    return JSON.parse(await readFile8(reachableModulesFile, "utf-8"));
+    return JSON.parse(await readFile9(reachableModulesFile, "utf-8"));
   } finally {
     await rm2(tmpFolder, { recursive: true });
   }
@@ -111119,7 +111286,7 @@ function transformSourceLocations(fileMappings, detectedOccurrences) {
 var import_lodash11 = __toESM(require_lodash(), 1);
 import assert5 from "assert";
 import { existsSync as existsSync11, createReadStream as createReadStream2, createWriteStream as createWriteStream3 } from "fs";
-import { readFile as readFile9, rm as rm4, cp as cp6 } from "fs/promises";
+import { readFile as readFile10, rm as rm4, cp as cp6 } from "fs/promises";
 import zlib2 from "zlib";
 import { join as join16, resolve as resolve14, sep as sep3 } from "path";
 
@@ -111196,11 +111363,11 @@ var GoCodeAwareVulnerabilityScanner = class {
       if (stderr)
         logger.debug(`Go code-aware analysis stderr
 ${stderr}`);
-      const diagnostics = JSON.parse(await readFile9(diagnosticsOutputFile, "utf8"));
+      const diagnostics = JSON.parse(await readFile10(diagnosticsOutputFile, "utf8"));
       logger.debug("Diagnostics", diagnostics);
-      const result = JSON.parse(await readFile9(vulnsOutputFile, "utf8"));
+      const result = JSON.parse(await readFile10(vulnsOutputFile, "utf8"));
       logger.debug("Analysis results", result);
-      const reachedModules = JSON.parse(await readFile9(reachedModulesOutputFile, "utf8"));
+      const reachedModules = JSON.parse(await readFile10(reachedModulesOutputFile, "utf8"));
       logger.debug("Reached modules", reachedModules);
       return {
         type: "success",
@@ -111300,7 +111467,7 @@ ${stderr}`);
 // dist/whole-program-code-aware-vulnerability-scanner/rust/rust-code-aware-vulnerability-scanner.js
 var import_lodash12 = __toESM(require_lodash(), 1);
 import { existsSync as existsSync12 } from "node:fs";
-import { readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
+import { readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
 import { basename as basename10, dirname as dirname14, resolve as resolve15 } from "node:path";
 
 // dist/whole-program-code-aware-vulnerability-scanner/rust/heuristics.js
@@ -111584,7 +111751,7 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
       const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runRustDirectDependencyAnalysis -i ${inputFile} -o ${outputFile} --tree-sitter-rust ${getTreeSitterRustPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.rust });
       if (result.error)
         return void 0;
-      const packageIds = JSON.parse(await readFile10(outputFile, "utf-8")).result;
+      const packageIds = JSON.parse(await readFile11(outputFile, "utf-8")).result;
       return packageIds?.map((packageId) => this.depIdToPurl.get(packageId)?.name).filter((name2) => name2 !== void 0).map((name2) => name2);
     });
   }
@@ -111620,7 +111787,7 @@ var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner
       const result = await execNeverFail2(cmdt`${await getNodeExecutable(ToolPathResolver.nodeExecutablePath)} ${getClassGraphAnalysisCliPath()} runRustReachabilityAnalysis -i ${inputFile} -o ${outputFile} --tree-sitter-rust ${getTreeSitterRustPath()}`, void 0, { timeout: timeoutMs, killSignal: "SIGKILL", heartbeat: HEARTBEATS.rust, telemetryHandler, analyzerTelemetryHandler });
       if (result.error)
         return { type: "error", message: result.error.message ?? "unknown error" };
-      const { success, error, analysisDiagnostics: diagnostics, vulnerablePaths, reachablePackageIds } = JSON.parse(await readFile10(outputFile, "utf-8")).result;
+      const { success, error, analysisDiagnostics: diagnostics, vulnerablePaths, reachablePackageIds } = JSON.parse(await readFile11(outputFile, "utf-8")).result;
       if (!success)
         return { type: "error", message: error ?? "unknown error" };
       const affectedPurls = reachablePackageIds.map((packageId) => this.depIdToPurl.get(packageId)).filter((purl) => purl !== void 0);
@@ -111817,7 +111984,7 @@ async function convertSocketArtifacts3(artifacts, tmpDir, artifactNameToId) {
   return { deps, depIdToPurl };
 }
 async function extractDependenciesFromCargoToml(cargoTomlPath) {
-  const content = await readFile10(cargoTomlPath, "utf-8");
+  const content = await readFile11(cargoTomlPath, "utf-8");
   const toml = parseTOML2(content);
   if (!toml)
     return /* @__PURE__ */ new Map();
@@ -111866,7 +112033,7 @@ async function getCrateInfo(cargoTomlPath) {
   let examples;
   let tests;
   const cargoTomlDir = dirname14(cargoTomlPath);
-  const content = await readFile10(cargoTomlPath, "utf-8");
+  const content = await readFile11(cargoTomlPath, "utf-8");
   const parsed = parseTOML2(content);
   if (!parsed) {
     lib = resolve15(dirname14(cargoTomlPath), "src");
@@ -112144,13 +112311,13 @@ var PythonCodeAwareVulnerabilityScanner = class {
       if (errors.length > 0)
         logger.debug(`Error messages from mambalade:
 ${errors.join("\n")}`);
-      const result = JSON.parse(await readFile11(vulnsOutputFile, "utf-8"));
+      const result = JSON.parse(await readFile12(vulnsOutputFile, "utf-8"));
       logger.debug("Analysis result: %O", {
         ...i3(result.matches, (match2) => match2.stacks.length),
         ...result.misses
       });
-      const { modules, ...mambaladeDiagnosticsOutput } = JSON.parse(await readFile11(diagnosticsOutputFile, "utf-8"));
-      const reachedPackages = JSON.parse(await readFile11(reachedPackagesOutputFile, "utf-8"));
+      const { modules, ...mambaladeDiagnosticsOutput } = JSON.parse(await readFile12(diagnosticsOutputFile, "utf-8"));
+      const reachedPackages = JSON.parse(await readFile12(reachedPackagesOutputFile, "utf-8"));
       const getTimes = (...keys) => (
         // Mambalade outputs times in seconds, we convert them to milliseconds
         keys.reduce((sum, key) => sum + (mambaladeDiagnosticsOutput.diagnostics.timings[key] ?? 0), 0) * 1e3
@@ -113522,7 +113689,7 @@ import { resolve as resolve21 } from "path";
 // dist/whole-program-code-aware-vulnerability-scanner/ruby/ruby-code-aware-vulnerability-scanner.js
 var import_lodash20 = __toESM(require_lodash(), 1);
 import { createWriteStream as createWriteStream4, existsSync as existsSync15 } from "fs";
-import { mkdir as mkdir9, readdir as readdir5, readFile as readFile12, rm as rm7 } from "fs/promises";
+import { mkdir as mkdir9, readdir as readdir5, readFile as readFile13, rm as rm7 } from "fs/promises";
 import { join as join18, relative as relative9 } from "path";
 import { pipeline as pipeline3 } from "stream/promises";
 var PRINT_ANALYSIS_COMMAND = false;
@@ -113616,10 +113783,10 @@ var RubyCodeAwareVulnerabilityScanner = class {
           heartbeat: HEARTBEATS.ruby,
           telemetryHandler
         });
-        const result = JSON.parse(await readFile12(vulnsOutputFile, "utf-8"));
+        const result = JSON.parse(await readFile13(vulnsOutputFile, "utf-8"));
         const relativeLoadPathsToPackageNames = new Map([...loadPathsToPackageNames.entries()].map(([k, v]) => [join18("vendor", relative9(this.vendorDir, k)), v]));
-        const { timedOut, ...diagnostics } = JSON.parse(await readFile12(diagnosticsOutputFile, "utf-8"));
-        const reachedPackages = JSON.parse(await readFile12(reachedPackagesOutputFile, "utf-8"));
+        const { timedOut, ...diagnostics } = JSON.parse(await readFile13(diagnosticsOutputFile, "utf-8"));
+        const reachedPackages = JSON.parse(await readFile13(reachedPackagesOutputFile, "utf-8"));
         logger.debug("Reached packages: %O", reachedPackages);
         return {
           type: "success",
@@ -113915,13 +114082,13 @@ async function runReachabilityAnalysis(state) {
 }
 
 // dist/reachability-analysis-state.js
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 async function getReachabilityAnalyzersStateFromInput(rootWorkingDir, subprojectDir, workspacePath, inputFile) {
   return {
     rootWorkingDir,
     subprojectDir,
     workspacePath,
-    ...JSON.parse(await readFile13(inputFile, "utf-8"))
+    ...JSON.parse(await readFile14(inputFile, "utf-8"))
   };
 }
 
@@ -113937,7 +114104,7 @@ var runReachabilityAnalysisCmd = new Command().name("runReachabilityAnalysis").a
   }
 }, "reachability-analyzer"));
 var runOnDependencyChainCmd = new Command().name("runOnDependencyChain").option("-d, --debug", "Enable debug logging", false).option("-s, --silent", "Silence all debug/warning output", false).option("--coana-socket-path <socketPath>", "Coana socket path").option("--silent-spinner", "Silence spinner", "CI" in process.env || !process.stdin.isTTY).requiredOption("-i, --input-file <inputFile>", "Input file for data and vulnerabilities").requiredOption("-o, --output-file <outputFile>", "Output file for the results").configureHelp({ sortSubcommands: true, sortOptions: true }).action(async (options) => withLoggerAndSpinner("Coana Reachability Analyzers", options, async () => {
-  const { ecosystem, dependencyChain, vulnerability } = JSON.parse(await readFile14(options.inputFile, "utf-8"));
+  const { ecosystem, dependencyChain, vulnerability } = JSON.parse(await readFile15(options.inputFile, "utf-8"));
   const defaultOptions2 = {
     timeoutSeconds: { allVulnRuns: 60, bucketedRuns: 60 },
     memoryLimitInMB: 16384