@aikidosec/ci-api-client 1.0.0

package/.editorconfig

@@ -0,0 +1,18 @@
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{json,iml}]
+indent_style = space
+indent_size = 2
+insert_final_newline = false
+
+[*.{diff,md,markdown}]
+trim_trailing_whitespace = false
+

package/.env

@@ -0,0 +1 @@
+AIKIDO_API=https://app.aikido.dev

package/.prettierrc

@@ -0,0 +1,10 @@
+{
+  "trailingComma": "es5",
+  "printWidth": 80,
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true,
+  "arrowParens": "avoid",
+  "bracketSameLine": false,
+  "bracketSpacing": true
+}

package/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+# Contributing to aikido-api-client
+
+Are you missing functionality or have you found a bug? Please feel free to add an issue or submit a PR. We try to be responsive and release updates and fixes as fast as possible.
+
+## Reporting issues
+
+This package uses the [GitHub Issue Tracker](https://github.com/AikidoSec/aikido-api-client/issues) to track bugs and features. Before submitting a bug report or feature request, check to make sure it hasn't already been submitted.
+
+## Contributing code
+
+If you want to add additional tags, attributes or functionality to the library, please feel free to create a [pull request](https://github.com/AikidoSec/aikido-api-client/pulls) with your changes.
+
+Please try to follow this workflow:
+
+- Fork the project
+- Create a new branch forked from the main branch with a title for your feature (e.g. feature-that-i-want)
+- Commit all your code into this branch until you are happy with your contribution
+- Create a pull request with your commits
+
+## Formatting ⚠️
+
+Please try to follow editor settings provided in `.editorconfig` and `.prettierrc`. If you are using an editor like VS Code your editor should automatically parse these files and auto-format your files on save. If not, you can re-format all source files with the following command:
+
+```sh
+$ yarn format
+```
+
+## Unit testing ⚠️
+
+No unit tests are currently available for the cli tool.

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Aikido Security BV and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# Aikido Security CI API client
+
+<!-- [![NPM Version](http://img.shields.io/npm/v/aikido-api-client.svg?style=flat)](https://www.npmjs.org/package/aikido-api-client)
+[![NPM Downloads](https://img.shields.io/npm/dm/aikido-api-client.svg?style=flat)](https://npmcharts.com/compare/aikido-api-client?minimal=true)
+[![Install Size](https://packagephobia.now.sh/badge?p=aikido-api-client)](https://packagephobia.now.sh/result?p=aikido-api-client) -->
+
+CLI helper for the public [Aikido CI API](https://aikido-dev.notion.site/aikido-dev/Aikido-CI-API-78d318b5f5f7477ab072e12f94b21374). This cli tool can help integrate Aikido into a custom CI pipeline without having to implement the Aikido CI API yourself.
+
+## Installation and setup
+
+The quickest way to get started is to install the cli tool as a global package.
+
+```sh
+# npm users
+$ npm install -g @aikidosec/ci-api-client
+
+# yarn users
+$ yarn global add @aikidosec/ci-api-client
+```
+
+After installation, you'll need to setup your Aikido API key. You can add your key by requesting a token on the [Continuous Integrations page](https://app.aikido.dev/settings/integrations/continuous-integration) in the [Integrations](https://app.aikido.dev/settings/integrations) section of the Aikido web platform. Click the "Start integrating" link and setup your key globally by executing
+
+```sh
+$ aikido-api-client apikey <your-api-key-here>
+```
+
+⚠️ Your Aikido API key is stored in `~/.config/configstore/aikido-api-client.json`. If you don't want this behaviour (e.g. for security related issues), you can also provide your API key to `aikido-api-client` by adding `--apikey <your-api-key-here>` to every command. However, for the examples below, we'll assume you've used `aikido-api-client apikey <your-api-key-here>` to save your API key. If `--apikey` is provided while a key is set in the configuration file on disk, the key that was provided with `--apikey` will be used.
+
+## Usage
+
+Using the `aikido-api-client` to start new scans is very straightforward.
+
+```sh
+$ aikido-api-client scan <repository_id> <base_commit_id> <head_commit_id>
+```
+
+The process will report scan progress and will exit with exitCode `0` if the scan was successfull (`gate_passed: true`). The process will exit with exitCode `10` if the scan was unsuccesfull (`gate_passed: false`). If anything else goes wrong (e.g. API unavailable, scanning unavailable, other unexpected issue) the process will exit with exitCode `1`.
+
+If you want the scan to run quietly (without output), you can add the `--quiet` option to the command.
+
+```sh
+# For more options and combinations, check the help output
+$ aikido-api-client help scan
+```
+
+Uploading custom test results:
+
+```sh
+$ aikido-api-client upload --repository-id <repository_id> --type checkov --file <path_to_payload_file>
+
+# For more options and combinations, check the help output
+$ aikido-api-client help upload
+```
+
+For more information about these parameters, please refer to `aikido-api-client help`, `aikido-api-client help scan` or `aikido-api-client help upload`, or [the public ci api page](https://aikido-dev.notion.site/aikido-dev/Aikido-CI-API-78d318b5f5f7477ab072e12f94b21374).
+
+## Help & contributing
+
+For more information about all available commands and options, execute:
+
+```sh
+$ aikido-api-client help
+```
+
+```sh
+$ aikido-api-client help <command>
+```
+
+If you are missing functionality in this cli tool, please feel free to add it. If you've detected a bug, please submit a PR. Check out [CONTRIBUTING.md](CONTRIBUTING.md) for more information.
+
+
+# Other resources
+
+- [Aikido Official Website](https://aikido.dev)
+- [Aikido Github Actions Workflow](https://github.com/AikidoSec/github-actions-workflow)
+- [Aikido on Twitter](https://twitter.com/AikidoSecurity)
+
+

package/RELEASING.md

@@ -0,0 +1,26 @@
+# Releasing
+
+## Creating a new version
+
+Increment the version of the package by updating the version in `package.json`
+or by updating the package using `npm version`.
+
+```sh
+$ cd aikido-api-client
+$ npm version
+```
+
+## Releasing a new version
+
+Make sure to re-buidl all Typescript files using `yarn build`. Release a new version by publishing the package to npm using `npm publish`.
+
+```sh
+$ cd aikido-api-client
+$ yarn build
+$ npm publish
+```
+
+*or*
+
+Setup the "Publish Node.js Package" action in the aikido-api-client Github.com repo.
+See also: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages

package/lib/aikidoApi.d.ts

@@ -0,0 +1,60 @@
+export type TScanApiOptions = {
+    repository_id?: string | number;
+    base_commit_id?: string;
+    head_commit_id?: string;
+    branch_name?: string;
+    pull_request_metadata?: {
+        title?: string;
+        url?: string;
+    };
+    self_managed_scanners?: string[];
+    fail_on_dependency_scan?: boolean;
+    fail_on_sast_scan?: boolean;
+    fail_on_iac_scan?: boolean;
+    minimum_severity?: string;
+    version: string;
+};
+export type TStartScanResult = {
+    scan_id: number;
+};
+export declare function startScan(data: TScanApiOptions): Promise<TStartScanResult>;
+export type TPollIsScanningResult = {
+    all_scans_completed: boolean;
+    dependency_scan_completed: boolean;
+    sast_scan_completed: boolean;
+    iac_scan_completed: boolean;
+    sbom_scan_completed?: boolean;
+};
+type TPollScanCompletedOptions = {
+    gate_passed: boolean;
+};
+type TPollScanFeatureBranchCompletedOptions = {
+    new_issues_found: number;
+    new_dependency_issues_found: number;
+    new_sast_issues_found: number;
+    new_iac_issues_found: number;
+    diff_url: string;
+};
+type TPollScanDefaultBranchCompletedOptions = {
+    open_issues_found: number;
+    issue_links: string[];
+};
+export type TPollScanFeatureBranchCompletedResult = TPollIsScanningResult & TPollScanCompletedOptions & TPollScanFeatureBranchCompletedOptions;
+export type TPollScanCompletedDefaultBranchResult = TPollIsScanningResult & TPollScanCompletedOptions & TPollScanDefaultBranchCompletedOptions;
+export declare function pollScanStatus(scanId: number): Promise<TPollIsScanningResult | TPollScanFeatureBranchCompletedResult | TPollScanCompletedDefaultBranchResult>;
+export declare enum TUploadPayloadType {
+    Checkov = "checkov",
+    JsonSbom = "json-sbom"
+}
+export type TUploadApiOptions = {
+    scan_id?: number;
+    repository_id: string | number;
+    container_image_name?: string;
+    payload_type: TUploadPayloadType;
+    payload: string;
+};
+export type TUploadResult = {
+    success: number;
+};
+export declare function uploadCustomScanResult(data: TUploadApiOptions): Promise<TUploadResult>;
+export {};

package/lib/aikidoApi.js

@@ -0,0 +1,52 @@
+import axios from 'axios';
+import { getApiKey } from './configuration.js';
+import { outputDebug } from './output.js';
+const getApiUrl = () => process.env.AIKIDO_API || 'https://app.aikido.dev';
+const getApiHeaders = () => ({
+    'Content-Type': 'application/json',
+    'X-AIK-API-SECRET': getApiKey(),
+});
+export async function startScan(data) {
+    const requestUrl = `${getApiUrl()}/api/integrations/continuous_integration/scan/repository`;
+    const requestConfig = {
+        method: 'POST',
+        data,
+        headers: getApiHeaders(),
+    };
+    outputDebug(`API request: ${requestUrl}`);
+    outputDebug(requestConfig);
+    const resultData = (await axios(requestUrl, requestConfig)).data;
+    outputDebug(resultData);
+    return resultData;
+}
+export async function pollScanStatus(scanId) {
+    const requestUrl = `${getApiUrl()}/api/integrations/continuous_integration/scan/repository`;
+    const requestConfig = {
+        method: 'GET',
+        params: { scan_id: scanId },
+        headers: getApiHeaders(),
+    };
+    outputDebug(`API request: ${requestUrl}`);
+    outputDebug(requestConfig);
+    const resultData = (await axios(requestUrl, requestConfig)).data;
+    outputDebug(resultData);
+    return resultData;
+}
+export var TUploadPayloadType;
+(function (TUploadPayloadType) {
+    TUploadPayloadType["Checkov"] = "checkov";
+    TUploadPayloadType["JsonSbom"] = "json-sbom";
+})(TUploadPayloadType || (TUploadPayloadType = {}));
+export async function uploadCustomScanResult(data) {
+    const requestUrl = `${getApiUrl()}/api/integrations/continuous_integration/scan/custom`;
+    const requestConfig = {
+        method: 'POST',
+        data,
+        headers: getApiHeaders(),
+    };
+    outputDebug(`API request: ${requestUrl}`);
+    outputDebug(requestConfig);
+    const resultData = (await axios(requestUrl, requestConfig)).data;
+    outputDebug(resultData);
+    return resultData;
+}

package/lib/commands/apiKey.d.ts

@@ -0,0 +1,8 @@
+import { Command } from 'commander';
+declare function cli(apiKey: string): void;
+export declare const cliSetup: (program: Command) => Command;
+declare const _default: {
+    cli: typeof cli;
+    cliSetup: (program: Command) => Command;
+};
+export default _default;

package/lib/commands/apiKey.js

@@ -0,0 +1,18 @@
+import { Argument } from 'commander';
+import { setApiKey } from '../configuration.js';
+import { outputError, outputLog } from '../output.js';
+function cli(apiKey) {
+    if (apiKey && apiKey.trim().length != 128) {
+        outputError('That does not seem right, please verify your api key');
+    }
+    setApiKey(apiKey);
+    outputLog(apiKey
+        ? 'Your new Aikido API key has been set'
+        : 'Your Aikido API key has been removed');
+}
+export const cliSetup = (program) => program
+    .command('apikey')
+    .addArgument(new Argument('<key>', 'Your Aikido public CI API key. See also: https://app.aikido.dev/settings/integrations/continuous-integration. To remove your apikey, leave the <key> argument value empty.').argOptional())
+    .description('Set (or remove) your Aikido public CI API key.')
+    .action(cli);
+export default { cli, cliSetup };

package/lib/commands/scan.d.ts

@@ -0,0 +1,36 @@
+import { Command } from 'commander';
+import { TPollIsScanningResult, TPollScanCompletedDefaultBranchResult, TPollScanFeatureBranchCompletedResult, TScanApiOptions } from '../aikidoApi.js';
+type TScanArguments = {
+    repoId: string | number;
+    baseCommitId: string;
+    headCommitId: string;
+    branchName: string;
+    options: TScanApiOptions;
+    pollInterval: number;
+    onStart?: () => void | null;
+    onStartComplete?: (startResult: any) => void | null;
+    onStartFail?: (error: any) => void | null;
+    onScanStart?: (startResult: TPollIsScanningResult | TPollScanFeatureBranchCompletedResult | TPollScanCompletedDefaultBranchResult) => void | null;
+    onNextPoll?: (pollResult: TPollIsScanningResult | TPollScanFeatureBranchCompletedResult | TPollScanCompletedDefaultBranchResult) => void | null;
+    onScanComplete?: (pollResult: TPollIsScanningResult | TPollScanFeatureBranchCompletedResult | TPollScanCompletedDefaultBranchResult) => void | null;
+    onScanFail?: (error: any) => void | null;
+};
+type TScanUserCliOptions = {
+    pullRequestTitle?: string;
+    pullRequestUrl?: string;
+    selfManagedScanners?: string[];
+    failOnDependencyScan?: boolean;
+    failOnSastScan?: boolean;
+    failOnIacScan?: boolean;
+    minimumSeverityLevel?: string;
+    pollInterval?: number;
+};
+declare function cli(repoId: string, baseCommitId: string, headCommitId: string, branchName: string, options: TScanUserCliOptions, command: string): Promise<void>;
+export declare const scan: ({ repoId, baseCommitId, headCommitId, branchName, options, pollInterval, onStart, onStartComplete, onStartFail, onScanStart, onNextPoll, onScanComplete, onScanFail, }: TScanArguments) => Promise<void>;
+export declare const cliSetup: (program: Command) => Command;
+declare const _default: {
+    cli: typeof cli;
+    cliSetup: (program: Command) => Command;
+    scan: ({ repoId, baseCommitId, headCommitId, branchName, options, pollInterval, onStart, onStartComplete, onStartFail, onScanStart, onNextPoll, onScanComplete, onScanFail, }: TScanArguments) => Promise<void>;
+};
+export default _default;

package/lib/commands/scan.js

@@ -0,0 +1,188 @@
+import { Argument, InvalidArgumentError, Option } from 'commander';
+import { pollScanStatus, startScan, } from '../aikidoApi.js';
+import { getApiKey } from '../configuration.js';
+import { outputError, outputHttpError, outputLog, startSpinner, } from '../output.js';
+import chalk from 'chalk';
+async function cli(repoId, baseCommitId, headCommitId, branchName, options, command) {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        outputError('Please set an api key using: aikido-cli apikey <key>');
+    }
+    const { apiOptions, cliOptions } = parseCliOptions(options);
+    let loader;
+    let pollCount = 1;
+    const onStart = () => {
+        loader = startSpinner('Starting Aikido Security scan');
+    };
+    const onStartComplete = (startResult) => {
+        loader?.succeed(`Aikido Security scan started (id: ${startResult.scan_id})`);
+    };
+    const onNextPoll = () => {
+        if (loader) {
+            loader.text = `Polling for Aikido Security scan to complete (${pollCount})`;
+        }
+        pollCount += 1;
+    };
+    const onScanStart = () => {
+        loader = startSpinner('Waiting for scan to complete');
+    };
+    const onScanComplete = (pollResult) => {
+        if (pollResult.gate_passed === true) {
+            loader?.succeed('Scan completed, no new issues found');
+        }
+        else {
+            loader?.fail('Scan completed with issues');
+            if (pollResult.open_issues_found) {
+                outputLog(chalk.gray(chalk.bold('Open issues found: ') + pollResult.open_issues_found));
+            }
+            if (pollResult.issue_links) {
+                outputLog(chalk.gray(pollResult.issue_links
+                    .map((issueLink) => '- ' + issueLink)
+                    .join('\n')));
+            }
+            if (pollResult.diff_url) {
+                outputLog(chalk.gray(`* Diff url: ${pollResult.diff_url}`));
+            }
+            process.exit(10);
+        }
+    };
+    const onFail = (error) => {
+        loader?.fail();
+        if (error.response?.status && error.response?.status === 404) {
+            outputError('Please verify your repoId, baseCommitId, headCommitId and branchName');
+        }
+        else {
+            outputHttpError(error);
+        }
+        process.exit(1);
+    };
+    await scan({
+        repoId,
+        baseCommitId,
+        headCommitId,
+        branchName,
+        options: apiOptions,
+        pollInterval: cliOptions.pollInterval,
+        onStart,
+        onStartComplete,
+        onStartFail: onFail,
+        onNextPoll,
+        onScanStart,
+        onScanComplete,
+        onScanFail: onFail,
+    });
+}
+export const scan = async ({ repoId, baseCommitId, headCommitId, branchName, options, pollInterval = 5, onStart, onStartComplete, onStartFail, onScanStart, onNextPoll, onScanComplete, onScanFail, }) => {
+    onStart?.();
+    let result = null;
+    try {
+        result = await startScan({
+            repository_id: repoId,
+            base_commit_id: baseCommitId,
+            head_commit_id: headCommitId,
+            branch_name: branchName,
+            ...options,
+        });
+        if (result.scan_id) {
+            onStartComplete?.(result);
+        }
+        else {
+            onStartFail?.(result);
+            return;
+        }
+    }
+    catch (error) {
+        onStartFail?.(error);
+        return;
+    }
+    onScanStart?.(result);
+    let pollResult;
+    const pollStatus = async () => {
+        try {
+            pollResult = await pollScanStatus(result.scan_id);
+            if (pollResult.all_scans_completed === false) {
+                onNextPoll?.(pollResult);
+                setTimeout(pollStatus, pollInterval * 1000);
+            }
+            else {
+                onScanComplete?.(pollResult);
+            }
+        }
+        catch (error) {
+            onScanFail?.(error);
+        }
+    };
+    pollStatus();
+};
+const parseCliOptions = (userCliOptions) => {
+    const apiOptions = { version: '1.0.5' };
+    const cliOptions = { pollInterval: 5 };
+    if (userCliOptions.pullRequestTitle) {
+        apiOptions.pull_request_metadata = {
+            ...(apiOptions.pull_request_metadata ?? {}),
+            title: userCliOptions.pullRequestTitle,
+        };
+    }
+    if (userCliOptions.pullRequestUrl) {
+        apiOptions.pull_request_metadata = {
+            ...(apiOptions.pull_request_metadata ?? {}),
+            url: userCliOptions.pullRequestUrl,
+        };
+    }
+    if (userCliOptions.selfManagedScanners) {
+        apiOptions.self_managed_scanners = userCliOptions.selfManagedScanners;
+    }
+    if (userCliOptions.failOnDependencyScan != undefined) {
+        apiOptions.fail_on_dependency_scan = userCliOptions.failOnDependencyScan;
+    }
+    if (userCliOptions.failOnSastScan != undefined) {
+        apiOptions.fail_on_sast_scan = userCliOptions.failOnSastScan;
+    }
+    if (userCliOptions.failOnIacScan != undefined) {
+        apiOptions.fail_on_iac_scan = userCliOptions.failOnIacScan;
+    }
+    if (userCliOptions.minimumSeverityLevel) {
+        apiOptions.minimum_severity = userCliOptions.minimumSeverityLevel;
+    }
+    if (userCliOptions.pollInterval &&
+        (isNaN(userCliOptions.pollInterval) || userCliOptions.pollInterval <= 0)) {
+        outputError('Please provide a valid poll interval');
+    }
+    else if (userCliOptions.pollInterval) {
+        cliOptions.pollInterval = userCliOptions.pollInterval;
+    }
+    return { apiOptions, cliOptions };
+};
+const validateCommitId = (value) => {
+    const testCommitId = (commitId) => commitId.length === 40 && /^[0-9a-f]{40}$/.test(commitId);
+    if (testCommitId(value) === false) {
+        throw new InvalidArgumentError('Please provide a valid commit ID');
+    }
+    return value;
+};
+export const cliSetup = (program) => program
+    .command('scan')
+    .addArgument(new Argument('<repository_id>', 'The internal GitHub/Gitlab/Bitbucket/.. repository id you want to scan.').argRequired())
+    .addArgument(new Argument('<base_commit_id>', 'The base commit of the code you want to scan (e.g. the commit where you branched from for your PR or the initial commit of your repo)')
+    .argRequired()
+    .argParser(validateCommitId))
+    .addArgument(new Argument('<head_commit_id>', 'The latest commit you want to include in your scan (e.g. the latest commit id of your pull request)')
+    .argRequired()
+    .argParser(validateCommitId))
+    .addArgument(new Argument('<branch_name>', 'The branch name')
+    .argOptional()
+    .default('main'))
+    .option('--pull-request-title <title>', 'Your pull request title')
+    .option('--pull-request-url <url>', 'Your pull request URL')
+    .addOption(new Option('--self-managed-scanners <scanners...>', 'Set the minimum severity level. Accepted options are: LOW, MEDIUM, HIGH and CRITICAL.').choices(['checkov', 'json-sbom']))
+    .option('--expected-amount-json-sboms <amount>', 'The expected amount of json sbombs')
+    .addOption(new Option('--no-fail-on-dependency-scan', "Don't fail when scanning depedencies..."))
+    .option('--fail-on-sast-scan', 'Let Aikido fail when new static code analysis issues have been detected...')
+    .option('--fail-on-iac-scan', 'Let Aikido fail when new infrastructure as code issues have been detected...')
+    .addOption(new Option('--minimum-severity-level <level>', 'Set the minimum severity level. Accepted options are: LOW, MEDIUM, HIGH and CRITICAL.').choices(['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']))
+    .addOption(new Option('--poll-interval [interval]', 'The poll interval when checking for an updated scan result')
+    .preset(5)
+    .argParser(parseFloat))
+    .description('Run a scan of an Aikido repo.')
+    .action(cli);
+export default { cli, cliSetup, scan };

package/lib/commands/upload.d.ts

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { TUploadApiOptions, TUploadPayloadType, TUploadResult } from '../aikidoApi.js';
+type TUploadArguments = {
+    data: TUploadApiOptions;
+    onUploadComplete?: (startResult: TUploadResult) => void | null;
+    onUploadFail?: (error: any) => void | null;
+};
+type TUploadUserCliOptions = {
+    scanId?: string | number;
+    repositoryId: string | number;
+    containerImage?: string;
+    type: TUploadPayloadType;
+    file?: string;
+    payload?: string;
+};
+declare function cli(options: TUploadUserCliOptions, command: string): Promise<void>;
+export declare const upload: ({ data, onUploadComplete, onUploadFail, }: TUploadArguments) => Promise<void>;
+export declare const cliSetup: (program: Command) => Command;
+declare const _default: {
+    cli: typeof cli;
+    cliSetup: (program: Command) => Command;
+};
+export default _default;