@herodevs/cli 1.1.0-beta.1 → 1.2.0-beta.1

package/dist/commands/report/purls.js

@@ -1,8 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { Command, Flags, ux } from '@oclif/core';
+import { getErrorMessage, isErrnoException } from "../../service/error.svc.js";
 import { extractPurls, getPurlOutput } from "../../service/purls.svc.js";
-import SbomScan from "../scan/sbom.js";
+import ScanSbom from "../scan/sbom.js";
 export default class ReportPurls extends Command {
     static description = 'Generate a list of purls from a sbom';
     static enableJsonFlag = true;
@@ -36,36 +37,50 @@ export default class ReportPurls extends Command {
     async run() {
         const { flags } = await this.parse(ReportPurls);
         const { dir: _dirFlag, file: _fileFlag, save, csv } = flags;
-        const sbomArgs = SbomScan.getSbomArgs(flags);
-        const sbomCommand = new SbomScan(sbomArgs, this.config);
-        const sbom = await sbomCommand.run();
-        if (!sbom) {
-            throw new Error('SBOM not generated');
-        }
-        const purls = await extractPurls(sbom);
-        this.log('Extracted %d purls from SBOM', purls.length);
-        ux.action.stop('Scan completed');
-        // Print the purls
-        for (const purl of purls) {
-            this.log(purl);
-        }
-        // Save if requested
-        if (save) {
-            try {
-                const outputFile = csv && !this.jsonEnabled() ? 'csv' : 'json';
-                const outputPath = path.join(_dirFlag || process.cwd(), `nes.purls.${outputFile}`);
-                const purlOutput = getPurlOutput(purls, outputFile);
-                fs.writeFileSync(outputPath, purlOutput);
-                this.log('Purls saved to %s', outputPath);
+        try {
+            const sbom = await ScanSbom.loadSbom(flags, this.config);
+            const purls = await extractPurls(sbom);
+            this.log('Extracted %d purls from SBOM', purls.length);
+            ux.action.stop('Scan completed');
+            // Print the purls
+            for (const purl of purls) {
+                this.log(purl);
             }
-            catch (error) {
-                const errorMessage = error && typeof error === 'object' && 'message' in error ? error.message : 'Unknown error';
-                this.warn(`Failed to save purls: ${errorMessage}`);
+            // Save if requested
+            if (save) {
+                try {
+                    const outputFile = csv && !this.jsonEnabled() ? 'csv' : 'json';
+                    const outputPath = path.join(_dirFlag || process.cwd(), `nes.purls.${outputFile}`);
+                    const purlOutput = getPurlOutput(purls, outputFile);
+                    fs.writeFileSync(outputPath, purlOutput);
+                    this.log('Purls saved to %s', outputPath);
+                }
+                catch (error) {
+                    if (isErrnoException(error)) {
+                        switch (error.code) {
+                            case 'EACCES':
+                                this.error('Permission denied: Cannot write to output file');
+                                break;
+                            case 'ENOSPC':
+                                this.error('No space left on device');
+                                break;
+                            case 'EISDIR':
+                                this.error('Cannot write to output file: Is a directory');
+                                break;
+                            default:
+                                this.error(`Failed to save purls: ${getErrorMessage(error)}`);
+                        }
+                    }
+                    this.error(`Failed to save purls: ${getErrorMessage(error)}`);
+                }
             }
+            // Return wrapped object with metadata
+            return {
+                purls,
+            };
+        }
+        catch (error) {
+            this.error(`Failed to generate PURLs: ${getErrorMessage(error)}`);
         }
-        // Return wrapped object with metadata
-        return {
-            purls,
-        };
     }
 }

package/dist/commands/scan/eol.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import type { ScanResult } from '../../api/types/nes.types.ts';
+import type { ScanResultComponent } from '../../api/types/nes.types.ts';
 export default class ScanEol extends Command {
     static description: string;
     static enableJsonFlag: boolean;
@@ -8,9 +8,18 @@ export default class ScanEol extends Command {
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         dir: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         save: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        getCustomerSupport: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<ScanResult | {
-        components: [];
+    run(): Promise<{
+        components: ScanResultComponent[];
     }>;
-    private checkEolScanDisabled;
+    private scanSbom;
+    private getFilteredComponents;
+    private saveReport;
+    private displayResults;
+    private displayNoComponentsMessage;
+    private logLine;
+    private displayStatusSection;
+    private logLegend;
 }

package/dist/commands/scan/eol.js

@@ -1,13 +1,18 @@
+import fs from 'node:fs';
 import { Command, Flags, ux } from '@oclif/core';
-import { prepareRows, scanForEol } from "../../service/eol/eol.svc.js";
-import { promptComponentDetails } from "../../ui/eol.ui.js";
-import SbomScan from "./sbom.js";
+import { submitScan } from "../../api/nes/nes.client.js";
+import { getErrorMessage, isErrnoException } from "../../service/error.svc.js";
+import { extractPurls } from "../../service/purls.svc.js";
+import { createStatusDisplay } from "../../ui/eol.ui.js";
+import { INDICATORS, STATUS_COLORS } from "../../ui/shared.us.js";
+import ScanSbom from "./sbom.js";
 export default class ScanEol extends Command {
     static description = 'Scan a given sbom for EOL data';
     static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> --dir=./my-project',
         '<%= config.bin %> <%= command.id %> --file=path/to/sbom.json',
+        '<%= config.bin %> <%= command.id %> -a --dir=./my-project',
     ];
     static flags = {
         file: Flags.string({
@@ -23,52 +28,119 @@ export default class ScanEol extends Command {
             default: false,
             description: 'Save the generated SBOM as nes.sbom.json in the scanned directory',
         }),
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Show all components (default is EOL and LTS only)',
+            default: false,
+        }),
+        getCustomerSupport: Flags.boolean({
+            char: 'c',
+            description: 'Get Never-Ending Support for End-of-Life components',
+            default: false,
+        }),
     };
     async run() {
-        this.checkEolScanDisabled();
         const { flags } = await this.parse(ScanEol);
-        const { dir: _dirFlag, file: _fileFlag } = flags;
-        // Load the SBOM: Only pass the file, dir, and save flags to SbomScan
-        const sbomArgs = SbomScan.getSbomArgs(flags);
-        const sbomCommand = new SbomScan(sbomArgs, this.config);
-        const sbom = await sbomCommand.run();
-        if (!sbom) {
-            throw new Error('SBOM not generated');
+        if (flags.getCustomerSupport) {
+            this.log(ux.colorize('yellow', 'Never-Ending Support is on the way. Please stay tuned for this feature.'));
+        }
+        const sbom = await ScanSbom.loadSbom(flags, this.config);
+        const scan = await this.scanSbom(sbom);
+        ux.action.stop('\nScan completed');
+        const filteredComponents = this.getFilteredComponents(scan, flags.all);
+        if (flags.save) {
+            await this.saveReport(filteredComponents);
+        }
+        if (this.jsonEnabled()) {
+            return { components: filteredComponents };
+        }
+        await this.displayResults(scan, flags.all);
+        return { components: filteredComponents };
+    }
+    async scanSbom(sbom) {
+        let scan;
+        let purls;
+        try {
+            purls = await extractPurls(sbom);
+        }
+        catch (error) {
+            this.error(`Failed to extract purls from sbom. ${getErrorMessage(error)}`);
+        }
+        try {
+            scan = await submitScan(purls);
+        }
+        catch (error) {
+            this.error(`Failed to submit scan to NES from sbom. ${getErrorMessage(error)}`);
+        }
+        if (scan.components.size === 0) {
+            this.warn('No components found in scan');
         }
-        // Scan the SBOM for EOL information
-        const { purls, scan } = await scanForEol(sbom);
-        ux.action.stop('Scan completed');
-        if (!scan?.components) {
-            if (_fileFlag) {
-                throw new Error(`Scan failed to generate for file path: ${_fileFlag}`);
+        return scan;
+    }
+    getFilteredComponents(scan, all) {
+        return Array.from(scan.components.entries())
+            .filter(([_, component]) => all || ['EOL', 'LTS'].includes(component.info.status))
+            .map(([_, component]) => component);
+    }
+    async saveReport(components) {
+        try {
+            fs.writeFileSync('nes.eol.json', JSON.stringify({ components }, null, 2));
+            this.log('Report saved to nes.eol.json');
+        }
+        catch (error) {
+            if (isErrnoException(error)) {
+                switch (error.code) {
+                    case 'EACCES':
+                        this.error('Permission denied. Unable to save report to nes.eol.json');
+                        break;
+                    case 'ENOSPC':
+                        this.error('No space left on device. Unable to save report to nes.eol.json');
+                        break;
+                    default:
+                        this.error(`Failed to save report: ${getErrorMessage(error)}`);
+                }
             }
-            if (_dirFlag) {
-                throw new Error(`Scan failed to generate for dir: ${_dirFlag}`);
+            else {
+                this.error(`Failed to save report: ${getErrorMessage(error)}`);
             }
-            throw new Error('Scan failed to generate components.');
         }
-        const lines = await prepareRows(purls, scan);
-        if (lines?.length === 0) {
-            this.log('No dependencies found');
-            return { components: [] };
+    }
+    async displayResults(scan, all) {
+        const { UNKNOWN, OK, LTS, EOL } = createStatusDisplay(scan.components, all);
+        if (!UNKNOWN.length && !OK.length && !LTS.length && !EOL.length) {
+            this.displayNoComponentsMessage(all);
+            return;
         }
-        const r = await promptComponentDetails(lines);
-        this.log('What now %o', r);
-        return scan;
+        this.log(ux.colorize('bold', 'Here are the results of the scan:'));
+        this.logLine();
+        // Display sections in order of increasing severity
+        for (const components of [UNKNOWN, OK, LTS, EOL]) {
+            this.displayStatusSection(components);
+        }
+        this.logLegend();
     }
-    checkEolScanDisabled(override = true) {
-        // Check if running in beta version or pre v1.0.0
-        const version = this.config.version;
-        const [major] = version.split('.').map(Number);
-        if (version.includes('beta') || major < 1) {
-            this.log(`VERSION=${version}`);
-            throw new Error('The EOL scan feature is not available in beta releases. Please wait for the stable release.');
+    displayNoComponentsMessage(all) {
+        if (!all) {
+            this.log(ux.colorize('yellow', 'No End-of-Life or Long Term Support components found in scan.'));
+            this.log(ux.colorize('yellow', 'Use --all flag to view all components.'));
         }
-        // Just in case the beta check fails
-        if (override) {
-            this.log(`VERSION=${version}`);
-            this.log('EOL scan is disabled');
-            return { components: [] };
+        else {
+            this.log(ux.colorize('yellow', 'No components found in scan.'));
         }
     }
+    logLine() {
+        this.log(ux.colorize('bold', '-'.repeat(50)));
+    }
+    displayStatusSection(components) {
+        if (components.length > 0) {
+            this.log(components.join('\n'));
+            this.logLine();
+        }
+    }
+    logLegend() {
+        this.log(ux.colorize(`${STATUS_COLORS.UNKNOWN}`, `${INDICATORS.UNKNOWN} = No Known Issues`));
+        this.log(ux.colorize(`${STATUS_COLORS.OK}`, `${INDICATORS.OK} = OK`));
+        this.log(ux.colorize(`${STATUS_COLORS.LTS}`, `${INDICATORS.LTS}= Long Term Support (LTS)`));
+        this.log(ux.colorize(`${STATUS_COLORS.EOL}`, `${INDICATORS.EOL} = End of Life (EOL)`));
+    }
 }

package/dist/commands/scan/sbom.d.ts

@@ -10,6 +10,7 @@ export default class ScanSbom extends Command {
         save: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         background: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    static loadSbom(flags: Record<string, string>, config: Command['config']): Promise<Sbom>;
     static getSbomArgs(flags: Record<string, string>): string[];
     getScanOptions(): {};
     run(): Promise<Sbom | undefined>;

package/dist/commands/scan/sbom.js

@@ -3,6 +3,7 @@ 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;
@@ -30,6 +31,15 @@ export default class ScanSbom extends Command {
             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, json, background } = flags ?? {};
         const sbomArgs = [];
@@ -37,8 +47,7 @@ export default class ScanSbom extends Command {
             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)
@@ -54,7 +63,7 @@ export default class ScanSbom extends Command {
         const { dir, save, file, background } = flags;
         // Validate that exactly one of --file or --dir is provided
         if (file && dir) {
-            throw new Error('Cannot specify both --file and --dir flags. Please use one or the other.');
+            this.error('Cannot specify both --file and --dir flags. Please use one or the other.');
         }
         let sbom;
         const path = dir || process.cwd();
@@ -76,39 +85,53 @@ export default class ScanSbom extends Command {
     }
     async _getSbomFromScan(_dirFlag) {
         const dir = resolve(_dirFlag);
-        if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
-            throw new Error(`Directory not found or not a directory: ${dir}`);
+        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;
     }
     _getSbomInBackground(path) {
-        const opts = this.getScanOptions();
-        const args = [
-            JSON.stringify({
-                opts,
-                path,
-            }),
-        ];
-        const workerProcess = spawn('node', [join(import.meta.dirname, '../../service/eol/sbom.worker.js'), ...args], {
-            stdio: 'ignore',
-            detached: true,
-            env: { ...process.env },
-        });
-        workerProcess.unref();
+        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();
+        }
+        catch (error) {
+            this.error(`Failed to start background scan: ${getErrorMessage(error)}`);
+        }
     }
     _getSbomFromFile(_fileFlag) {
         const file = resolve(_fileFlag);
-        if (!fs.existsSync(file)) {
-            throw new Error(`SBOM file not found: ${file}`);
-        }
-        ux.action.start(`Loading sbom from ${file}`);
         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',
@@ -118,8 +141,7 @@ 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) {
@@ -131,8 +153,7 @@ export default class ScanSbom extends Command {
             }
         }
         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/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.js

@@ -72,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,7 +1,4 @@
-import { NesApolloClient } from "../../api/nes/nes.client.js";
 import { debugLogger } from "../../service/log.svc.js";
-import { getDaysEolFromEolAt, getStatusFromComponent } from "../line.svc.js";
-import { extractPurls } from "../purls.svc.js";
 import { createBomFromDir } from "./cdx.svc.js";
 export async function createSbom(directory, opts = {}) {
     const sbom = await createBomFromDir(directory, opts.cdxgen || {});
@@ -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
-            debugLogger(`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.js

@@ -1,5 +1,6 @@
 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) => {

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/nes/nes.svc.js

@@ -9,6 +9,7 @@ export const buildScanResult = (scan) => {
         components,
         message: scan.message,
         success: true,
+        warnings: scan.warnings || [],
     };
 };
 export const SbomScanner = (client) => async (purls) => {

package/dist/ui/date.ui.d.ts

@@ -0,0 +1 @@
+export declare function parseMomentToSimpleDate(momentDate: string | Date | number | null): string;