@trustify-da/trustify-da-javascript-client 0.3.0-ea.be56bee → 0.3.0-ea.c300d9f

package/dist/src/cli.js

@@ -3,8 +3,45 @@ import fs from 'node:fs';
 import * as path from "path";
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import { resolveConfig } from './config.js';
 import { getProjectLicense, getLicenseDetails } from './license/index.js';
+import { runRemediation } from './remediate.js';
+import { generateReport } from './remediation_report.js';
 import client, { selectTrustifyDABackend, generateSbom } from './index.js';
+/**
+ * Builds a yargs middleware that loads `.trustify-da.yml` (discovered by walking
+ * up from the command's target path, or cwd when no path is available) and fills `--providers`, `--sources`, and
+ * `--group-by` with config file values when they were not supplied on the CLI or
+ * via environment variables. Precedence: CLI flag > env var > config file > default.
+ * @param {string} [pathKey] - positional argument holding the target path; defaults to the current working directory
+ * @param {{ groupBy?: boolean }} [options={}] - set `groupBy` when the command exposes `--group-by`
+ * @returns {(args: object) => object} yargs middleware
+ */
+function configMiddleware(pathKey, options = {}) {
+    return args => {
+        const startPath = pathKey === undefined ? process.cwd() : args[pathKey];
+        const envVars = options.groupBy
+            ? process.env
+            : Object.fromEntries(Object.entries(process.env).filter(([key]) => key !== 'TRUSTIFY_DA_GROUP_BY'));
+        const merged = resolveConfig(startPath, { backendUrl: args.backendUrl, providers: args.providers, sources: args.sources, groupBy: args['group-by'] }, envVars);
+        if (merged.backendUrlSource === 'file' && process.env.TRUSTIFY_DA_TOKEN) {
+            throw new Error('Refusing to send TRUSTIFY_DA_TOKEN to a backend selected by project configuration. Set --backend-url or TRUSTIFY_DA_BACKEND_URL to explicitly trust it.');
+        }
+        if (args.providers !== undefined || merged.providers.length) {
+            args.providers = merged.providers.join(',');
+        }
+        if (args.sources !== undefined || merged.sources.length) {
+            args.sources = merged.sources.join(',');
+        }
+        if (merged.backendUrl != null) {
+            args.backendUrl = merged.backendUrl;
+        }
+        if (options.groupBy) {
+            args['group-by'] = merged.groupBy;
+        }
+        return args;
+    };
+}
 // command for component analysis take manifest type and content
 const component = {
     command: 'component </path/to/manifest>',
@@ -19,11 +56,32 @@ const component = {
             desc: 'Workspace root directory (for monorepos; lock file is expected here)',
             type: 'string',
             normalize: true,
+        },
+        backendUrl: {
+            desc: 'Trustify DA backend URL (env: TRUSTIFY_DA_BACKEND_URL)',
+            type: 'string',
+        },
+        providers: {
+            desc: 'Comma-separated list of vulnerability providers (env: TRUSTIFY_DA_PROVIDERS)',
+            type: 'string',
+        },
+        sources: {
+            desc: 'Comma-separated list of vulnerability sources (env: TRUSTIFY_DA_SOURCES)',
+            type: 'string',
         }
-    }),
+    }).middleware(configMiddleware('/path/to/manifest')),
     handler: async (args) => {
         let manifestName = args['/path/to/manifest'];
         const opts = args.workspaceDir ? { TRUSTIFY_DA_WORKSPACE_DIR: args.workspaceDir } : {};
+        if (args.backendUrl !== undefined) {
+            opts.TRUSTIFY_DA_BACKEND_URL = args.backendUrl;
+        }
+        if (args.providers !== undefined) {
+            opts.TRUSTIFY_DA_PROVIDERS = args.providers;
+        }
+        if (args.sources !== undefined) {
+            opts.TRUSTIFY_DA_SOURCES = args.sources;
+        }
         let res = await client.componentAnalysis(manifestName, opts);
         console.log(JSON.stringify(res, null, 2));
     }
@@ -72,8 +130,20 @@ const image = {
             desc: 'For JSON report, get only the \'summary\'',
             type: 'boolean',
             conflicts: 'html'
+        },
+        backendUrl: {
+            desc: 'Trustify DA backend URL (env: TRUSTIFY_DA_BACKEND_URL)',
+            type: 'string',
+        },
+        providers: {
+            desc: 'Comma-separated list of vulnerability providers (env: TRUSTIFY_DA_PROVIDERS)',
+            type: 'string',
+        },
+        sources: {
+            desc: 'Comma-separated list of vulnerability sources (env: TRUSTIFY_DA_SOURCES)',
+            type: 'string',
         }
-    }),
+    }).middleware(configMiddleware()),
     handler: async (args) => {
         let imageRefs = args['image-refs'];
         if (!Array.isArray(imageRefs)) {
@@ -81,7 +151,17 @@ const image = {
         }
         let html = args['html'];
         let summary = args['summary'];
-        let res = await client.imageAnalysis(imageRefs, html);
+        const opts = {};
+        if (args.backendUrl !== undefined) {
+            opts.TRUSTIFY_DA_BACKEND_URL = args.backendUrl;
+        }
+        if (args.providers !== undefined) {
+            opts.TRUSTIFY_DA_PROVIDERS = args.providers;
+        }
+        if (args.sources !== undefined) {
+            opts.TRUSTIFY_DA_SOURCES = args.sources;
+        }
+        let res = await client.imageAnalysis(imageRefs, html, opts);
         if (summary && !html) {
             let summaries = {};
             for (let [imageRef, report] of Object.entries(res)) {
@@ -132,13 +212,34 @@ const stack = {
             desc: 'Workspace root directory (for monorepos; lock file is expected here)',
             type: 'string',
             normalize: true,
+        },
+        backendUrl: {
+            desc: 'Trustify DA backend URL (env: TRUSTIFY_DA_BACKEND_URL)',
+            type: 'string',
+        },
+        providers: {
+            desc: 'Comma-separated list of vulnerability providers (env: TRUSTIFY_DA_PROVIDERS)',
+            type: 'string',
+        },
+        sources: {
+            desc: 'Comma-separated list of vulnerability sources (env: TRUSTIFY_DA_SOURCES)',
+            type: 'string',
         }
-    }),
+    }).middleware(configMiddleware('/path/to/manifest')),
     handler: async (args) => {
         let manifest = args['/path/to/manifest'];
         let html = args['html'];
         let summary = args['summary'];
         const opts = args.workspaceDir ? { TRUSTIFY_DA_WORKSPACE_DIR: args.workspaceDir } : {};
+        if (args.backendUrl !== undefined) {
+            opts.TRUSTIFY_DA_BACKEND_URL = args.backendUrl;
+        }
+        if (args.providers !== undefined) {
+            opts.TRUSTIFY_DA_PROVIDERS = args.providers;
+        }
+        if (args.sources !== undefined) {
+            opts.TRUSTIFY_DA_SOURCES = args.sources;
+        }
         let theProvidersSummary = new Map();
         let theProvidersObject = {};
         let res = await client.stackAnalysis(manifest, html, opts);
@@ -201,13 +302,28 @@ const stackBatch = {
             desc: 'Stop on first invalid package.json or SBOM error (env: TRUSTIFY_DA_CONTINUE_ON_ERROR=false)',
             type: 'boolean',
             default: false,
+        },
+        backendUrl: {
+            desc: 'Trustify DA backend URL (env: TRUSTIFY_DA_BACKEND_URL)',
+            type: 'string',
+        },
+        providers: {
+            desc: 'Comma-separated list of vulnerability providers (env: TRUSTIFY_DA_PROVIDERS)',
+            type: 'string',
+        },
+        sources: {
+            desc: 'Comma-separated list of vulnerability sources (env: TRUSTIFY_DA_SOURCES)',
+            type: 'string',
         }
-    }),
+    }).middleware(configMiddleware('/path/to/workspace-root')),
     handler: async (args) => {
         const workspaceRoot = args['/path/to/workspace-root'];
         const html = args['html'];
         const summary = args['summary'];
         const opts = {};
+        if (args.backendUrl !== undefined) {
+            opts.TRUSTIFY_DA_BACKEND_URL = args.backendUrl;
+        }
         if (args.concurrency != null) {
             opts.batchConcurrency = args.concurrency;
         }
@@ -221,6 +337,12 @@ const stackBatch = {
         if (args.failFast) {
             opts.continueOnError = false;
         }
+        if (args.providers !== undefined) {
+            opts.TRUSTIFY_DA_PROVIDERS = args.providers;
+        }
+        if (args.sources !== undefined) {
+            opts.TRUSTIFY_DA_SOURCES = args.sources;
+        }
         let res = await client.stackAnalysisBatch(workspaceRoot, html, opts);
         const batchAnalysis = res && typeof res === 'object' && res != null && 'analysis' in res ? res.analysis : res;
         if (summary && !html && typeof batchAnalysis === 'object') {
@@ -373,9 +495,68 @@ const sbom = {
         }
     }
 };
+const remediate = {
+    command: 'remediate <path>',
+    desc: 'Scan and apply vulnerability remediations to manifest files',
+    builder: yargs => yargs.positional('path', {
+        desc: 'Path to manifest file or directory',
+        type: 'string',
+        normalize: true,
+    }).options({
+        'dry-run': {
+            alias: 'd',
+            type: 'boolean',
+            desc: 'Preview changes without modifying files',
+        },
+        providers: {
+            desc: 'Comma-separated list of vulnerability providers (env: TRUSTIFY_DA_PROVIDERS)',
+            type: 'string',
+        },
+        sources: {
+            desc: 'Comma-separated list of vulnerability sources (env: TRUSTIFY_DA_SOURCES)',
+            type: 'string',
+        },
+        'group-by': {
+            type: 'string',
+            choices: ['dependency', 'bundle'],
+            desc: 'Report grouping strategy (default: dependency)',
+        },
+        backendUrl: {
+            desc: 'Trustify DA backend URL (env: TRUSTIFY_DA_BACKEND_URL)',
+            type: 'string',
+        },
+    }).middleware(configMiddleware('path', { groupBy: true })),
+    handler: async (args) => {
+        try {
+            const result = await runRemediation(args.path, {
+                dryRun: args['dry-run'],
+                providers: args.providers,
+                sources: args.sources,
+                backendUrl: args.backendUrl,
+            });
+            if (result.remediations.length === 0 && result.manifests.length === 0) {
+                console.log('No supported manifest files found.');
+                process.exit(result.exitCode);
+            }
+            if (!args['dry-run'] && result.appliedFiles.length > 0) {
+                console.log(`Updated ${result.appliedFiles.length} file(s):`);
+                for (const file of result.appliedFiles) {
+                    console.log(`  ${file}`);
+                }
+                console.log('');
+            }
+            console.log(generateReport(result.remediations, { groupBy: args['group-by'], dryRun: args['dry-run'] }));
+            process.exit(result.exitCode);
+        }
+        catch (err) {
+            console.error(err.message);
+            process.exit(1);
+        }
+    }
+};
 // parse and invoke the command
 yargs(hideBin(process.argv))
-    .usage(`Usage: ${process.argv[0].includes("node") ? path.parse(process.argv[1]).base : path.parse(process.argv[0]).base} {component|stack|stack-batch|image|validate-token|license|sbom}`)
+    .usage(`Usage: ${process.argv[0].includes("node") ? path.parse(process.argv[1]).base : path.parse(process.argv[0]).base} {component|stack|stack-batch|image|validate-token|license|sbom|remediate}`)
     .command(stack)
     .command(stackBatch)
     .command(component)
@@ -383,6 +564,7 @@ yargs(hideBin(process.argv))
     .command(validateToken)
     .command(license)
     .command(sbom)
+    .command(remediate)
     .scriptName('')
     .version(false)
     .demandCommand(1)

package/dist/src/config.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Discovers and parses `.trustify-da.yml` by walking up from `startPath`.
+ * A missing config file is not an error — an empty object is returned so callers
+ * can fall back to defaults.
+ * @param {string} [startPath] - manifest file or directory to start the search from
+ * @returns {FileConfig} the parsed config object, or `{}` when no file is found
+ * @throws {Error} when the config file exists but contains malformed YAML
+ */
+export function loadConfig(startPath?: string): FileConfig;
+/**
+ * Merges config sources with precedence: CLI flag > environment variable
+ * (`TRUSTIFY_DA_*`) > config file > hardcoded default. Providers and sources are
+ * normalized to arrays regardless of whether the source used a YAML array or a
+ * comma-separated string.
+ * @param {FileConfig} [fileConfig={}] - values parsed from `.trustify-da.yml`
+ * @param {{ providers?: string, sources?: string, groupBy?: string, backendUrl?: string }} [cliFlags={}]
+ * @param {{ [key: string]: string | undefined }} [envVars={}] - typically `process.env`
+ * @returns {ResolvedConfig} the resolved, typed config object
+ */
+export function mergeConfig(fileConfig?: FileConfig, cliFlags?: {
+    providers?: string;
+    sources?: string;
+    groupBy?: string;
+    backendUrl?: string;
+}, envVars?: {
+    [key: string]: string | undefined;
+}): ResolvedConfig;
+/**
+ * Loads and merges the project configuration for a target path.
+ * @param {string} [startPath] - manifest file or directory to start discovery from
+ * @param {{ providers?: string, sources?: string, groupBy?: string, backendUrl?: string }} [cliFlags={}] - explicit options
+ * @param {{ [key: string]: string | undefined }} [envVars={}] - typically `process.env`
+ * @returns {ResolvedConfig} the resolved, typed config object
+ */
+export function resolveConfig(startPath?: string, cliFlags?: {
+    providers?: string;
+    sources?: string;
+    groupBy?: string;
+    backendUrl?: string;
+}, envVars?: {
+    [key: string]: string | undefined;
+}): ResolvedConfig;
+/**
+ * @typedef {{
+ *   'group-by'?: 'dependency' | 'bundle',
+ *   exclude?: string[],
+ *   labels?: string[],
+ *   'branch-prefix'?: string,
+ *   [key: string]: unknown
+ * }} RemediationConfig
+ */
+/** @typedef {{ critical?: number, high?: number, 'license-conflicts'?: number, [key: string]: unknown }} FailOnConfig */
+/** @typedef {{ 'fail-on'?: FailOnConfig, [key: string]: unknown }} CheckConfig */
+/** @typedef {{ format?: string, targets?: string[], [key: string]: unknown }} SbomConfig */
+/**
+ * @typedef {{
+ *   'backend-url'?: string,
+ *   providers?: string[] | string,
+ *   sources?: string[] | string,
+ *   remediation?: RemediationConfig,
+ *   check?: CheckConfig,
+ *   sbom?: SbomConfig,
+ *   [key: string]: unknown
+ * }} FileConfig
+ */
+/**
+ * @typedef {{
+ *   backendUrl: string | null,
+ *   backendUrlSource: 'cli' | 'environment' | 'file' | 'default',
+ *   providers: string[],
+ *   sources: string[],
+ *   groupBy: string,
+ *   remediation: object,
+ *   check: object,
+ *   sbom: object
+ * }} ResolvedConfig
+ */
+/** Config file names discovered by walking up the directory tree, in precedence order. */
+export const CONFIG_FILENAMES: string[];
+export type RemediationConfig = {
+    "group-by"?: "dependency" | "bundle";
+    exclude?: string[];
+    labels?: string[];
+    "branch-prefix"?: string;
+    [key: string]: unknown;
+};
+export type FailOnConfig = {
+    critical?: number;
+    high?: number;
+    "license-conflicts"?: number;
+    [key: string]: unknown;
+};
+export type CheckConfig = {
+    "fail-on"?: FailOnConfig;
+    [key: string]: unknown;
+};
+export type SbomConfig = {
+    format?: string;
+    targets?: string[];
+    [key: string]: unknown;
+};
+export type FileConfig = {
+    "backend-url"?: string;
+    providers?: string[] | string;
+    sources?: string[] | string;
+    remediation?: RemediationConfig;
+    check?: CheckConfig;
+    sbom?: SbomConfig;
+    [key: string]: unknown;
+};
+export type ResolvedConfig = {
+    backendUrl: string | null;
+    backendUrlSource: "cli" | "environment" | "file" | "default";
+    providers: string[];
+    sources: string[];
+    groupBy: string;
+    remediation: object;
+    check: object;
+    sbom: object;
+};

package/dist/src/config.js

@@ -0,0 +1,260 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { load as yamlLoad } from 'js-yaml';
+/**
+ * @typedef {{
+ *   'group-by'?: 'dependency' | 'bundle',
+ *   exclude?: string[],
+ *   labels?: string[],
+ *   'branch-prefix'?: string,
+ *   [key: string]: unknown
+ * }} RemediationConfig
+ */
+/** @typedef {{ critical?: number, high?: number, 'license-conflicts'?: number, [key: string]: unknown }} FailOnConfig */
+/** @typedef {{ 'fail-on'?: FailOnConfig, [key: string]: unknown }} CheckConfig */
+/** @typedef {{ format?: string, targets?: string[], [key: string]: unknown }} SbomConfig */
+/**
+ * @typedef {{
+ *   'backend-url'?: string,
+ *   providers?: string[] | string,
+ *   sources?: string[] | string,
+ *   remediation?: RemediationConfig,
+ *   check?: CheckConfig,
+ *   sbom?: SbomConfig,
+ *   [key: string]: unknown
+ * }} FileConfig
+ */
+/**
+ * @typedef {{
+ *   backendUrl: string | null,
+ *   backendUrlSource: 'cli' | 'environment' | 'file' | 'default',
+ *   providers: string[],
+ *   sources: string[],
+ *   groupBy: string,
+ *   remediation: object,
+ *   check: object,
+ *   sbom: object
+ * }} ResolvedConfig
+ */
+/** Config file names discovered by walking up the directory tree, in precedence order. */
+export const CONFIG_FILENAMES = ['.trustify-da.yml', '.trustify-da.yaml'];
+function isMapping(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype == null;
+}
+function assertMapping(value, field, source) {
+    if (!isMapping(value)) {
+        throw new Error(`Invalid config file ${source}: ${field} must be a mapping`);
+    }
+}
+function assertString(value, field, source) {
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid config file ${source}: ${field} must be a string`);
+    }
+}
+function assertStringArray(value, field, source) {
+    if (!Array.isArray(value) || value.some(item => typeof item !== 'string')) {
+        throw new Error(`Invalid config file ${source}: ${field} must be an array of strings`);
+    }
+}
+function assertStringOrArray(value, field, source) {
+    if (typeof value !== 'string') {
+        assertStringArray(value, field, source);
+    }
+}
+/**
+ * Validates all fields in the initial configuration schema. Unknown fields are preserved.
+ * @param {unknown} config
+ * @param {string} [source]
+ * @returns {FileConfig}
+ */
+function validateConfig(config, source = '<config>') {
+    assertMapping(config, 'root', source);
+    if (config['backend-url'] !== undefined) {
+        assertString(config['backend-url'], 'backend-url', source);
+    }
+    if (config.providers !== undefined) {
+        assertStringOrArray(config.providers, 'providers', source);
+    }
+    if (config.sources !== undefined) {
+        assertStringOrArray(config.sources, 'sources', source);
+    }
+    if (config.remediation !== undefined) {
+        assertMapping(config.remediation, 'remediation', source);
+        const remediation = config.remediation;
+        if (remediation['group-by'] !== undefined && !['dependency', 'bundle'].includes(remediation['group-by'])) {
+            throw new Error(`Invalid config file ${source}: remediation.group-by must be dependency or bundle`);
+        }
+        if (remediation.exclude !== undefined) {
+            assertStringArray(remediation.exclude, 'remediation.exclude', source);
+        }
+        if (remediation.labels !== undefined) {
+            assertStringArray(remediation.labels, 'remediation.labels', source);
+        }
+        if (remediation['branch-prefix'] !== undefined) {
+            assertString(remediation['branch-prefix'], 'remediation.branch-prefix', source);
+        }
+    }
+    if (config.check !== undefined) {
+        assertMapping(config.check, 'check', source);
+        if (config.check['fail-on'] !== undefined) {
+            assertMapping(config.check['fail-on'], 'check.fail-on', source);
+            for (const field of ['critical', 'high', 'license-conflicts']) {
+                const value = config.check['fail-on'][field];
+                if (value !== undefined && (typeof value !== 'number' || !Number.isFinite(value))) {
+                    throw new Error(`Invalid config file ${source}: check.fail-on.${field} must be a finite number`);
+                }
+            }
+        }
+    }
+    if (config.sbom !== undefined) {
+        assertMapping(config.sbom, 'sbom', source);
+        if (config.sbom.format !== undefined) {
+            assertString(config.sbom.format, 'sbom.format', source);
+        }
+        if (config.sbom.targets !== undefined) {
+            assertStringArray(config.sbom.targets, 'sbom.targets', source);
+        }
+    }
+    return config;
+}
+/**
+ * Walks up from `startPath` looking for a `.trustify-da.yml` (or `.yaml`) file,
+ * similar to how `.eslintrc` discovery works. If `startPath` points at a file,
+ * discovery begins in its containing directory. Within a directory, `.yml` takes
+ * precedence over `.yaml`.
+ * @param {string} startPath - manifest file or directory to start the search from
+ * @returns {string | null} absolute path to the config file, or null if none found
+ */
+function findConfigFile(startPath) {
+    let dir = path.resolve(startPath || '.');
+    try {
+        if (fs.statSync(dir).isFile()) {
+            dir = path.dirname(dir);
+        }
+    }
+    catch {
+        // startPath may not exist yet — walk up from its resolved location anyway
+    }
+    // Walk up until the filesystem root (where dirname(dir) === dir)
+    for (;;) {
+        for (const name of CONFIG_FILENAMES) {
+            const candidate = path.join(dir, name);
+            try {
+                if (fs.statSync(candidate).isFile()) {
+                    return candidate;
+                }
+            }
+            catch {
+                // Ignore inaccessible or disappearing candidates and continue discovery.
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return null;
+        }
+        dir = parent;
+    }
+}
+/**
+ * Discovers and parses `.trustify-da.yml` by walking up from `startPath`.
+ * A missing config file is not an error — an empty object is returned so callers
+ * can fall back to defaults.
+ * @param {string} [startPath] - manifest file or directory to start the search from
+ * @returns {FileConfig} the parsed config object, or `{}` when no file is found
+ * @throws {Error} when the config file exists but contains malformed YAML
+ */
+export function loadConfig(startPath) {
+    const configPath = findConfigFile(startPath);
+    if (!configPath) {
+        return {};
+    }
+    const content = fs.readFileSync(configPath, 'utf-8');
+    let doc;
+    try {
+        doc = yamlLoad(content);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse config file ${configPath}: ${err.message}`);
+    }
+    return doc == null ? {} : validateConfig(doc, configPath);
+}
+/**
+ * Normalizes a providers/sources value to an array of trimmed strings. Accepts
+ * either a YAML array (`[redhat, osv]`) or a comma-separated string (`redhat,osv`).
+ * @param {string[] | string | undefined | null} value
+ * @returns {string[]}
+ */
+function toArray(value) {
+    if (Array.isArray(value)) {
+        return value.filter(v => typeof v === 'string' && v.trim()).map(v => v.trim());
+    }
+    if (typeof value === 'string') {
+        return value.split(',').map(v => v.trim()).filter(Boolean);
+    }
+    return [];
+}
+/**
+ * Returns the first argument that is neither undefined nor null.
+ * @param {...unknown} values
+ * @returns {unknown}
+ */
+function first(...values) {
+    return values.find(v => v != null);
+}
+/**
+ * Merges config sources with precedence: CLI flag > environment variable
+ * (`TRUSTIFY_DA_*`) > config file > hardcoded default. Providers and sources are
+ * normalized to arrays regardless of whether the source used a YAML array or a
+ * comma-separated string.
+ * @param {FileConfig} [fileConfig={}] - values parsed from `.trustify-da.yml`
+ * @param {{ providers?: string, sources?: string, groupBy?: string, backendUrl?: string }} [cliFlags={}]
+ * @param {{ [key: string]: string | undefined }} [envVars={}] - typically `process.env`
+ * @returns {ResolvedConfig} the resolved, typed config object
+ */
+export function mergeConfig(fileConfig = {}, cliFlags = {}, envVars = {}) {
+    const file = validateConfig(fileConfig || {});
+    const cli = cliFlags || {};
+    const env = envVars || {};
+    let backendUrl = null;
+    let backendUrlSource = 'default';
+    if (cli.backendUrl != null) {
+        backendUrl = cli.backendUrl;
+        backendUrlSource = 'cli';
+    }
+    else if (env.TRUSTIFY_DA_BACKEND_URL != null) {
+        backendUrl = env.TRUSTIFY_DA_BACKEND_URL;
+        backendUrlSource = 'environment';
+    }
+    else if (file['backend-url'] != null) {
+        backendUrl = file['backend-url'];
+        backendUrlSource = 'file';
+    }
+    const groupBy = first(cli.groupBy, env.TRUSTIFY_DA_GROUP_BY, file.remediation?.['group-by']) ?? 'dependency';
+    if (!['dependency', 'bundle'].includes(groupBy)) {
+        throw new Error(`Invalid group-by value "${groupBy}". Expected dependency or bundle.`);
+    }
+    return {
+        backendUrl,
+        backendUrlSource,
+        providers: toArray(first(cli.providers, env.TRUSTIFY_DA_PROVIDERS, file.providers)),
+        sources: toArray(first(cli.sources, env.TRUSTIFY_DA_SOURCES, file.sources)),
+        groupBy,
+        remediation: file.remediation ?? {},
+        check: file.check ?? {},
+        sbom: file.sbom ?? {},
+    };
+}
+/**
+ * Loads and merges the project configuration for a target path.
+ * @param {string} [startPath] - manifest file or directory to start discovery from
+ * @param {{ providers?: string, sources?: string, groupBy?: string, backendUrl?: string }} [cliFlags={}] - explicit options
+ * @param {{ [key: string]: string | undefined }} [envVars={}] - typically `process.env`
+ * @returns {ResolvedConfig} the resolved, typed config object
+ */
+export function resolveConfig(startPath, cliFlags = {}, envVars = {}) {
+    return mergeConfig(loadConfig(startPath), cliFlags, envVars);
+}

package/dist/src/cyclone_dx_sbom.d.ts

@@ -26,6 +26,19 @@ export default class CycloneDxSbom {
         alg: string;
         content: string;
     }>): CycloneDxSbom;
+    /**
+     * Attach hashes to already-added components by matching their PURL. This is a
+     * post-processing step so ecosystem-specific hash sources (e.g. Maven reading
+     * the local .m2 cache) can enrich the SBOM without threading their concern
+     * through the shared dependency-tree parser. Components without a matching
+     * entry, or whose hashes are already set, are left untouched.
+     * @param {Map<string, Array<{alg: string, content: string}>>} hashMap - PURL→hashes map
+     * @return {CycloneDxSbom} the updated SBOM
+     */
+    attachHashes(hashMap: Map<string, Array<{
+        alg: string;
+        content: string;
+    }>>): CycloneDxSbom;
     /** @param {{}} opts - various options, settings and configuration of application.
      * @return String CycloneDx Sbom json object in a string format
      */