@herodevs/cli 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/service/analytics.svc.js

@@ -0,0 +1,112 @@
+import os from 'node:os';
+import { track as _track, Identify, identify, init, setOptOut, Types } from '@amplitude/analytics-node';
+import NodeMachineId from 'node-machine-id';
+import { config } from "../config/constants.js";
+const device_id = NodeMachineId.machineIdSync(true);
+const started_at = new Date();
+const session_id = started_at.getTime();
+const defaultAnalyticsContext = {
+    locale: Intl.DateTimeFormat().resolvedOptions().locale,
+    os_platform: os.platform(),
+    os_release: os.release(),
+    cli_version: process.env.npm_package_version ?? 'unknown',
+    ci_provider: getCIProvider(),
+    app_used: getTerminal(),
+    started_at,
+};
+let analyticsContext = defaultAnalyticsContext;
+export function initializeAnalytics() {
+    init('0', {
+        flushQueueSize: 2,
+        flushIntervalMillis: 250,
+        logLevel: Types.LogLevel.None,
+        serverUrl: config.analyticsUrl,
+    });
+    setOptOut(process.env.TRACKING_OPT_OUT === 'true');
+    identify(new Identify(), {
+        device_id,
+        platform: analyticsContext.os_platform,
+        os_name: getOSName(analyticsContext.os_platform ?? ''),
+        os_version: analyticsContext.os_release,
+        session_id,
+        app_version: analyticsContext.cli_version,
+    });
+}
+export function track(event, getProperties) {
+    const localContext = getProperties?.(analyticsContext);
+    if (localContext) {
+        analyticsContext = { ...analyticsContext, ...localContext };
+    }
+    return _track(event, localContext, { device_id, session_id });
+}
+function getCIProvider(env = process.env) {
+    if (env.GITHUB_ACTIONS)
+        return 'github';
+    if (env.GITLAB_CI)
+        return 'gitlab';
+    if (env.CIRCLECI)
+        return 'circleci';
+    if (env.TF_BUILD)
+        return 'azure';
+    if (env.BITBUCKET_COMMIT || env.BITBUCKET_BUILD_NUMBER)
+        return 'bitbucket';
+    if (env.JENKINS_URL)
+        return 'jenkins';
+    if (env.BUILDKITE)
+        return 'buildkite';
+    if (env.TRAVIS)
+        return 'travis';
+    if (env.TEAMCITY_VERSION)
+        return 'teamcity';
+    if (env.CODEBUILD_BUILD_ID)
+        return 'codebuild';
+    if (env.CI)
+        return 'unknown_ci';
+    return undefined;
+}
+function getTerminal(env = process.env) {
+    if (env.TERM_PROGRAM === 'vscode' || env.VSCODE_PID)
+        return 'vscode';
+    if (env.TERM_PROGRAM === 'iTerm.app' || env.ITERM_SESSION_ID)
+        return 'iterm';
+    if (env.TERM_PROGRAM === 'Apple_Terminal')
+        return 'apple_terminal';
+    if (env.TERM_PROGRAM === 'WarpTerminal' || env.WARP_IS_LOCAL_SHELL_SESSION)
+        return 'warp';
+    if (env.TERM_PROGRAM === 'ghostty' || env.GHOSTTY_RESOURCES_DIR || env.GHOSTTY_CONFIG_DIR)
+        return 'ghostty';
+    if (env.TERM_PROGRAM === 'WezTerm' || env.WEZTERM_EXECUTABLE || env.WEZTERM_PANE)
+        return 'wezterm';
+    if (env.TERM === 'alacritty' || env.ALACRITTY_LOG || env.ALACRITTY_SOCKET)
+        return 'alacritty';
+    if (env.TERM === 'xterm-kitty' || env.KITTY_WINDOW_ID)
+        return 'kitty';
+    if (env.WT_SESSION || env.WT_PROFILE_ID)
+        return 'windows_terminal';
+    if (env.ConEmuPID || env.ConEmuDir || env.CONEMU_BUILD)
+        return 'conemu';
+    if (env.TERM_PROGRAM === 'mintty' || env.MINTTY_SHORTCUT)
+        return 'mintty';
+    if (env.TILIX_ID)
+        return 'tilix';
+    if (env.GNOME_TERMINAL_SCREEN || env.GNOME_TERMINAL_SERVICE || env.VTE_VERSION)
+        return 'gnome';
+    if (env.KONSOLE_VERSION)
+        return 'konsole';
+    if (env.TERM_PROGRAM === 'Hyper')
+        return 'hyper';
+    return 'unknown_terminal';
+}
+function getOSName(platform) {
+    if (platform === 'darwin')
+        return 'macOS';
+    if (platform === 'win32')
+        return 'Windows';
+    if (platform === 'linux')
+        return 'Linux';
+    if (platform === 'android')
+        return 'Android';
+    if (platform === 'ios')
+        return 'iOS';
+    return platform;
+}

package/dist/service/{eol/cdx.svc.d.ts → cdx.svc.d.ts}

@@ -1,18 +1,4 @@
-import type { CdxGenOptions } from './eol.svc.ts';
-export interface SbomDependency {
-    ref: string;
-    dependsOn: string[];
-}
-export interface SbomEntry {
-    group: string;
-    name: string;
-    purl: string;
-    version: string;
-}
-export interface Sbom {
-    components: SbomEntry[];
-    dependencies: SbomDependency[];
-}
+import type { CdxBom } from '@herodevs/eol-shared';
 export declare const SBOM_DEFAULT__OPTIONS: {
     $0: string;
     _: never[];
@@ -44,6 +30,7 @@ export declare const SBOM_DEFAULT__OPTIONS: {
     o: string;
     output: string;
     outputFormat: string;
+    author: string[];
     profile: string;
     project: undefined;
     'project-version': string;
@@ -61,6 +48,11 @@ export declare const SBOM_DEFAULT__OPTIONS: {
     skipDtTlsCheck: boolean;
     'spec-version': number;
     specVersion: number;
+    tools: {
+        name: string;
+        publisher: string;
+        version: string;
+    }[];
     'usages-slices-file': string;
     usagesSlicesFile: string;
     validate: boolean;
@@ -69,4 +61,4 @@ export declare const SBOM_DEFAULT__OPTIONS: {
  * Lazy loads cdxgen (for ESM purposes), scans
  * `directory`, and returns the `bomJson` property.
  */
-export declare function createBomFromDir(directory: string, opts?: CdxGenOptions): Promise<any>;
+export declare function createSbom(directory: string): Promise<CdxBom>;

package/dist/service/{eol/cdx.svc.js → cdx.svc.js}

@@ -1,5 +1,6 @@
 import { createBom } from '@cyclonedx/cdxgen';
-import { debugLogger } from "../../service/log.svc.js";
+import { debugLogger } from "./log.svc.js";
+const author = process.env.npm_package_author ?? 'HeroDevs, Inc.';
 export const SBOM_DEFAULT__OPTIONS = {
     $0: 'cdxgen',
     _: [],
@@ -23,8 +24,8 @@ export const SBOM_DEFAULT__OPTIONS = {
     includeFormulation: false,
     'no-install-deps': true,
     noInstallDeps: true,
-    'min-confidence': 0,
-    minConfidence: 0,
+    'min-confidence': 1,
+    minConfidence: 1,
     multiProject: true,
     'no-banner': false,
     noBabel: false,
@@ -32,7 +33,7 @@ export const SBOM_DEFAULT__OPTIONS = {
     o: 'bom.json',
     output: 'bom.json',
     outputFormat: 'json', // or "xml"
-    // author: ['OWASP Foundation'],
+    author: [author],
     profile: 'generic',
     project: undefined,
     'project-version': '',
@@ -50,6 +51,13 @@ export const SBOM_DEFAULT__OPTIONS = {
     skipDtTlsCheck: true,
     'spec-version': 1.6,
     specVersion: 1.6,
+    tools: [
+        {
+            name: '@herodevs/cli',
+            publisher: author,
+            version: process.env.npm_package_version ?? 'unknown',
+        },
+    ],
     'usages-slices-file': 'usages.slices.json',
     usagesSlicesFile: 'usages.slices.json',
     validate: true,
@@ -58,8 +66,10 @@ export const SBOM_DEFAULT__OPTIONS = {
  * Lazy loads cdxgen (for ESM purposes), scans
  * `directory`, and returns the `bomJson` property.
  */
-export async function createBomFromDir(directory, opts = {}) {
-    const sbom = await createBom(directory, { ...SBOM_DEFAULT__OPTIONS, ...opts });
+export async function createSbom(directory) {
+    const sbom = await createBom(directory, SBOM_DEFAULT__OPTIONS);
+    if (!sbom)
+        throw new Error('SBOM not generated');
     debugLogger('Successfully generated SBOM');
-    return sbom?.bomJson;
+    return sbom.bomJson;
 }

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

@@ -0,0 +1,30 @@
+import type { ComponentStatus, EolReport } from '@herodevs/eol-shared';
+/**
+ * Formats status row text with appropriate color and icon
+ */
+export declare const getStatusRowText: Record<ComponentStatus, (text: string) => string>;
+export type ComponentCounts = Record<ComponentStatus, number> & {
+    NES_AVAILABLE: number;
+    TOTAL: number;
+    ECOSYSTEMS: string[];
+};
+/**
+ * Counts components by their status, including NES remediation availability
+ */
+export declare function countComponentsByStatus(report: EolReport): ComponentCounts;
+/**
+ * Formats scan results for console display
+ */
+export declare function formatScanResults(report: EolReport): string[];
+/**
+ * Formats web report URL for console display
+ */
+export declare function formatWebReportUrl(id: string, reportCardUrl: string): string[];
+/**
+ * Formats data privacy information link for console display
+ */
+export declare function formatDataPrivacyLink(): string[];
+/**
+ * Formats the report save hint for console display when the web report URL is hidden
+ */
+export declare function formatReportSaveHint(): string[];

package/dist/service/display.svc.js

@@ -0,0 +1,87 @@
+import { deriveComponentStatus } from '@herodevs/eol-shared';
+import { ux } from '@oclif/core';
+import terminalLink from 'terminal-link';
+const STATUS_COLORS = {
+    EOL: 'red',
+    UNKNOWN: 'default',
+    OK: 'green',
+    EOL_UPCOMING: 'yellow',
+};
+const SEPARATOR_WIDTH = 40;
+/**
+ * Formats status row text with appropriate color and icon
+ */
+export const getStatusRowText = {
+    EOL: (text) => ux.colorize(STATUS_COLORS.EOL, `✗ ${text}`),
+    UNKNOWN: (text) => ux.colorize(STATUS_COLORS.UNKNOWN, `• ${text}`),
+    OK: (text) => ux.colorize(STATUS_COLORS.OK, `✔ ${text}`),
+    EOL_UPCOMING: (text) => ux.colorize(STATUS_COLORS.EOL_UPCOMING, `! ${text}`),
+};
+/**
+ * Counts components by their status, including NES remediation availability
+ */
+export function countComponentsByStatus(report) {
+    const grouped = {
+        UNKNOWN: 0,
+        OK: 0,
+        EOL_UPCOMING: 0,
+        EOL: 0,
+        NES_AVAILABLE: 0,
+        ECOSYSTEMS: [],
+        TOTAL: report.components.length,
+    };
+    const ecosystems = new Set();
+    for (const component of report.components) {
+        const status = deriveComponentStatus(component.metadata);
+        grouped[status]++;
+        if (component.nesRemediation?.remediations?.length) {
+            grouped.NES_AVAILABLE++;
+        }
+        const ecosystem = component.purl.match(/^pkg:([^/]+)\//)?.[1];
+        if (ecosystem) {
+            ecosystems.add(ecosystem);
+        }
+    }
+    grouped.ECOSYSTEMS = Array.from(ecosystems);
+    return grouped;
+}
+/**
+ * Formats scan results for console display
+ */
+export function formatScanResults(report) {
+    const { UNKNOWN, OK, EOL_UPCOMING, EOL, NES_AVAILABLE } = countComponentsByStatus(report);
+    if (!UNKNOWN && !OK && !EOL_UPCOMING && !EOL) {
+        return [ux.colorize('yellow', 'No components found in scan.')];
+    }
+    return [
+        ux.colorize('bold', 'Scan results:'),
+        ux.colorize('bold', '-'.repeat(SEPARATOR_WIDTH)),
+        ux.colorize('bold', `${report.components.length.toLocaleString()} total packages scanned`),
+        getStatusRowText.EOL(`${EOL.toLocaleString().padEnd(5)} End-of-Life (EOL)`),
+        getStatusRowText.EOL_UPCOMING(`${EOL_UPCOMING.toLocaleString().padEnd(5)} EOL Upcoming`),
+        getStatusRowText.OK(`${OK.toLocaleString().padEnd(5)} Not End-of-Life (EOL)`),
+        getStatusRowText.UNKNOWN(`${UNKNOWN.toLocaleString().padEnd(5)} Unknown EOL Status`),
+        getStatusRowText.UNKNOWN(`${NES_AVAILABLE.toLocaleString().padEnd(5)} HeroDevs NES Remediation${NES_AVAILABLE !== 1 ? 's' : ''} Available`),
+    ];
+}
+/**
+ * Formats web report URL for console display
+ */
+export function formatWebReportUrl(id, reportCardUrl) {
+    const url = ux.colorize('blue', terminalLink(new URL(reportCardUrl).hostname, `${reportCardUrl}/${id}`, { fallback: (_, url) => url }));
+    return [ux.colorize('bold', '-'.repeat(SEPARATOR_WIDTH)), `🌐 View your full EOL report at: ${url}\n`];
+}
+/**
+ * Formats data privacy information link for console display
+ */
+export function formatDataPrivacyLink() {
+    const privacyUrl = 'https://docs.herodevs.com/eol-ds/data-privacy-and-security';
+    const link = ux.colorize('blue', terminalLink('Learn more about data privacy', privacyUrl, { fallback: (text, url) => `${text}: ${url}` }));
+    return [`🔒 ${link}\n`];
+}
+/**
+ * Formats the report save hint for console display when the web report URL is hidden
+ */
+export function formatReportSaveHint() {
+    return [ux.colorize('bold', '-'.repeat(SEPARATOR_WIDTH)), 'To save your detailed JSON report, use the --save flag'];
+}

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

@@ -0,0 +1,30 @@
+import type { CdxBom, EolReport } from '@herodevs/eol-shared';
+export interface FileError extends Error {
+    code?: string;
+}
+/**
+ * Reads an SBOM from a file path and converts it to CycloneDX format
+ * Supports both SPDX 2.3 and CycloneDX formats
+ */
+export declare function readSbomFromFile(filePath: string): CdxBom;
+/**
+ * Validates that a directory path exists and is actually a directory
+ */
+export declare function validateDirectory(dirPath: string): void;
+type SaveArtifactRequest = {
+    kind: 'sbom';
+    payload: CdxBom;
+    outputPath?: string;
+} | {
+    kind: 'sbomTrimmed';
+    payload: CdxBom;
+} | {
+    kind: 'report';
+    payload: EolReport;
+    outputPath?: string;
+};
+/**
+ * Saves an SBOM, trimmed SBOM, or report to disk using the correct default filename.
+ */
+export declare function saveArtifactToFile(dir: string, request: SaveArtifactRequest): string;
+export {};

package/dist/service/file.svc.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import path, { join, resolve } from 'node:path';
+import { isCdxBom, isSpdxBom, spdxToCdxBom } from '@herodevs/eol-shared';
+import { filenamePrefix } from "../config/constants.js";
+import { getErrorMessage } from "./log.svc.js";
+/**
+ * Computes an absolute output path using either a provided path or the base directory and default name.
+ */
+function resolveOutputPath(baseDir, defaultFilename, customPath) {
+    const defaultOutput = resolve(join(baseDir, defaultFilename));
+    if (!customPath) {
+        return { fileName: defaultFilename, fullPath: defaultOutput };
+    }
+    const resolvedCustomPath = resolve(customPath);
+    let targetPath = resolvedCustomPath;
+    const hasTrailingSeparator = /[\\/]$/.test(customPath);
+    const customIsDirectory = fs.existsSync(resolvedCustomPath) && fs.statSync(resolvedCustomPath).isDirectory();
+    if (hasTrailingSeparator || customIsDirectory) {
+        targetPath = join(resolvedCustomPath, defaultFilename);
+    }
+    return { fileName: path.basename(targetPath), fullPath: targetPath };
+}
+/**
+ * Ensures the output directory for a given path exists, is a directory, and is writable.
+ */
+function ensureOutputDirectory(fullPath, fileName) {
+    const targetDir = path.dirname(fullPath);
+    if (!fs.existsSync(targetDir)) {
+        throw new Error(`Unable to save ${fileName}`);
+    }
+    const stats = fs.statSync(targetDir);
+    if (!stats.isDirectory()) {
+        throw new Error(`Unable to save ${fileName}`);
+    }
+    try {
+        fs.accessSync(targetDir, fs.constants.W_OK);
+    }
+    catch {
+        throw new Error(`Unable to save ${fileName}`);
+    }
+}
+/**
+ * Writes JSON to disk after validating directory constraints and formats the payload for readability.
+ */
+function writeJsonFile(fullPath, fileName, payload, failureLabel) {
+    ensureOutputDirectory(fullPath, fileName);
+    try {
+        fs.writeFileSync(fullPath, JSON.stringify(payload, null, 2));
+        return fullPath;
+    }
+    catch (error) {
+        const fileError = error;
+        switch (fileError.code) {
+            case 'EACCES':
+                throw new Error(`Permission denied. Unable to save ${fileName}`);
+            case 'ENOSPC':
+                throw new Error(`No space left on device. Unable to save ${fileName}`);
+            case 'ENOENT':
+            case 'ENOTDIR':
+                throw new Error(`Unable to save ${fileName}`);
+        }
+        throw new Error(`Failed to save ${failureLabel}: ${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Reads an SBOM from a file path and converts it to CycloneDX format
+ * Supports both SPDX 2.3 and CycloneDX formats
+ */
+export function readSbomFromFile(filePath) {
+    const file = resolve(filePath);
+    if (!fs.existsSync(file)) {
+        throw new Error(`SBOM file not found: ${file}`);
+    }
+    try {
+        const fileContent = fs.readFileSync(file, 'utf8');
+        const jsonContent = JSON.parse(fileContent);
+        if (isSpdxBom(jsonContent)) {
+            return spdxToCdxBom(jsonContent);
+        }
+        if (isCdxBom(jsonContent)) {
+            return jsonContent;
+        }
+        throw new Error(`Invalid SBOM file format. Expected SPDX 2.3 or CycloneDX format.`);
+    }
+    catch (error) {
+        throw new Error(`Failed to read SBOM file: ${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Validates that a directory path exists and is actually a directory
+ */
+export function validateDirectory(dirPath) {
+    const dir = resolve(dirPath);
+    if (!fs.existsSync(dir)) {
+        throw new Error(`Directory not found: ${dir}`);
+    }
+    const stats = fs.statSync(dir);
+    if (!stats.isDirectory()) {
+        throw new Error(`Path is not a directory: ${dir}`);
+    }
+}
+const artifactFilenames = {
+    sbom: `${filenamePrefix}.sbom.json`,
+    sbomTrimmed: `${filenamePrefix}.sbom-trimmed.json`,
+    report: `${filenamePrefix}.report.json`,
+};
+/**
+ * Saves an SBOM, trimmed SBOM, or report to disk using the correct default filename.
+ */
+export function saveArtifactToFile(dir, request) {
+    const defaultFilename = artifactFilenames[request.kind];
+    const customOutputPath = 'outputPath' in request ? request.outputPath : undefined;
+    const { fileName, fullPath } = resolveOutputPath(dir, defaultFilename, customOutputPath);
+    return writeJsonFile(fullPath, fileName, request.payload, fileName);
+}

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

@@ -5,3 +5,4 @@ import debug from 'debug';
  * All user-facing output should be handled by commands.
  */
 export declare const debugLogger: debug.Debugger;
+export declare function getErrorMessage(error: unknown): string;

package/dist/service/log.svc.js

@@ -5,3 +5,12 @@ import debug from 'debug';
  * All user-facing output should be handled by commands.
  */
 export const debugLogger = debug('oclif:herodevs-debug');
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (error && typeof error === 'object') {
+        return JSON.stringify(error);
+    }
+    return String(error) || 'Unknown error';
+}

package/dist/service/{eol/sbom.worker.js → sbom.worker.js}

@@ -1,6 +1,7 @@
 import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { createBom } from '@cyclonedx/cdxgen';
+import { filenamePrefix } from "../config/constants.js";
 import { SBOM_DEFAULT__OPTIONS } from "./cdx.svc.js";
 process.on('uncaughtException', (err) => {
     console.error('Uncaught exception:', err.message);
@@ -15,7 +16,7 @@ try {
     const options = JSON.parse(process.argv[2]);
     const { path, opts } = options;
     const { bomJson } = await createBom(path, { ...SBOM_DEFAULT__OPTIONS, ...opts });
-    const outputPath = join(path, 'eol.sbom.json');
+    const outputPath = join(path, `${filenamePrefix}.sbom.json`);
     writeFileSync(outputPath, JSON.stringify(bomJson, null, 2));
     process.exit(0);
 }

package/dist/utils/strip-typename.d.ts

@@ -0,0 +1 @@
+export declare function stripTypename<T>(obj: T): T;

package/dist/utils/strip-typename.js

@@ -0,0 +1,15 @@
+export function stripTypename(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(stripTypename);
+    }
+    if (obj !== null && typeof obj === 'object') {
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            if (key === '__typename')
+                continue;
+            result[key] = stripTypename(obj[key]);
+        }
+        return result;
+    }
+    return obj;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herodevs/cli",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.11",
   "author": "HeroDevs, Inc",
   "bin": {
     "hd": "./bin/run.js"
@@ -17,18 +17,21 @@
     "ci": "biome ci",
     "ci:fix": "biome check --write",
     "clean": "shx rm -rf dist && npm run clean:files && shx rm -rf node_modules",
-    "clean:files": "shx rm -f eol.**.csv eol.**.json eol.**.text",
+    "clean:files": "shx rm -f herodevs.**.csv herodevs.**.json herodevs.**.txt",
     "dev": "npm run build && ./bin/dev.js",
     "dev:debug": "npm run build && DEBUG=oclif:* ./bin/dev.js",
     "format": "biome format --write",
     "lint": "biome lint --write",
     "postpack": "shx rm -f oclif.manifest.json",
-    "prepack": "oclif manifest && oclif readme",
+    "prepare": "shx test -d dist || npm run build",
+    "prepack": "oclif manifest",
     "pretest": "npm run lint && npm run typecheck",
-    "readme": "npm run ci:fix && npm run build && npm exec oclif readme",
-    "test": "globstar -- node --import tsx --test \"test/**/*.test.ts\"",
+    "readme": "npm run ci:fix && npm run build && oclif readme",
+    "test": "globstar -- node --import tsx --test --experimental-test-module-mocks \"test/**/*.test.ts\"",
     "test:e2e": "globstar -- node --import tsx --test \"e2e/**/*.test.ts\"",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "version": "oclif manifest",
+    "postversion": "node scripts/update-install-script-version.js && git add README.md"
   },
   "keywords": [
     "herodevs",
@@ -36,30 +39,34 @@
     "herodevs cli"
   ],
   "dependencies": {
+    "@amplitude/analytics-node": "^1.5.14",
     "@apollo/client": "^3.13.8",
-    "@cyclonedx/cdxgen": "^11.2.7",
-    "@oclif/core": "^4",
-    "@oclif/plugin-help": "^6",
-    "@oclif/plugin-update": "^4",
-    "@oclif/table": "^0.4.7",
+    "@cyclonedx/cdxgen": "~11.4.4",
+    "@herodevs/eol-shared": "github:herodevs/eol-shared#v0.1.11",
+    "@oclif/core": "^4.5.3",
+    "@oclif/plugin-help": "^6.2.32",
+    "@oclif/plugin-update": "^4.7.8",
     "graphql": "^16.11.0",
+    "node-machine-id": "^1.1.12",
+    "ora": "^8.2.0",
     "packageurl-js": "^2.0.1",
+    "terminal-link": "^5.0.0",
     "update-notifier": "^7.3.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.8.3",
-    "@oclif/test": "^4",
-    "@types/inquirer": "^9.0.8",
-    "@types/node": "^22",
+    "@biomejs/biome": "^2.2.2",
+    "@oclif/test": "^4.1.13",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^24.7.0",
     "@types/sinon": "^17.0.4",
     "@types/update-notifier": "^6.0.8",
     "globstar": "^1.0.0",
-    "oclif": "^4",
+    "oclif": "^4.22.29",
     "shx": "^0.4.0",
-    "sinon": "^20.0.0",
-    "ts-node": "^10",
-    "tsx": "^4.19.4",
-    "typescript": "^5.8.3"
+    "sinon": "^21.0.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">=20.0.0"
@@ -81,8 +88,12 @@
       "@oclif/plugin-update"
     ],
     "hooks": {
-      "init": "./dist/hooks/npm-update-notifier.js",
-      "prerun": "./dist/hooks/prerun.js"
+      "init": [
+        "./dist/hooks/init/00_npm-update-notifier.js",
+        "./dist/hooks/init/01_initialize_amplitude.js"
+      ],
+      "prerun": "./dist/hooks/prerun/prerun.js",
+      "finally": "./dist/hooks/finally/finally.js"
     },
     "topicSeparator": " ",
     "macos": {

package/dist/api/client.d.ts

@@ -1,12 +0,0 @@
-import * as apollo from '@apollo/client/core/index.js';
-export interface ApolloHelper {
-    mutate<T, V extends apollo.OperationVariables>(mutation: apollo.DocumentNode, variables?: V): Promise<apollo.FetchResult<T>>;
-    query<T, V extends apollo.OperationVariables | undefined = undefined>(query: apollo.DocumentNode, variables?: V): Promise<apollo.ApolloQueryResult<T>>;
-}
-export declare const createApollo: (url: string) => apollo.ApolloClient<apollo.NormalizedCacheObject>;
-export declare class ApolloClient implements ApolloHelper {
-    #private;
-    constructor(url: string);
-    mutate<T, V extends apollo.OperationVariables>(mutation: apollo.DocumentNode, variables?: V): Promise<apollo.FetchResult<T>>;
-    query<T, V extends apollo.OperationVariables | undefined>(query: apollo.DocumentNode, variables?: V): Promise<apollo.ApolloQueryResult<T>>;
-}