@herodevs/cli 1.0.0-beta.2 → 1.2.0-beta.1

package/dist/commands/scan/sbom.js

@@ -1,7 +1,9 @@
-import path from 'node:path';
-import { Command, Flags, ux } from '@oclif/core';
+import { spawn } from 'node:child_process';
 import fs from 'node:fs';
+import { join, resolve } from 'node:path';
+import { Command, Flags, ux } from '@oclif/core';
 import { createSbom, validateIsCycloneDxSbom } from "../../service/eol/eol.svc.js";
+import { getErrorMessage } from "../../service/error.svc.js";
 export default class ScanSbom extends Command {
     static description = 'Scan a SBOM for purls';
     static enableJsonFlag = true;
@@ -23,16 +25,33 @@ export default class ScanSbom extends Command {
             default: false,
             description: 'Save the generated SBOM as nes.sbom.json in the scanned directory',
         }),
+        background: Flags.boolean({
+            char: 'b',
+            default: false,
+            description: 'Run the scan in the background',
+        }),
     };
+    static async loadSbom(flags, config) {
+        const sbomArgs = ScanSbom.getSbomArgs(flags);
+        const sbomCommand = new ScanSbom(sbomArgs, config);
+        const sbom = await sbomCommand.run();
+        if (!sbom) {
+            throw new Error('SBOM not generated');
+        }
+        return sbom;
+    }
     static getSbomArgs(flags) {
-        const { dir, file, save } = flags ?? {};
+        const { dir, file, save, json, background } = flags ?? {};
         const sbomArgs = [];
         if (file)
             sbomArgs.push('--file', file);
         if (dir)
             sbomArgs.push('--dir', dir);
-        if (save)
-            sbomArgs.push('--save');
+        // if (save) sbomArgs.push('--save'); // only save if sbom command is used directly with -s flag
+        if (json)
+            sbomArgs.push('--json');
+        if (background)
+            sbomArgs.push('--background');
         return sbomArgs;
     }
     getScanOptions() {
@@ -41,44 +60,78 @@ export default class ScanSbom extends Command {
     }
     async run() {
         const { flags } = await this.parse(ScanSbom);
-        const { dir: _dirFlag, save, file: _fileFlag } = flags;
+        const { dir, save, file, background } = flags;
         // Validate that exactly one of --file or --dir is provided
-        if (_fileFlag && _dirFlag) {
-            throw new Error('Cannot specify both --file and --dir flags. Please use one or the other.');
+        if (file && dir) {
+            this.error('Cannot specify both --file and --dir flags. Please use one or the other.');
         }
         let sbom;
-        if (_fileFlag) {
-            sbom = this._getSbomFromFile(_fileFlag);
+        const path = dir || process.cwd();
+        if (file) {
+            sbom = this._getSbomFromFile(file);
+        }
+        else if (background) {
+            this._getSbomInBackground(path);
+            this.log(`The scan is running in the background. The file will be saved at ${path}/nes.sbom.json`);
+            return;
         }
         else {
-            const _dir = _dirFlag || process.cwd();
-            sbom = await this._getSbomFromScan(_dir);
+            sbom = await this._getSbomFromScan(path);
             if (save) {
-                this._saveSbom(_dir, sbom);
+                this._saveSbom(path, sbom);
             }
         }
         return sbom;
     }
     async _getSbomFromScan(_dirFlag) {
-        const dir = path.resolve(_dirFlag);
-        if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
-            throw new Error(`Directory not found or not a directory: ${dir}`);
+        const dir = resolve(_dirFlag);
+        try {
+            if (!fs.existsSync(dir)) {
+                this.error(`Directory not found: ${dir}`);
+            }
+            const stats = fs.statSync(dir);
+            if (!stats.isDirectory()) {
+                this.error(`Path is not a directory: ${dir}`);
+            }
+            ux.action.start(`Scanning ${dir}`);
+            const options = this.getScanOptions();
+            const sbom = await createSbom(dir, options);
+            if (!sbom) {
+                this.error(`SBOM failed to generate for dir: ${dir}`);
+            }
+            return sbom;
         }
-        ux.action.start(`Scanning ${dir}`);
-        const options = this.getScanOptions();
-        const sbom = await createSbom(dir, options);
-        if (!sbom) {
-            throw new Error(`SBOM failed to generate for dir: ${dir}`);
+        catch (error) {
+            this.error(`Failed to scan directory: ${getErrorMessage(error)}`);
         }
-        return sbom;
     }
-    _getSbomFromFile(_fileFlag) {
-        const file = path.resolve(_fileFlag);
-        if (!fs.existsSync(file)) {
-            throw new Error(`SBOM file not found: ${file}`);
+    _getSbomInBackground(path) {
+        try {
+            const opts = this.getScanOptions();
+            const args = [
+                JSON.stringify({
+                    opts,
+                    path,
+                }),
+            ];
+            const workerProcess = spawn('node', [join(import.meta.url, '../../service/eol/sbom.worker.js'), ...args], {
+                stdio: 'ignore',
+                detached: true,
+                env: { ...process.env },
+            });
+            workerProcess.unref();
         }
-        ux.action.start(`Loading sbom from ${file}`);
+        catch (error) {
+            this.error(`Failed to start background scan: ${getErrorMessage(error)}`);
+        }
+    }
+    _getSbomFromFile(_fileFlag) {
+        const file = resolve(_fileFlag);
         try {
+            if (!fs.existsSync(file)) {
+                this.error(`SBOM file not found: ${file}`);
+            }
+            ux.action.start(`Loading sbom from ${file}`);
             const fileContent = fs.readFileSync(file, {
                 encoding: 'utf8',
                 flag: 'r',
@@ -88,19 +141,19 @@ export default class ScanSbom extends Command {
             return sbom;
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to read or parse SBOM file: ${errorMessage}`);
+            this.error(`Failed to read SBOM file: ${getErrorMessage(error)}`);
         }
     }
     _saveSbom(dir, sbom) {
         try {
-            const outputPath = path.join(dir, 'nes.sbom.json');
+            const outputPath = join(dir, 'nes.sbom.json');
             fs.writeFileSync(outputPath, JSON.stringify(sbom, null, 2));
-            this.log(`SBOM saved to ${outputPath}`);
+            if (!this.jsonEnabled()) {
+                this.log(`SBOM saved to ${outputPath}`);
+            }
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.warn(`Failed to save SBOM: ${errorMessage}`);
+            this.error(`Failed to save SBOM: ${getErrorMessage(error)}`);
         }
     }
 }

package/dist/hooks/prerun.js

@@ -0,0 +1,8 @@
+import debug from 'debug';
+const hook = async (opts) => {
+    // If JSON flag is enabled, silence debug logging
+    if (opts.Command.prototype.jsonEnabled()) {
+        debug.disable();
+    }
+};
+export default hook;

package/dist/service/committers.svc.js

@@ -21,7 +21,14 @@ export function parseGitLogOutput(output) {
 export function groupCommitsByMonth(entries) {
     const result = {};
     // Group commits by month
-    const commitsByMonth = Object.groupBy(entries, (entry) => entry.month);
+    const commitsByMonth = entries.reduce((acc, entry) => {
+        const monthKey = entry.month;
+        if (!acc[monthKey]) {
+            acc[monthKey] = [];
+        }
+        acc[monthKey].push(entry);
+        return acc;
+    }, {});
     // Process each month
     for (const [month, commits] of Object.entries(commitsByMonth)) {
         if (!commits) {
@@ -29,7 +36,14 @@ export function groupCommitsByMonth(entries) {
             continue;
         }
         // Count commits per author for this month
-        const commitsByAuthor = Object.groupBy(commits, (entry) => entry.author);
+        const commitsByAuthor = commits.reduce((acc, entry) => {
+            const authorKey = entry.author;
+            if (!acc[authorKey]) {
+                acc[authorKey] = [];
+            }
+            acc[authorKey].push(entry);
+            return acc;
+        }, {});
         const authorCounts = {};
         for (const [author, authorCommits] of Object.entries(commitsByAuthor)) {
             authorCounts[author] = authorCommits?.length ?? 0;
@@ -44,7 +58,14 @@ export function groupCommitsByMonth(entries) {
  * @returns Object with authors as keys and total commit counts as values
  */
 export function calculateOverallStats(entries) {
-    const commitsByAuthor = Object.groupBy(entries, (entry) => entry.author);
+    const commitsByAuthor = entries.reduce((acc, entry) => {
+        const authorKey = entry.author;
+        if (!acc[authorKey]) {
+            acc[authorKey] = [];
+        }
+        acc[authorKey].push(entry);
+        return acc;
+    }, {});
     const result = {};
     // Count commits for each author
     for (const author in commitsByAuthor) {

package/dist/service/eol/cdx.svc.d.ts

@@ -9,6 +9,58 @@ export interface Sbom {
     components: SbomEntry[];
     dependencies: SbomEntry[];
 }
+export declare const SBOM_DEFAULT__OPTIONS: {
+    $0: string;
+    _: never[];
+    'auto-compositions': boolean;
+    autoCompositions: boolean;
+    'data-flow-slices-file': string;
+    dataFlowSlicesFile: string;
+    deep: boolean;
+    'deps-slices-file': string;
+    depsSlicesFile: string;
+    evidence: boolean;
+    'export-proto': boolean;
+    exportProto: boolean;
+    'fail-on-error': boolean;
+    failOnError: boolean;
+    false: boolean;
+    'include-crypto': boolean;
+    'include-formulation': boolean;
+    includeCrypto: boolean;
+    includeFormulation: boolean;
+    'install-deps': boolean;
+    installDeps: boolean;
+    'min-confidence': number;
+    minConfidence: number;
+    multiProject: boolean;
+    'no-banner': boolean;
+    noBabel: boolean;
+    noBanner: boolean;
+    o: string;
+    output: string;
+    outputFormat: string;
+    profile: string;
+    project: undefined;
+    'project-version': string;
+    projectVersion: string;
+    'proto-bin-file': string;
+    protoBinFile: string;
+    r: boolean;
+    'reachables-slices-file': string;
+    reachablesSlicesFile: string;
+    recurse: boolean;
+    requiredOnly: boolean;
+    'semantics-slices-file': string;
+    semanticsSlicesFile: string;
+    'skip-dt-tls-check': boolean;
+    skipDtTlsCheck: boolean;
+    'spec-version': number;
+    specVersion: number;
+    'usages-slices-file': string;
+    usagesSlicesFile: string;
+    validate: boolean;
+};
 /**
  * Lazy loads cdxgen (for ESM purposes), scans
  * `directory`, and returns the `bomJson` property.

package/dist/service/eol/cdx.svc.js

@@ -1,71 +1,66 @@
-import { log } from "../../service/log.svc.js";
+import { debugLogger } from "../../service/log.svc.js";
+export const SBOM_DEFAULT__OPTIONS = {
+    $0: 'cdxgen',
+    _: [],
+    'auto-compositions': true,
+    autoCompositions: true,
+    'data-flow-slices-file': 'data-flow.slices.json',
+    dataFlowSlicesFile: 'data-flow.slices.json',
+    deep: false, // TODO: you def want to check this out
+    'deps-slices-file': 'deps.slices.json',
+    depsSlicesFile: 'deps.slices.json',
+    evidence: false,
+    'export-proto': false,
+    exportProto: false,
+    // DON'T FAIL ON ERROR; you won't get hlepful logs
+    'fail-on-error': false,
+    failOnError: false,
+    false: true,
+    'include-crypto': false,
+    'include-formulation': false,
+    includeCrypto: false,
+    includeFormulation: false,
+    'install-deps': true,
+    installDeps: true,
+    'min-confidence': 0,
+    minConfidence: 0,
+    multiProject: true,
+    'no-banner': false,
+    noBabel: false,
+    noBanner: false,
+    o: 'bom.json',
+    output: 'bom.json',
+    outputFormat: 'json', // or "xml"
+    // author: ['OWASP Foundation'],
+    profile: 'generic',
+    project: undefined,
+    'project-version': '',
+    projectVersion: '',
+    'proto-bin-file': 'bom.cdx',
+    protoBinFile: 'bom.cdx',
+    r: false,
+    'reachables-slices-file': 'reachables.slices.json',
+    reachablesSlicesFile: 'reachables.slices.json',
+    recurse: false,
+    requiredOnly: false,
+    'semantics-slices-file': 'semantics.slices.json',
+    semanticsSlicesFile: 'semantics.slices.json',
+    'skip-dt-tls-check': true,
+    skipDtTlsCheck: true,
+    'spec-version': 1.6,
+    specVersion: 1.6,
+    'usages-slices-file': 'usages.slices.json',
+    usagesSlicesFile: 'usages.slices.json',
+    validate: true,
+};
 /**
  * Lazy loads cdxgen (for ESM purposes), scans
  * `directory`, and returns the `bomJson` property.
  */
 export async function createBomFromDir(directory, opts = {}) {
-    const options = {
-        $0: 'cdxgen',
-        _: [],
-        'auto-compositions': true,
-        autoCompositions: true,
-        'data-flow-slices-file': 'data-flow.slices.json',
-        dataFlowSlicesFile: 'data-flow.slices.json',
-        deep: false, // TODO: you def want to check this out
-        'deps-slices-file': 'deps.slices.json',
-        depsSlicesFile: 'deps.slices.json',
-        evidence: false,
-        'export-proto': false,
-        exportProto: false,
-        // DON'T FAIL ON ERROR; you won't get hlepful logs
-        'fail-on-error': false,
-        failOnError: false,
-        false: true,
-        'include-crypto': false,
-        'include-formulation': false,
-        includeCrypto: false,
-        includeFormulation: false,
-        // 'server-host': '127.0.0.1',
-        // serverHost: '127.0.0.1',
-        // 'server-port': '9090',
-        // serverPort: '9090',
-        'install-deps': true,
-        installDeps: true,
-        'min-confidence': 0,
-        minConfidence: 0,
-        multiProject: true,
-        'no-banner': false,
-        noBabel: false,
-        noBanner: false,
-        o: 'bom.json',
-        output: 'bom.json',
-        outputFormat: 'json', // or "xml"
-        // author: ['OWASP Foundation'],
-        profile: 'generic',
-        project: undefined,
-        'project-version': '',
-        projectVersion: '',
-        'proto-bin-file': 'bom.cdx',
-        protoBinFile: 'bom.cdx',
-        r: false,
-        'reachables-slices-file': 'reachables.slices.json',
-        reachablesSlicesFile: 'reachables.slices.json',
-        recurse: false,
-        requiredOnly: false,
-        'semantics-slices-file': 'semantics.slices.json',
-        semanticsSlicesFile: 'semantics.slices.json',
-        'skip-dt-tls-check': true,
-        skipDtTlsCheck: true,
-        'spec-version': 1.6,
-        specVersion: 1.6,
-        'usages-slices-file': 'usages.slices.json',
-        usagesSlicesFile: 'usages.slices.json',
-        validate: true,
-        ...opts,
-    };
     const { createBom } = await getCdxGen();
-    const sbom = await createBom?.(directory, options);
-    log.info('Successfully generated SBOM');
+    const sbom = await createBom?.(directory, { ...SBOM_DEFAULT__OPTIONS, ...opts });
+    debugLogger('Successfully generated SBOM');
     return sbom?.bomJson;
 }
 // use a value holder, for easier mocking
@@ -77,6 +72,7 @@ export async function getCdxGen() {
     const ogEnv = process.env.NODE_ENV;
     process.env.NODE_ENV = undefined;
     try {
+        // @ts-expect-error
         cdxgen.createBom = (await import('@cyclonedx/cdxgen')).createBom;
     }
     finally {

package/dist/service/eol/eol.svc.d.ts

@@ -1,5 +1,3 @@
-import type { ScanResult } from '../../api/types/nes.types.ts';
-import type { Line } from '../line.svc.ts';
 import { type Sbom } from './cdx.svc.ts';
 export interface CdxGenOptions {
     projectType?: string[];
@@ -12,23 +10,4 @@ export type CdxCreator = (dir: string, opts: CdxGenOptions) => Promise<{
 }>;
 export declare function createSbom(directory: string, opts?: ScanOptions): Promise<Sbom>;
 export declare function validateIsCycloneDxSbom(sbom: unknown): asserts sbom is Sbom;
-/**
- * Main function to scan directory and collect SBOM data
- */
-export declare function scanForEol(sbom: Sbom): Promise<{
-    purls: string[];
-    scan: ScanResult;
-}>;
-/**
- * Uses the purls from the sbom to run the scan.
- */
-export declare function submitScan(purls: string[]): Promise<ScanResult>;
-/**
- * Work in progress; creates "rows" for each component
- * based on the model + the scan result from NES.
- *
- * The idea being that each row can easily be used for
- * processing and/or rendering.
- */
-export declare function prepareRows(purls: string[], scan: ScanResult): Promise<Line[]>;
 export { cdxgen } from './cdx.svc.ts';

package/dist/service/eol/eol.svc.js

@@ -1,13 +1,10 @@
-import { NesApolloClient } from "../../api/nes/nes.client.js";
-import { log } from "../../service/log.svc.js";
-import { getDaysEolFromEolAt, getStatusFromComponent } from "../line.svc.js";
-import { extractPurls } from "../purls.svc.js";
+import { debugLogger } from "../../service/log.svc.js";
 import { createBomFromDir } from "./cdx.svc.js";
 export async function createSbom(directory, opts = {}) {
     const sbom = await createBomFromDir(directory, opts.cdxgen || {});
     if (!sbom)
         throw new Error('SBOM not generated');
-    log.info('SBOM generated');
+    debugLogger('SBOM generated');
     return sbom;
 }
 export function validateIsCycloneDxSbom(sbom) {
@@ -26,61 +23,4 @@ export function validateIsCycloneDxSbom(sbom) {
         throw new Error('Invalid SBOM: missing or invalid components array');
     }
 }
-/**
- * Main function to scan directory and collect SBOM data
- */
-export async function scanForEol(sbom) {
-    const purls = await extractPurls(sbom);
-    const scan = await submitScan(purls);
-    return { purls, scan };
-}
-/**
- * Uses the purls from the sbom to run the scan.
- */
-export async function submitScan(purls) {
-    // NOTE: GRAPHQL_HOST is set in `./bin/dev.js` or tests
-    const host = process.env.GRAPHQL_HOST || 'https://api.nes.herodevs.com';
-    const path = process.env.GRAPHQL_PATH || '/graphql';
-    const url = host + path;
-    const client = new NesApolloClient(url);
-    const scan = await client.scan.sbom(purls);
-    return scan;
-}
-/**
- * Work in progress; creates "rows" for each component
- * based on the model + the scan result from NES.
- *
- * The idea being that each row can easily be used for
- * processing and/or rendering.
- */
-export async function prepareRows(purls, scan) {
-    const lines = [];
-    for (const purl of purls) {
-        const details = scan.components.get(purl);
-        if (!details) {
-            // In this case, the purl string is in the generated sbom, but the NES/XEOL api has no data
-            // TODO: add UNKNOWN Component Status, create new line, and create flag to show/hide unknown results
-            log.debug(`Unknown status: ${purl}.`);
-            continue;
-        }
-        const { info } = details;
-        // Handle date deserialization from GraphQL
-        if (typeof info.eolAt === 'string' && info.eolAt) {
-            info.eolAt = new Date(info.eolAt);
-        }
-        const daysEol = getDaysEolFromEolAt(info.eolAt);
-        const status = getStatusFromComponent(details, daysEol);
-        const showOk = process.env.SHOW_OK === 'true';
-        if (!showOk && status === 'OK') {
-            continue;
-        }
-        lines.push({
-            daysEol,
-            info,
-            purl,
-            status,
-        });
-    }
-    return lines;
-}
 export { cdxgen } from "./cdx.svc.js";

package/dist/service/eol/sbom.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/service/eol/sbom.worker.js

@@ -0,0 +1,26 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+// @ts-expect-error
+import { createBom } from '@cyclonedx/cdxgen';
+import { SBOM_DEFAULT__OPTIONS } from "./cdx.svc.js";
+process.on('uncaughtException', (err) => {
+    console.error('Uncaught exception:', err.message);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('Unhandled rejection:', reason);
+    process.exit(1);
+});
+try {
+    console.log('Sbom worker started');
+    const options = JSON.parse(process.argv[2]);
+    const { path, opts } = options;
+    const { bomJson } = await createBom(path, { ...SBOM_DEFAULT__OPTIONS, ...opts });
+    const outputPath = join(path, 'nes.sbom.json');
+    writeFileSync(outputPath, JSON.stringify(bomJson, null, 2));
+    process.exit(0);
+}
+catch (error) {
+    console.error('Error creating SBOM', error.message);
+    process.exit(1);
+}

package/dist/service/error.svc.d.ts

@@ -0,0 +1,8 @@
+export declare const isError: (error: unknown) => error is Error;
+export declare const isErrnoException: (error: unknown) => error is NodeJS.ErrnoException;
+export declare const isApolloError: (error: unknown) => error is ApolloError;
+export declare const getErrorMessage: (error: unknown) => string;
+export declare class ApolloError extends Error {
+    readonly originalError?: unknown;
+    constructor(message: string, original?: unknown);
+}

package/dist/service/error.svc.js

@@ -0,0 +1,28 @@
+export const isError = (error) => {
+    return error instanceof Error;
+};
+export const isErrnoException = (error) => {
+    return isError(error) && 'code' in error;
+};
+export const isApolloError = (error) => {
+    return error instanceof ApolloError;
+};
+export const getErrorMessage = (error) => {
+    if (isError(error)) {
+        return error.message;
+    }
+    return 'Unknown error';
+};
+export class ApolloError extends Error {
+    originalError;
+    constructor(message, original) {
+        if (isError(original)) {
+            super(`${message}: ${original.message}`);
+        }
+        else {
+            super(`${message}: ${String(original)}`);
+        }
+        this.name = 'ApolloError';
+        this.originalError = original;
+    }
+}

package/dist/service/log.svc.d.ts

@@ -1,10 +1,7 @@
+import debug from 'debug';
 /**
- * A simple logging construct when you
- * don't have the command instance handy
+ * A simple debug logger for services.
+ * Services should only use debug logging for development/troubleshooting.
+ * All user-facing output should be handled by commands.
  */
-export declare const log: {
-    info: (_message?: unknown, ...args: unknown[]) => void;
-    warn: (_message?: unknown, ...args: unknown[]) => void;
-    debug: (_message?: unknown, ...args: unknown[]) => void;
-};
-export declare const initOclifLog: (info: (message?: unknown, ...args: unknown[]) => void, warn: (message?: unknown, ...args: unknown[]) => void, debug: (message?: unknown, ...args: unknown[]) => void) => void;
+export declare const debugLogger: debug.Debugger;

package/dist/service/log.svc.js

@@ -1,20 +1,7 @@
+import debug from 'debug';
 /**
- * A simple logging construct when you
- * don't have the command instance handy
+ * A simple debug logger for services.
+ * Services should only use debug logging for development/troubleshooting.
+ * All user-facing output should be handled by commands.
  */
-export const log = {
-    info: (_message, ...args) => {
-        console.log('[default_log]', ...args);
-    },
-    warn: (_message, ...args) => {
-        console.warn('[default_warn]', ...args);
-    },
-    debug: (_message, ...args) => {
-        console.debug('[default_debug]', ...args);
-    },
-};
-export const initOclifLog = (info, warn, debug) => {
-    log.info = info;
-    log.warn = warn;
-    log.debug = debug;
-};
+export const debugLogger = debug('oclif:herodevs-debug');

package/dist/service/nes/nes.svc.js

@@ -1,5 +1,5 @@
 import { M_SCAN } from "../../api/queries/nes/sbom.js";
-import { log } from "../log.svc.js";
+import { debugLogger } from "../log.svc.js";
 export const buildScanResult = (scan) => {
     const components = new Map();
     for (const c of scan.components) {
@@ -9,6 +9,7 @@ export const buildScanResult = (scan) => {
         components,
         message: scan.message,
         success: true,
+        warnings: scan.warnings || [],
     };
 };
 export const SbomScanner = (client) => async (purls) => {
@@ -16,8 +17,8 @@ export const SbomScanner = (client) => async (purls) => {
     const res = await client.mutate(M_SCAN.gql, { input });
     const scan = res.data?.insights?.scan?.eol;
     if (!scan?.success) {
-        log.info('failed scan %o', scan || {});
-        log.warn('scan failed');
+        debugLogger('failed scan %o', scan || {});
+        debugLogger('scan failed');
         throw new Error('Failed to provide scan: ');
     }
     const result = buildScanResult(scan);