agent-master-devsecops 0.0.0-stage → 5.1.0

package/scripts/auditors/sca_dependency_auditor.js

@@ -0,0 +1,673 @@
+/**
+ * scripts/auditors/sca_dependency_auditor.js
+ * Auditor Industrial de Composição de Software (SCA) & Conformidade de Licenças (v5.1 Enterprise)
+ * 
+ * Integração multi-tier e de primeira classe com ferramentas oficiais da indústria:
+ * - npm audit nativo (banco de vulnerabilidades GitHub Advisory / CVE em tempo real)
+ * - Trivy CLI (scanner universal de vulnerabilidades em sistemas de arquivos e dependências)
+ * - OSV.dev Live API via KnowledgeGateway (Tier 1 de Grounding com Hot Cache SQLite WAL)
+ * - Fallback determinístico para catálogo de contingência e checagem de licenças copyleft tóxicas
+ * - Emissão de relatórios oficiais em padrão OASIS SARIF v2.1.0 (auditToSarif)
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { getKnowledgeGateway } = require('../core/knowledge_gateway.js');
+const { createSarifReport } = require('../core/sarif_engine.js');
+
+// Catálogo imutável de licenças com restrições copyleft estritas (risco comercial e IP)
+const RESTRICTIVE_LICENSES = Object.freeze([
+  'GPL-2.0',
+  'GPL-3.0',
+  'AGPL-3.0',
+  'SSPL',
+  'LGPL-3.0',
+  'GPL',
+  'AGPL'
+]);
+
+// Base de conhecimento offline de vulnerabilidades conhecidas (Fallback determinístico)
+const KNOWN_VULNERABLE_PACKAGES = Object.freeze([
+  Object.freeze({
+    name: 'lodash',
+    affectedVersionRegex: /^([0-3]\.|4\.(0|1[0-6]\.|17\.[0-9]\b|17\.1[0-9]\b|17\.20\b))/,
+    cve: 'CVE-2020-8203 / CWE-1321',
+    severity: 'ALTA',
+    description: 'Poluição de Protótipo (Prototype Pollution) via zipObjectDeep e defaultsDeep.',
+    recommendation: 'Atualize para lodash >= 4.17.21'
+  }),
+  Object.freeze({
+    name: 'axios',
+    affectedVersionRegex: /^(0\.(1[0-9]\.|2[0-1]\.[0-1]\b))/,
+    cve: 'CVE-2020-28168 / CWE-918',
+    severity: 'ALTA',
+    description: 'Server-Side Request Forgery (SSRF) e vazamento de cabeçalho de autorização em redirects.',
+    recommendation: 'Atualize para axios >= 0.21.2 ou >= 1.x'
+  }),
+  Object.freeze({
+    name: 'tar',
+    affectedVersionRegex: /^([0-5]\.|6\.(0\.|1\.[0-8]\b))/,
+    cve: 'CVE-2021-37712 / CWE-22',
+    severity: 'ALTA',
+    description: 'Path Traversal e sobrescrita arbitrária de arquivos durante extração de tarballs.',
+    recommendation: 'Atualize para tar >= 6.1.9'
+  }),
+  Object.freeze({
+    name: 'minimist',
+    affectedVersionRegex: /^([0-1]\.(0\.|1\.|2\.[0-5]\b))/,
+    cve: 'CVE-2020-7598 / CWE-1321',
+    severity: 'MÉDIA',
+    description: 'Prototype Pollution em argumento de linha de comando.',
+    recommendation: 'Atualize para minimist >= 1.2.6'
+  }),
+  Object.freeze({
+    name: 'shell-quote',
+    affectedVersionRegex: /^(1\.[0-6]\.|1\.7\.[0-2]\b)/,
+    cve: 'CVE-2021-42740 / CWE-78',
+    severity: 'CRÍTICA',
+    description: 'Command Injection via caracteres de escape mal formatados.',
+    recommendation: 'Atualize para shell-quote >= 1.7.3'
+  })
+]);
+
+/**
+ * Executa comandos CLI com timeout seguro, isolamento de buffer e proteção windowsHide.
+ */
+function runCliSafely(bin, args = [], options = {}) {
+  try {
+    const timeout = options.timeout || 30000;
+    const maxBuffer = options.maxBuffer || 15 * 1024 * 1024;
+    const cwd = options.cwd || process.cwd();
+
+    if (process.platform === 'win32') {
+      return spawnSync(process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', bin, ...args], {
+        encoding: 'utf8',
+        timeout,
+        maxBuffer,
+        windowsHide: true,
+        cwd
+      });
+    }
+    return spawnSync(bin, args, {
+      encoding: 'utf8',
+      timeout,
+      maxBuffer,
+      windowsHide: true,
+      cwd
+    });
+  } catch (err) {
+    return { status: -1, error: err };
+  }
+}
+
+/**
+ * Verifica se o comando npm audit está operacional no ambiente do host.
+ * @returns {boolean}
+ */
+function isNpmAuditAvailable() {
+  try {
+    const res = runCliSafely('npm', ['--version'], { timeout: 10000 });
+    return res.status === 0;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Verifica se a ferramenta Trivy CLI está disponível no PATH do host.
+ * @returns {boolean}
+ */
+function isTrivyAvailable() {
+  try {
+    const res = runCliSafely('trivy', ['--version'], { timeout: 10000 });
+    return res.status === 0;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Executa auditoria nativa real com npm audit.
+ * @param {string} targetDir
+ * @returns {object|null}
+ */
+function auditWithNpmAudit(targetDir) {
+  try {
+    const res = runCliSafely('npm', ['audit', '--json'], { cwd: targetDir, timeout: 60000 });
+    if (!res.stdout) return null;
+
+    let auditData;
+    try {
+      auditData = JSON.parse(res.stdout);
+    } catch (_) {
+      return null;
+    }
+
+    if (auditData.error) {
+      return null;
+    }
+
+    const vulnerabilities = [];
+    const rawVulns = auditData.vulnerabilities || {};
+
+    for (const [pkgName, detail] of Object.entries(rawVulns)) {
+      const severityMap = {
+        critical: 'CRÍTICA',
+        high: 'ALTA',
+        moderate: 'MÉDIA',
+        low: 'BAIXA',
+        info: 'INFO'
+      };
+      const severity = severityMap[detail.severity?.toLowerCase()] || 'ALTA';
+      const cves = Array.isArray(detail.via)
+        ? detail.via.map(v => typeof v === 'object' ? `${v.title} (${v.url || v.name})` : v).join('; ')
+        : (typeof detail.via === 'string' ? detail.via : 'Advisory');
+
+      vulnerabilities.push({
+        package: pkgName,
+        installedVersion: detail.range || 'N/A',
+        severity,
+        cve: cves,
+        description: `Detectado via npm audit: ${cves}`,
+        recommendation: detail.fixAvailable ? `npm audit fix (disponível: ${JSON.stringify(detail.fixAvailable)})` : 'Revisão manual da árvore de dependências'
+      });
+    }
+
+    const criticalOrHighVulns = vulnerabilities.filter(v => v.severity === 'CRÍTICA' || v.severity === 'ALTA');
+    const totalDeps = (auditData.metadata?.dependencies?.total) || Object.keys(rawVulns).length;
+
+    // Checagem de licença do manifesto
+    const pkgPath = path.join(targetDir, 'package.json');
+    const licenseIssues = [];
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        const lic = pkg.license || 'UNLICENSED';
+        if (RESTRICTIVE_LICENSES.some(r => String(lic).toUpperCase().includes(r))) {
+          licenseIssues.push({
+            package: pkg.name || 'root-project',
+            license: lic,
+            severity: 'ALTA',
+            message: `Licença restritiva detectada: ${lic}. Pode exigir abertura compulsória do código-fonte.`
+          });
+        }
+      } catch (err) {
+        void err;
+      }
+    }
+
+    const approved = criticalOrHighVulns.length === 0 && licenseIssues.length === 0;
+
+    return {
+      engine: 'npm_audit_industrial',
+      source: 'npm_audit_cli',
+      approved,
+      totalDependencies: totalDeps,
+      vulnerabilitiesCount: vulnerabilities.length,
+      criticalVulnerabilities: criticalOrHighVulns.length,
+      vulnerabilities,
+      licenseIssues,
+      wildcardIssues: [],
+      verdict: approved ? 'CONFORME' : 'VETADO',
+      auditSummary: auditData.metadata?.vulnerabilities || null
+    };
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Executa auditoria nativa real com Trivy CLI.
+ * @param {string} targetDir
+ * @returns {object|null}
+ */
+function auditWithTrivy(targetDir) {
+  try {
+    const res = runCliSafely('trivy', ['fs', '--format', 'json', '--quiet', targetDir], { timeout: 60000 });
+    if (!res.stdout || res.status !== 0) return null;
+
+    const data = JSON.parse(res.stdout);
+    const results = data.Results || [];
+    const vulnerabilities = [];
+
+    for (const r of results) {
+      const vulns = r.Vulnerabilities || [];
+      for (const v of vulns) {
+        const sevMap = {
+          CRITICAL: 'CRÍTICA',
+          HIGH: 'ALTA',
+          MEDIUM: 'MÉDIA',
+          LOW: 'BAIXA'
+        };
+        vulnerabilities.push({
+          package: v.PkgName,
+          installedVersion: v.InstalledVersion,
+          severity: sevMap[v.Severity] || 'MÉDIA',
+          cve: v.VulnerabilityID,
+          description: v.Title || v.Description || 'Trivy finding',
+          recommendation: v.FixedVersion ? `Atualizar para versão >= ${v.FixedVersion}` : 'Consultar fornecedor'
+        });
+      }
+    }
+
+    const criticalOrHighVulns = vulnerabilities.filter(v => v.severity === 'CRÍTICA' || v.severity === 'ALTA');
+    const approved = criticalOrHighVulns.length === 0;
+
+    return {
+      engine: 'trivy_cli_industrial',
+      source: 'trivy_cli',
+      approved,
+      totalDependencies: vulnerabilities.length,
+      vulnerabilitiesCount: vulnerabilities.length,
+      criticalVulnerabilities: criticalOrHighVulns.length,
+      vulnerabilities,
+      licenseIssues: [],
+      wildcardIssues: [],
+      verdict: approved ? 'CONFORME' : 'VETADO'
+    };
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Normaliza e parseia manifesto package.json com tratamento defensivo.
+ * @param {string|object} input 
+ * @returns {object}
+ */
+function resolveManifest(input) {
+  if (typeof input === 'object' && input !== null) {
+    return input;
+  }
+  if (typeof input === 'string') {
+    if (fs.existsSync(input)) {
+      const stats = fs.statSync(input);
+      if (stats.isDirectory()) {
+        const pkgPath = path.join(input, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+          return JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        }
+      }
+      return JSON.parse(fs.readFileSync(input, 'utf8'));
+    }
+    try {
+      return JSON.parse(input);
+    } catch (_) {
+      throw new Error(`Entrada de manifesto inválida: ${input.substring(0, 50)}`);
+    }
+  }
+  if (!input) {
+    return { name: 'unspecified-project', dependencies: {}, devDependencies: {}, license: 'UNLICENSED' };
+  }
+  throw new Error('Entrada inválida para manifesto package.json.');
+}
+
+/**
+ * Audita um manifesto ou diretório para SCA e conformidade de licenças.
+ * @param {string|object} manifestInput 
+ * @param {object} [options={}]
+ * @returns {object}
+ */
+function auditDependenciesSCA(manifestInput, options = {}) {
+  const preferLiveTool = options.preferLiveTool !== false;
+
+  // 1. Se for um caminho de arquivo ou diretório existente, tenta ferramentas industriais
+  if (preferLiveTool && typeof manifestInput === 'string' && fs.existsSync(manifestInput)) {
+    const stats = fs.statSync(manifestInput);
+    const targetDir = stats.isDirectory() ? manifestInput : path.dirname(manifestInput);
+
+    if (isTrivyAvailable()) {
+      const trivyRes = auditWithTrivy(targetDir);
+      if (trivyRes) return trivyRes;
+    }
+
+    const lockPath = path.join(targetDir, 'package-lock.json');
+    const shrinkwrapPath = path.join(targetDir, 'npm-shrinkwrap.json');
+    if ((fs.existsSync(lockPath) || fs.existsSync(shrinkwrapPath)) && isNpmAuditAvailable()) {
+      const npmRes = auditWithNpmAudit(targetDir);
+      if (npmRes) return npmRes;
+    }
+  }
+
+  // 2. Fallback determinístico para catálogo estático e análise de manifesto
+  let manifest;
+  try {
+    manifest = resolveManifest(manifestInput);
+  } catch (err) {
+    return {
+      approved: false,
+      error: `Falha ao carregar manifesto: ${err.message}`,
+      vulnerabilities: [],
+      licenseIssues: []
+    };
+  }
+
+  const prodDeps = manifest.dependencies || {};
+  const devDeps = manifest.devDependencies || {};
+  const allDeps = { ...prodDeps, ...devDeps };
+
+  const vulnerabilities = [];
+  const licenseIssues = [];
+  const wildcardIssues = [];
+
+  // Auditoria de Licença do Próprio Pacote
+  const projectLicense = manifest.license || 'UNLICENSED';
+  if (RESTRICTIVE_LICENSES.some(lic => String(projectLicense).toUpperCase().includes(lic))) {
+    licenseIssues.push({
+      package: manifest.name || 'root-project',
+      license: projectLicense,
+      severity: 'ALTA',
+      message: `Licença restritiva detectada: ${projectLicense}. Pode exigir abertura compulsória do código-fonte.`
+    });
+  }
+
+  // Auditoria de Versões e Vulnerabilidades Conhecidas
+  for (const [pkgName, versionSpec] of Object.entries(allDeps)) {
+    const rawVersion = String(versionSpec).replace(/^[\^~>=<]+/, '').trim();
+
+    // Checagem de Wildcard (reprodutibilidade)
+    if (versionSpec === '*' || versionSpec === 'latest') {
+      wildcardIssues.push({
+        package: pkgName,
+        version: versionSpec,
+        severity: 'MÉDIA',
+        message: `Uso de versão não determinística ("${versionSpec}"). Fere a Regra 1 de reprodutibilidade.`
+      });
+    }
+
+    // Checagem de CVEs conhecidas
+    for (const vuln of KNOWN_VULNERABLE_PACKAGES) {
+      if (vuln.name === pkgName && vuln.affectedVersionRegex.test(rawVersion)) {
+        vulnerabilities.push({
+          package: pkgName,
+          installedVersion: versionSpec,
+          severity: vuln.severity,
+          cve: vuln.cve,
+          description: vuln.description,
+          recommendation: vuln.recommendation
+        });
+      }
+    }
+  }
+
+  const criticalOrHighVulns = vulnerabilities.filter(v => v.severity === 'CRÍTICA' || v.severity === 'ALTA');
+  const approved = criticalOrHighVulns.length === 0 && licenseIssues.length === 0;
+
+  return {
+    engine: 'offline_catalog_fallback',
+    source: 'embedded_cve_catalog',
+    advisoryNotice: 'Auditoria executada via catálogo determinístico de contingência. Para análise em tempo real com bancos CVE oficiais (NVD/OSV), forneça o package-lock.json e utilize npm audit ou Trivy CLI.',
+    approved,
+    totalDependencies: Object.keys(allDeps).length,
+    vulnerabilitiesCount: vulnerabilities.length,
+    criticalVulnerabilities: criticalOrHighVulns.length,
+    vulnerabilities,
+    licenseIssues,
+    wildcardIssues,
+    verdict: approved ? 'CONFORME' : 'VETADO'
+  };
+}
+
+/**
+ * Executa auditoria de dependências consumindo a base oficial do OSV.dev via KnowledgeGateway.
+ * @param {string|object} manifestInput
+ * @param {object} [options={}]
+ * @returns {Promise<object>}
+ */
+async function auditWithOsvApi(manifestInput, options = {}) {
+  let manifest;
+  try {
+    manifest = resolveManifest(manifestInput);
+  } catch (err) {
+    return {
+      approved: false,
+      error: `Falha ao carregar manifesto: ${err.message}`,
+      vulnerabilities: [],
+      licenseIssues: []
+    };
+  }
+
+  const gateway = options.gateway || getKnowledgeGateway(options);
+  const prodDeps = manifest.dependencies || {};
+  const devDeps = manifest.devDependencies || {};
+  const allDeps = { ...prodDeps, ...devDeps };
+
+  const vulnerabilities = [];
+  const licenseIssues = [];
+  const wildcardIssues = [];
+
+  // Checagem de licença do projeto
+  const projectLicense = manifest.license || 'UNLICENSED';
+  if (RESTRICTIVE_LICENSES.some(lic => String(projectLicense).toUpperCase().includes(lic))) {
+    licenseIssues.push({
+      package: manifest.name || 'root-project',
+      license: projectLicense,
+      severity: 'ALTA',
+      message: `Licença restritiva detectada: ${projectLicense}. Pode exigir abertura compulsória do código-fonte.`
+    });
+  }
+
+  // Consulta de vulnerabilidades OSV para cada dependência
+  const ecosystem = options.ecosystem || 'npm';
+  for (const [pkgName, versionSpec] of Object.entries(allDeps)) {
+    const rawVersion = String(versionSpec).replace(/^[\^~>=<]+/, '').trim();
+    if (versionSpec === '*' || versionSpec === 'latest') {
+      wildcardIssues.push({
+        package: pkgName,
+        version: versionSpec,
+        severity: 'MÉDIA',
+        message: `Uso de versão não determinística ("${versionSpec}"). Fere a Regra 1 de reprodutibilidade.`
+      });
+    }
+
+    try {
+      const osvRes = await gateway.queryOsv(pkgName, rawVersion, ecosystem);
+      if (osvRes && osvRes.hasVulnerabilities) {
+        for (const v of osvRes.vulnerabilities) {
+          vulnerabilities.push({
+            package: pkgName,
+            installedVersion: versionSpec,
+            severity: v.severity || 'ALTA',
+            cve: v.cve || v.id,
+            description: v.summary || 'Vulnerabilidade reportada via OSV',
+            recommendation: v.recommendation || `Atualize ${pkgName}`
+          });
+        }
+      }
+    } catch (err) {
+      void err;
+    }
+  }
+
+  const criticalOrHighVulns = vulnerabilities.filter(v => v.severity === 'CRÍTICA' || v.severity === 'ALTA');
+  const approved = criticalOrHighVulns.length === 0 && licenseIssues.length === 0;
+
+  return {
+    engine: 'osv_gateway_augmentation',
+    source: 'osv_api',
+    approved,
+    totalDependencies: Object.keys(allDeps).length,
+    vulnerabilitiesCount: vulnerabilities.length,
+    criticalVulnerabilities: criticalOrHighVulns.length,
+    vulnerabilities,
+    licenseIssues,
+    wildcardIssues,
+    verdict: approved ? 'CONFORME' : 'VETADO'
+  };
+}
+
+/**
+ * Formata os resultados da auditoria SCA em relatório executivo Markdown/texto.
+ * @param {object} auditResult 
+ * @returns {string}
+ */
+function formatReport(auditResult) {
+  if (!auditResult || typeof auditResult !== 'object') {
+    return 'Relatório SCA inválido ou vazio.';
+  }
+
+  const vulns = Array.isArray(auditResult.vulnerabilities) ? auditResult.vulnerabilities : [];
+  const licenses = Array.isArray(auditResult.licenseIssues) ? auditResult.licenseIssues : [];
+  const wildcards = Array.isArray(auditResult.wildcardIssues) ? auditResult.wildcardIssues : [];
+
+  let output = '================================================================================\n';
+  output += `RELATÓRIO DE AUDITORIA DE DEPENDÊNCIAS & SCA [ ${auditResult.verdict || (auditResult.approved ? 'CONFORME' : 'VETADO')} ]\n`;
+  output += '================================================================================\n\n';
+
+  output += `Mecanismo de Análise: ${auditResult.engine || 'catálogo embutido'}\n`;
+  output += `Total de Dependências Auditadas: ${auditResult.totalDependencies || 0}\n`;
+  output += `Total de Vulnerabilidades Encontradas: ${auditResult.vulnerabilitiesCount || vulns.length}\n`;
+  output += `- Críticas / Altas: ${auditResult.criticalVulnerabilities || vulns.filter(v => v.severity === 'CRÍTICA' || v.severity === 'ALTA').length}\n`;
+  output += `- Problemas de Licença Restritiva: ${licenses.length}\n`;
+  output += `- Problemas de Versão Não-Determinística (Wildcard): ${wildcards.length}\n\n`;
+
+  if (auditResult.advisoryNotice) {
+    output += `Nota Consultiva: ${auditResult.advisoryNotice}\n\n`;
+  }
+
+  output += 'VULNERABILIDADES IDENTIFICADAS:\n';
+  if (vulns.length === 0) {
+    output += 'Nenhuma vulnerabilidade crítica ou conhecida identificada.\n';
+  } else {
+    vulns.forEach((v, idx) => {
+      output += `${idx + 1}. [${v.severity || 'ALTA'}] ${v.package} (versão instalada: ${v.installedVersion || 'N/A'})\n`;
+      output += `   CVE/Alerta: ${v.cve || 'N/A'}\n`;
+      output += `   Descrição: ${v.description || 'Vulnerabilidade em dependência'}\n`;
+      output += `   Recomendação: ${v.recommendation || 'Atualize a dependência'}\n\n`;
+    });
+  }
+
+  output += 'CONFORMIDADE DE LICENÇAS (IP & COPYLEFT):\n';
+  if (licenses.length === 0) {
+    output += 'Nenhuma licença restritiva ou copyleft tóxica detectada.\n';
+  } else {
+    licenses.forEach((lic, idx) => {
+      output += `${idx + 1}. [${lic.severity || 'ALTA'}] Pacote: ${lic.package} · Licença: ${lic.license}\n`;
+      output += `   Impacto: ${lic.message}\n\n`;
+    });
+  }
+
+  output += '================================================================================\n';
+  return output;
+}
+
+/**
+ * Executa a auditoria SCA e exporta o resultado em SARIF v2.1.0 oficial.
+ * @param {string|object} manifestInput
+ * @param {object} [options={}]
+ * @returns {object} SARIF v2.1.0
+ */
+function auditToSarif(manifestInput, options = {}) {
+  const auditRes = auditDependenciesSCA(manifestInput, options);
+  const findings = [];
+
+  for (const v of auditRes.vulnerabilities || []) {
+    findings.push({
+      ruleId: v.cve || 'SCA-VULN',
+      name: `Vulnerabilidade em Dependência: ${v.package}`,
+      severity: v.severity,
+      package: v.package,
+      installedVersion: v.installedVersion,
+      filename: typeof manifestInput === 'string' && fs.existsSync(manifestInput) ? manifestInput : 'package.json',
+      line: 1,
+      column: 1,
+      snippet: `"${v.package}": "${v.installedVersion}"`,
+      message: `${v.package} (${v.installedVersion}): ${v.description || v.cve}`,
+      remediation: v.recommendation
+    });
+  }
+
+  for (const lic of auditRes.licenseIssues || []) {
+    findings.push({
+      ruleId: 'SCA-RESTRICTIVE-LICENSE',
+      name: `Licença Restritiva Copyleft: ${lic.license}`,
+      severity: lic.severity,
+      package: lic.package,
+      filename: typeof manifestInput === 'string' && fs.existsSync(manifestInput) ? manifestInput : 'package.json',
+      line: 1,
+      column: 1,
+      snippet: `"license": "${lic.license}"`,
+      message: lic.message,
+      remediation: 'Substitua a dependência ou solicite aprovação jurídica.'
+    });
+  }
+
+  return createSarifReport({
+    toolName: auditRes.engine === 'trivy_cli_industrial' ? 'trivy-sca' : 'agent-master-sca-auditor',
+    toolVersion: '5.1.0',
+    findings,
+    properties: {
+      engine: auditRes.engine,
+      approved: auditRes.approved,
+      verdict: auditRes.verdict,
+      totalDependencies: auditRes.totalDependencies
+    }
+  });
+}
+
+/**
+ * Classe canônica do Auditor de Dependências e Composição de Software (SCA).
+ */
+class ScaDependencyAuditor {
+  constructor(options = {}) {
+    this.options = Object.freeze({ ...options });
+    this.restrictiveLicenses = Array.isArray(options.restrictiveLicenses)
+      ? options.restrictiveLicenses
+      : RESTRICTIVE_LICENSES;
+    this.knownVulnerabilities = Array.isArray(options.knownVulnerabilities)
+      ? options.knownVulnerabilities
+      : KNOWN_VULNERABLE_PACKAGES;
+  }
+
+  isNpmAuditAvailable() {
+    return isNpmAuditAvailable();
+  }
+
+  isTrivyAvailable() {
+    return isTrivyAvailable();
+  }
+
+  auditWithNpmAudit(targetDir) {
+    return auditWithNpmAudit(targetDir);
+  }
+
+  auditWithTrivy(targetDir) {
+    return auditWithTrivy(targetDir);
+  }
+
+  audit(manifestInput, options = {}) {
+    return auditDependenciesSCA(manifestInput, { ...this.options, ...options });
+  }
+
+  auditDependenciesSCA(manifestInput, options = {}) {
+    return auditDependenciesSCA(manifestInput, { ...this.options, ...options });
+  }
+
+  async auditWithOsvApi(manifestInput, options = {}) {
+    return auditWithOsvApi(manifestInput, { ...this.options, ...options });
+  }
+
+  auditToSarif(manifestInput, options = {}) {
+    return auditToSarif(manifestInput, { ...this.options, ...options });
+  }
+
+  formatReport(auditResult) {
+    return formatReport(auditResult);
+  }
+}
+
+module.exports = {
+  ScaDependencyAuditor,
+  auditDependenciesSCA,
+  auditWithOsvApi,
+  auditWithNpmAudit,
+  auditWithTrivy,
+  auditToSarif,
+  formatReport,
+  isNpmAuditAvailable,
+  isTrivyAvailable,
+  RESTRICTIVE_LICENSES,
+  KNOWN_VULNERABLE_PACKAGES
+};