@trustify-da/trustify-da-javascript-client 0.3.0-ea.a783c26 → 0.3.0-ea.a87208f

package/dist/src/providers/base_javascript.js

@@ -12,6 +12,49 @@ import Manifest from './manifest.js';
  * @type {string}
  */
 export const purlType = 'npm';
+/**
+ * Maps a Subresource Integrity (SRI) algorithm token to its CycloneDX label.
+ * @type {Object<string, string>}
+ */
+const SRI_ALG_LABELS = {
+    sha1: 'SHA-1',
+    sha256: 'SHA-256',
+    sha384: 'SHA-384',
+    sha512: 'SHA-512',
+};
+/**
+ * Converts a Subresource Integrity (SRI) string to a CycloneDX hash object.
+ * SRI is formatted as `<alg>-<base64>` (e.g. `sha512-Ab3d...`). CycloneDX
+ * expects an uppercased algorithm label (e.g. `SHA-512`) and a hex-encoded
+ * digest. When the SRI string contains multiple space-separated hashes, only
+ * the first is used.
+ * @param {string} integrity - SRI string from a lock file
+ * @returns {{alg: string, content: string}|null} CycloneDX hash, or null when unparseable
+ */
+export function sriToHash(integrity) {
+    if (typeof integrity !== 'string') {
+        return null;
+    }
+    const first = integrity.trim().split(/\s+/)[0];
+    if (!first) {
+        return null;
+    }
+    const dash = first.indexOf('-');
+    if (dash < 0) {
+        return null;
+    }
+    const alg = SRI_ALG_LABELS[first.slice(0, dash).toLowerCase()];
+    // Strip any SRI options (e.g. "?foo") that may follow the base64 payload
+    const base64 = first.slice(dash + 1).split('?')[0];
+    if (!alg || !base64) {
+        return null;
+    }
+    const content = Buffer.from(base64, 'base64').toString('hex');
+    if (!content) {
+        return null;
+    }
+    return { alg, content };
+}
 /**
  * Base class for JavaScript package manager providers.
  * This class provides common functionality for different JavaScript package managers
@@ -25,6 +68,11 @@ export default class Base_javascript {
     #cmd;
     /** @type {string} */
     #ecosystem;
+    /**
+     * Lock-file hashes keyed by `name@version`.
+     * @type {Map<string, Array<{alg: string, content: string}>>}
+     */
+    #hashes = new Map();
     /**
    * Sets up the provider with the manifest path and options
    * @param {string} manifestPath - Path to the package.json manifest file
@@ -71,6 +119,13 @@ export default class Base_javascript {
         throw new TypeError("_cmdName must be implemented");
     }
     /**
+   * Returns the package manager name (e.g. npm, yarn, pnpm, bun)
+   * @returns {string} The package manager name
+   */
+    packageManagerName() {
+        return this._cmdName();
+    }
+    /**
    * Returns the command arguments for listing dependencies
    * @returns {Array<string>} The command arguments
    * @abstract
@@ -88,6 +143,58 @@ export default class Base_javascript {
     _updateLockFileCmdArgs() {
         throw new TypeError("_updateLockFileCmdArgs must be implemented");
     }
+    /**
+     * Parses the provider's lock file into a hash map keyed by `name@version`.
+     * Subclasses override this (accepting the lock directory) to support their
+     * lock file format. The default implementation returns an empty map so
+     * providers without lock parsing (or without a lock file present) gracefully
+     * omit hashes.
+     * @returns {Map<string, Array<{alg: string, content: string}>>} Hash map
+     * @protected
+     */
+    _parseLockFileHashes() {
+        return new Map();
+    }
+    /**
+     * Loads lock-file hashes for the given directory into internal state.
+     * Parsing failures degrade gracefully to an empty map (no hashes emitted).
+     * @param {string} lockDir - Directory containing the lock file
+     * @protected
+     */
+    _loadHashes(lockDir) {
+        try {
+            this.#hashes = this._parseLockFileHashes(lockDir) || new Map();
+        }
+        catch (_) {
+            this.#hashes = new Map();
+        }
+    }
+    /**
+     * Looks up CycloneDX hashes for a package by name and resolved version.
+     * @param {string} name - The package name (including scope, e.g. `@hapi/joi`)
+     * @param {string} version - The resolved package version
+     * @returns {Array<{alg: string, content: string}>|undefined} Hashes, or undefined
+     * @protected
+     */
+    _hashesFor(name, version) {
+        if (!name || !version) {
+            return undefined;
+        }
+        return this.#hashes.get(`${name}@${version}`);
+    }
+    /**
+     * Looks up CycloneDX hashes for a package described by a PackageURL.
+     * @param {PackageURL} purl - The package URL
+     * @returns {Array<{alg: string, content: string}>|undefined} Hashes, or undefined
+     * @protected
+     */
+    _hashesForPurl(purl) {
+        if (!purl) {
+            return undefined;
+        }
+        const name = purl.namespace ? `${purl.namespace}/${purl.name}` : purl.name;
+        return this._hashesFor(name, purl.version);
+    }
     /**
    * Checks if the provider supports the given manifest name
    * @param {string} manifestName - The manifest name to check
@@ -217,7 +324,8 @@ export default class Base_javascript {
         this._version();
         const manifestDir = path.dirname(this.#manifest.manifestPath);
         const cmdDir = this._findLockFileDir(manifestDir, opts) || manifestDir;
-        this.#createLockFile(cmdDir);
+        this._createLockFile(cmdDir);
+        this._loadHashes(cmdDir);
         let output = this.#executeListCmd(includeTransitive, cmdDir);
         output = this._parseDepTreeOutput(output);
         return JSON.parse(output);
@@ -277,7 +385,7 @@ export default class Base_javascript {
             const [name, artifact] = entry;
             const target = toPurl(purlType, name, artifact.version);
             const rootPurl = toPurl(purlType, this.#manifest.name, this.#manifest.version);
-            sbom.addDependency(rootPurl, target);
+            sbom.addDependency(rootPurl, target, undefined, this._hashesFor(name, artifact.version));
             this.#addDependenciesOf(sbom, target, artifact);
         });
     }
@@ -295,7 +403,7 @@ export default class Base_javascript {
             const [name, depArtifact] = entry;
             if (depArtifact.version !== undefined) {
                 const target = toPurl(purlType, name, depArtifact.version);
-                sbom.addDependency(from, target);
+                sbom.addDependency(from, target, undefined, this._hashesFor(name, depArtifact.version));
                 this.#addDependenciesOf(sbom, target, depArtifact);
             }
         });
@@ -319,7 +427,8 @@ export default class Base_javascript {
             .sort();
         for (const key of sortedDepsKeys) {
             const rootPurl = toPurlFromString(sbom.getRoot().purl);
-            sbom.addDependency(rootPurl, rootDeps.get(key));
+            const targetPurl = rootDeps.get(key);
+            sbom.addDependency(rootPurl, targetPurl, undefined, this._hashesForPurl(targetPurl));
         }
         this.#ensurePeerAndOptionalDeps(sbom);
         sbom.filterIgnoredDeps(this.#manifest.ignored);
@@ -363,9 +472,9 @@ export default class Base_javascript {
     /**
    * Creates or updates the lock file for the package manager
    * @param {string} manifestDir - Directory containing the manifest file
-   * @private
+   * @protected
    */
-    #createLockFile(manifestDir) {
+    _createLockFile(manifestDir) {
         const originalDir = process.cwd();
         const isWindows = os.platform() === 'win32';
         if (isWindows) {

package/dist/src/providers/base_pyproject.d.ts

@@ -1,4 +1,4 @@
-/** @typedef {{name: string, version: string, children: string[]}} GraphEntry */
+/** @typedef {{name: string, version: string, children: string[], hashes?: Array<{alg: string, content: string}>}} GraphEntry */
 /** @typedef {{name: string, version: string, dependencies: DepTreeEntry[]}} DepTreeEntry */
 /** @typedef {{directDeps: string[], graph: Map<string, GraphEntry>}} DependencyData */
 /** @typedef {{ecosystem: string, content: string, contentType: string}} Provided */
@@ -13,7 +13,7 @@ export default class Base_pyproject {
      * @param {Object} [opts={}]
      * @returns {boolean}
      */
-    validateLockFile(manifestDir: string, opts?: any): boolean;
+    validateLockFile(manifestDir: string, opts?: Object): boolean;
     /**
      * Walk up from manifestDir to find the directory containing the lock file.
      * Follows the same pattern as Base_javascript._findLockFileDir().
@@ -22,7 +22,7 @@ export default class Base_pyproject {
      * @returns {string|null}
      * @protected
      */
-    protected _findLockFileDir(manifestDir: string, opts?: any): string | null;
+    protected _findLockFileDir(manifestDir: string, opts?: Object): string | null;
     /**
      * Detect workspace root boundaries.
      * Currently only uv has native workspace support ([tool.uv.workspace] in pyproject.toml).
@@ -44,13 +44,13 @@ export default class Base_pyproject {
      * @param {Object} [opts={}]
      * @returns {Promise<Provided>}
      */
-    provideStack(manifest: string, opts?: any): Promise<Provided>;
+    provideStack(manifest: string, opts?: Object): Promise<Provided>;
     /**
      * @param {string} manifest - path to pyproject.toml
      * @param {Object} [opts={}]
      * @returns {Promise<Provided>}
      */
-    provideComponent(manifest: string, opts?: any): Promise<Provided>;
+    provideComponent(manifest: string, opts?: Object): Promise<Provided>;
     /**
      * @returns {string}
      * @protected
@@ -61,6 +61,11 @@ export default class Base_pyproject {
      * @protected
      */
     protected _cmdName(): string;
+    /**
+     * Returns the package manager name (e.g. pip, poetry, uv)
+     * @returns {string}
+     */
+    packageManagerName(): string;
     /**
      * Resolve dependencies using the tool-specific command and parser.
      *
@@ -72,7 +77,7 @@ export default class Base_pyproject {
      * @returns {Promise<DependencyData>}
      * @protected
      */
-    protected _getDependencyData(manifestDir: string, workspaceDir: string, parsed: object, opts: any): Promise<DependencyData>;
+    protected _getDependencyData(manifestDir: string, workspaceDir: string, parsed: object, opts: Object): Promise<DependencyData>;
     /**
      * Canonicalize a Python package name per PEP 503.
      * @param {string} name
@@ -131,6 +136,10 @@ export type GraphEntry = {
     name: string;
     version: string;
     children: string[];
+    hashes?: Array<{
+        alg: string;
+        content: string;
+    }>;
 };
 export type DepTreeEntry = {
     name: string;

package/dist/src/providers/base_pyproject.js

@@ -7,9 +7,10 @@ import Sbom from '../sbom.js';
 import { getCustom } from '../tools.js';
 const ecosystem = 'pip';
 const IGNORE_MARKERS = ['exhortignore', 'trustify-da-ignore'];
+const NO_SCOPE = undefined;
 const DEFAULT_ROOT_NAME = 'default-pip-root';
 const DEFAULT_ROOT_VERSION = '0.0.0';
-/** @typedef {{name: string, version: string, children: string[]}} GraphEntry */
+/** @typedef {{name: string, version: string, children: string[], hashes?: Array<{alg: string, content: string}>}} GraphEntry */
 /** @typedef {{name: string, version: string, dependencies: DepTreeEntry[]}} DepTreeEntry */
 /** @typedef {{directDeps: string[], graph: Map<string, GraphEntry>}} DependencyData */
 /** @typedef {{ecosystem: string, content: string, contentType: string}} Provided */
@@ -144,6 +145,13 @@ export default class Base_pyproject {
     _cmdName() {
         throw new TypeError('_cmdName must be implemented');
     }
+    /**
+     * Returns the package manager name (e.g. pip, poetry, uv)
+     * @returns {string}
+     */
+    packageManagerName() {
+        return this._cmdName();
+    }
     /**
      * Resolve dependencies using the tool-specific command and parser.
      *
@@ -281,7 +289,7 @@ export default class Base_pyproject {
                     continue;
                 }
                 let entry = graph.get(key);
-                sbom.addDependency(rootPurl, this._toPurl(entry.name, entry.version));
+                sbom.addDependency(rootPurl, this._toPurl(entry.name, entry.version), NO_SCOPE, entry.hashes);
             }
             for (let [key, entry] of graph) {
                 if (!reachable.has(key)) {
@@ -293,7 +301,7 @@ export default class Base_pyproject {
                         continue;
                     }
                     let childEntry = graph.get(child);
-                    sbom.addDependency(parentPurl, this._toPurl(childEntry.name, childEntry.version));
+                    sbom.addDependency(parentPurl, this._toPurl(childEntry.name, childEntry.version), NO_SCOPE, childEntry.hashes);
                 }
             }
         }
@@ -306,7 +314,7 @@ export default class Base_pyproject {
                 if (!entry) {
                     continue;
                 }
-                sbom.addDependency(rootPurl, this._toPurl(entry.name, entry.version));
+                sbom.addDependency(rootPurl, this._toPurl(entry.name, entry.version), NO_SCOPE, entry.hashes);
             }
         }
         return sbom.getAsJsonString(opts);

package/dist/src/providers/containerfile_parser.d.ts

@@ -0,0 +1,5 @@
+export function getParser(): Promise<Parser>;
+export function getFromQuery(): Promise<Query>;
+export function getArgQuery(): Promise<Query>;
+import { Parser } from 'web-tree-sitter';
+import { Query } from 'web-tree-sitter';

package/dist/src/providers/containerfile_parser.js

@@ -0,0 +1,20 @@
+import { readFile } from 'node:fs/promises';
+import { Language, Parser, Query } from 'web-tree-sitter';
+const wasmUrl = new URL('./tree-sitter-containerfile.wasm', import.meta.url);
+async function init() {
+    await Parser.init();
+    const wasmBytes = new Uint8Array(await readFile(wasmUrl));
+    return await Language.load(wasmBytes);
+}
+export async function getParser() {
+    const language = await init();
+    return new Parser().setLanguage(language);
+}
+export async function getFromQuery() {
+    const language = await init();
+    return new Query(language, '(from_instruction (image_spec) @image)');
+}
+export async function getArgQuery() {
+    const language = await init();
+    return new Query(language, '(arg_instruction (arg_pair name: (_) @name default: (_) @default))');
+}

package/dist/src/providers/golang_gomodules.d.ts

@@ -1,12 +1,22 @@
+/**
+ * Discover all go.mod manifest paths in a Go workspace.
+ * Uses `go work edit -json` to get workspace members.
+ *
+ * @param {string} workspaceRoot - Absolute or relative path to workspace root (must contain go.work)
+ * @param {import('../index.js').Options} [opts={}]
+ * @returns {Promise<string[]>} Paths to go.mod files (absolute)
+ */
+export function discoverGoWorkspaceModules(workspaceRoot: string, opts?: import("../index.js").Options): Promise<string[]>;
 declare namespace _default {
     export { isSupported };
     export { validateLockFile };
     export { provideComponent };
     export { provideStack };
     export { readLicenseFromManifest };
+    export function packageManagerName(): string;
 }
 export default _default;
-export type Provided = import("../provider").Provided;
+export type Provided = any;
 export type Package = {
     name: string;
     version: string;

package/dist/src/providers/golang_gomodules.js

@@ -4,8 +4,9 @@ import { PackageURL } from 'packageurl-js';
 import { readLicenseFile } from '../license/license_utils.js';
 import Sbom from '../sbom.js';
 import { getCustom, getCustomPath, invokeCommand } from "../tools.js";
+import { filterManifestPathsByDiscoveryIgnore, resolveWorkspaceDiscoveryIgnore } from '../workspace.js';
 import { getParser, getRequireQuery } from './gomod_parser.js';
-export default { isSupported, validateLockFile, provideComponent, provideStack, readLicenseFromManifest };
+export default { isSupported, validateLockFile, provideComponent, provideStack, readLicenseFromManifest, packageManagerName() { return 'go'; } };
 /** @typedef {import('../provider').Provider} */
 /** @typedef {import('../provider').Provided} Provided */
 /** @typedef {{name: string, version: string}} Package */
@@ -186,6 +187,36 @@ function performManifestVersionsCheck(rootElementName, goModGraphOutputRows, man
         throw error;
     }
 }
+/** Parses go.sum to build a hash map of module@version to CycloneDX hashes. */
+function parseGoSumHashes(manifestDir) {
+    let goSumPath = path.join(manifestDir, 'go.sum');
+    if (!fs.existsSync(goSumPath)) {
+        return new Map();
+    }
+    let hashMap = new Map();
+    let content = fs.readFileSync(goSumPath, 'utf-8');
+    for (let line of content.split('\n')) {
+        line = line.trim();
+        if (!line) {
+            continue;
+        }
+        let parts = line.split(/\s+/);
+        if (parts.length < 3) {
+            continue;
+        }
+        let [mod, version, hash] = parts;
+        if (version.endsWith('/go.mod')) {
+            continue;
+        }
+        if (!hash.startsWith('h1:')) {
+            continue;
+        }
+        let base64Part = hash.slice(3);
+        let hexDigest = Buffer.from(base64Part, 'base64').toString('hex');
+        hashMap.set(`${mod}@${version}`, [{ alg: "SHA-256", content: hexDigest }]);
+    }
+    return hashMap;
+}
 /**
  * Create SBOM json string for go Module.
  * @param {string} manifest - path for go.mod
@@ -240,6 +271,7 @@ async function getSBOM(manifest, opts = {}, includeTransitive) {
     if (matchManifestVersions === "true") {
         performManifestVersionsCheck(root, rows, manifestContent, parser, requireQuery);
     }
+    let goSumHashes = parseGoSumHashes(manifestDir);
     const mainModule = toPurl(root, "@");
     const license = readLicenseFromManifest(manifest);
     sbom.addRoot(mainModule, license);
@@ -261,7 +293,7 @@ async function getSBOM(manifest, opts = {}, includeTransitive) {
             if (getParentVertexFromEdge(row) === root && !directDepPaths.has(getPackageName(child))) {
                 return;
             }
-            sbom.addDependency(source, target);
+            sbom.addDependency(source, target, undefined, goSumHashes.get(child));
         });
         // at the end, filter out all ignored dependencies including versions.
         sbom.filterIgnoredDepsIncludingVersion(allIgnoredDeps);
@@ -274,12 +306,22 @@ async function getSBOM(manifest, opts = {}, includeTransitive) {
             let target = toPurl(child, "@");
             if (dependencyNotIgnored(ignoredDeps, target)) {
                 if (directDepPaths.has(getPackageName(child))) {
-                    sbom.addDependency(mainModule, target);
+                    sbom.addDependency(mainModule, target, undefined, goSumHashes.get(child));
                 }
             }
         });
         enforceRemovingIgnoredDepsInCaseOfAutomaticVersionUpdate(ignoredDeps, sbom);
     }
+    // Backfill hashes for components that were only seen as dependency sources
+    for (const comp of sbom.sbomModel.components) {
+        if (!comp.hashes && comp.purl) {
+            let key = decodeURIComponent(comp.purl.replace('pkg:golang/', ''));
+            let hashes = goSumHashes.get(key);
+            if (hashes) {
+                comp.hashes = hashes;
+            }
+        }
+    }
     return sbom.getAsJsonString(opts);
 }
 /**
@@ -328,13 +370,7 @@ function getFinalPackagesVersionsForModule(rows, manifestPath, goBin) {
     catch (error) {
         throw new Error('failed to list all modules', { cause: error });
     }
-    let finalVersionModules = new Map();
-    finalVersionsForAllModules.split(getLineSeparatorGolang()).filter(string => string.trim() !== "")
-        .filter(string => string.trim().split(" ").length === 2)
-        .forEach((dependency) => {
-        let dep = dependency.split(" ");
-        finalVersionModules[dep[0]] = dep[1];
-    });
+    let finalVersionModules = parseModuleVersions(finalVersionsForAllModules);
     let finalVersionModulesArray = new Array();
     rows.filter(string => string.trim() !== "").forEach(module => {
         let child = getChildVertexFromEdge(module);
@@ -395,7 +431,69 @@ function getVersionOfPackage(fullPackage) {
     let parts = fullPackage.split("@");
     return parts.length > 1 ? parts[1] : undefined;
 }
+function parseModuleVersions(goListOutput) {
+    let modules = {};
+    goListOutput.split(getLineSeparatorGolang()).filter(string => string.trim() !== "")
+        .forEach((line) => {
+        let parts = line.trim().split(" ");
+        if (parts.length === 2) {
+            modules[parts[0]] = parts[1];
+        }
+        else if (parts.length >= 4 && parts[2] === "=>") {
+            modules[parts[0]] = parts[parts.length - 1];
+        }
+    });
+    return modules;
+}
 function getLineSeparatorGolang() {
     let reg = /\n|\r\n/;
     return reg;
 }
+/**
+ * Discover all go.mod manifest paths in a Go workspace.
+ * Uses `go work edit -json` to get workspace members.
+ *
+ * @param {string} workspaceRoot - Absolute or relative path to workspace root (must contain go.work)
+ * @param {import('../index.js').Options} [opts={}]
+ * @returns {Promise<string[]>} Paths to go.mod files (absolute)
+ */
+export async function discoverGoWorkspaceModules(workspaceRoot, opts = {}) {
+    const root = path.resolve(workspaceRoot);
+    const goWork = path.join(root, 'go.work');
+    if (!fs.existsSync(goWork)) {
+        return [];
+    }
+    const goBin = getCustomPath('go', opts);
+    let output;
+    try {
+        output = invokeCommand(goBin, ['work', 'edit', '-json', goWork], { cwd: root });
+    }
+    catch {
+        return [];
+    }
+    let workspace;
+    try {
+        workspace = JSON.parse(output.toString().trim());
+    }
+    catch {
+        return [];
+    }
+    const useEntries = workspace.Use || [];
+    if (useEntries.length === 0) {
+        return [];
+    }
+    const manifestPaths = [];
+    for (const entry of useEntries) {
+        const diskPath = entry.DiskPath;
+        if (!diskPath) {
+            continue;
+        }
+        const moduleDir = path.resolve(root, diskPath);
+        const goMod = path.join(moduleDir, 'go.mod');
+        if (fs.existsSync(goMod)) {
+            manifestPaths.push(goMod);
+        }
+    }
+    const ignorePatterns = resolveWorkspaceDiscoveryIgnore(opts);
+    return filterManifestPathsByDiscoveryIgnore(manifestPaths, root, ignorePatterns);
+}

package/dist/src/providers/java_gradle.d.ts

@@ -1,3 +1,22 @@
+/**
+ * Discover all build.gradle[.kts] manifest paths in a Gradle multi-project build.
+ * Uses a custom init script to get structured project listing.
+ *
+ * @param {string} workspaceRoot - Absolute or relative path to workspace root (must contain settings.gradle[.kts])
+ * @param {import('../index.js').Options} [opts={}]
+ * @returns {Promise<string[]>} Paths to build.gradle[.kts] files (absolute)
+ */
+export function discoverGradleSubprojects(workspaceRoot: string, opts?: import("../index.js").Options): Promise<string[]>;
+/**
+ * Parse the structured output from the Gradle init script.
+ *
+ * @param {string} raw - Raw stdout from gradle
+ * @returns {{ path: string, dir: string }[]}
+ */
+export function parseGradleInitScriptOutput(raw: string): {
+    path: string;
+    dir: string;
+}[];
 /**
  * This class provides common functionality for Groovy and Kotlin DSL files.
  */