@pnp/cli-microsoft365 7.3.0-beta.01256d2 → 7.3.0-beta.6062919

package/dist/cli/Cli.js

@@ -1,858 +0,0 @@
-import Configstore from 'configstore';
-import fs from 'fs';
-import minimist from 'minimist';
-import { createRequire } from 'module';
-import ora from 'ora';
-import os from 'os';
-import path from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-import Command, { CommandError } from '../Command.js';
-import config from '../config.js';
-import request from '../request.js';
-import { settingsNames } from '../settingsNames.js';
-import { telemetry } from '../telemetry.js';
-import { app } from '../utils/app.js';
-import { formatting } from '../utils/formatting.js';
-import { md } from '../utils/md.js';
-import { validation } from '../utils/validation.js';
-import { prompt } from '../utils/prompt.js';
-import { timings } from './timings.js';
-const require = createRequire(import.meta.url);
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
-export class Cli {
-    get config() {
-        if (!this._config) {
-            this._config = new Configstore(config.configstoreName);
-        }
-        return this._config;
-    }
-    getSettingWithDefaultValue(settingName, defaultValue) {
-        const configuredValue = this.config.get(settingName);
-        if (typeof configuredValue === 'undefined') {
-            return defaultValue;
-        }
-        else {
-            return configuredValue;
-        }
-    }
-    constructor() {
-        this.commands = [];
-        const options = {
-            text: 'Running command...',
-            /* c8 ignore next 1 */
-            stream: this.getSettingWithDefaultValue('errorOutput', 'stderr') === 'stderr' ? process.stderr : process.stdout
-        };
-        this.spinner = ora(options);
-    }
-    static getInstance() {
-        if (!Cli.instance) {
-            Cli.instance = new Cli();
-        }
-        return Cli.instance;
-    }
-    async execute(rawArgs) {
-        const start = process.hrtime.bigint();
-        // for completion commands we also need information about commands' options
-        const loadAllCommandInfo = rawArgs.indexOf('completion') > -1;
-        this.loadAllCommandsInfo(loadAllCommandInfo);
-        // check if help for a specific command has been requested using the
-        // 'm365 help xyz' format. If so, remove 'help' from the array of words
-        // to use lazy loading commands but keep track of the fact that help should
-        // be displayed
-        let showHelp = false;
-        if (rawArgs.length > 0 && rawArgs[0] === 'help') {
-            showHelp = true;
-            rawArgs.shift();
-        }
-        // parse args to see if a command has been specified
-        const parsedArgs = minimist(rawArgs);
-        // load command
-        await this.loadCommandFromArgs(parsedArgs._);
-        if (this.commandToExecute) {
-            // we have found a command to execute. Parse args again taking into
-            // account short and long options, option types and whether the command
-            // supports known and unknown options or not
-            try {
-                this.optionsFromArgs = {
-                    options: this.getCommandOptionsFromArgs(rawArgs, this.commandToExecute)
-                };
-            }
-            catch (e) {
-                const optionsWithoutShorts = Cli.removeShortOptions({ options: parsedArgs });
-                return this.closeWithError(e.message, optionsWithoutShorts, false);
-            }
-        }
-        else {
-            // we need this to properly support displaying commands
-            // from the current group
-            this.optionsFromArgs = {
-                options: parsedArgs
-            };
-        }
-        // show help if no match found, help explicitly requested or
-        // no command specified
-        if (!this.commandToExecute ||
-            showHelp ||
-            parsedArgs.h ||
-            parsedArgs.help) {
-            if (parsedArgs.output !== 'none') {
-                this.printHelp(await this.getHelpMode(parsedArgs));
-            }
-            return Promise.resolve();
-        }
-        delete this.optionsFromArgs.options._;
-        delete this.optionsFromArgs.options['--'];
-        try {
-            // replace values staring with @ with file contents
-            Cli.loadOptionValuesFromFiles(this.optionsFromArgs);
-        }
-        catch (e) {
-            return this.closeWithError(e, this.optionsFromArgs);
-        }
-        const startProcessing = process.hrtime.bigint();
-        try {
-            // process options before passing them on to validation stage
-            const contextCommandOptions = await this.loadOptionsFromContext(this.commandToExecute.options, this.optionsFromArgs.options.debug);
-            this.optionsFromArgs.options = { ...contextCommandOptions, ...this.optionsFromArgs.options };
-            await this.commandToExecute.command.processOptions(this.optionsFromArgs.options);
-            const endProcessing = process.hrtime.bigint();
-            timings.options.push(Number(endProcessing - startProcessing));
-        }
-        catch (e) {
-            const endProcessing = process.hrtime.bigint();
-            timings.options.push(Number(endProcessing - startProcessing));
-            return this.closeWithError(e.message, this.optionsFromArgs, false);
-        }
-        // if output not specified, set the configured output value (if any)
-        if (this.optionsFromArgs.options.output === undefined) {
-            this.optionsFromArgs.options.output = this.getSettingWithDefaultValue(settingsNames.output, 'json');
-        }
-        const startValidation = process.hrtime.bigint();
-        const validationResult = await this.commandToExecute.command.validate(this.optionsFromArgs, this.commandToExecute);
-        const endValidation = process.hrtime.bigint();
-        timings.validation.push(Number(endValidation - startValidation));
-        if (validationResult !== true) {
-            return this.closeWithError(validationResult, this.optionsFromArgs, true);
-        }
-        const end = process.hrtime.bigint();
-        timings.core.push(Number(end - start));
-        try {
-            await Cli.executeCommand(this.commandToExecute.command, this.optionsFromArgs);
-            const endTotal = process.hrtime.bigint();
-            timings.total.push(Number(endTotal - start));
-            this.printTimings(rawArgs);
-            process.exit(0);
-        }
-        catch (err) {
-            const endTotal = process.hrtime.bigint();
-            timings.total.push(Number(endTotal - start));
-            this.printTimings(rawArgs);
-            await this.closeWithError(err, this.optionsFromArgs);
-            /* c8 ignore next */
-        }
-    }
-    printTimings(rawArgs) {
-        if (rawArgs.some(arg => arg === '--debug')) {
-            Cli.error('');
-            Cli.error('Timings:');
-            Object.getOwnPropertyNames(timings).forEach(key => {
-                Cli.error(`${key}: ${timings[key].reduce((a, b) => a + b, 0) / 1e6}ms`);
-            });
-        }
-    }
-    static async executeCommand(command, args) {
-        const logger = {
-            log: async (message) => {
-                if (args.options.output !== 'none') {
-                    const output = await Cli.formatOutput(command, message, args.options);
-                    Cli.log(output);
-                }
-            },
-            logRaw: async (message) => {
-                if (args.options.output !== 'none') {
-                    Cli.log(message);
-                }
-            },
-            logToStderr: async (message) => {
-                if (args.options.output !== 'none') {
-                    Cli.error(message);
-                }
-            }
-        };
-        if (args.options.debug) {
-            await logger.logToStderr(`Executing command ${command.name} with options ${JSON.stringify(args)}`);
-        }
-        // store the current command name, if any and set the name to the name of
-        // the command to execute
-        const cli = Cli.getInstance();
-        const parentCommandName = cli.currentCommandName;
-        cli.currentCommandName = command.getCommandName(cli.currentCommandName);
-        const showSpinner = cli.getSettingWithDefaultValue(settingsNames.showSpinner, true) && args.options.output !== 'none';
-        // don't show spinner if running tests
-        /* c8 ignore next 3 */
-        if (showSpinner && typeof global.it === 'undefined') {
-            cli.spinner.start();
-        }
-        const startCommand = process.hrtime.bigint();
-        try {
-            await command.action(logger, args);
-            if (args.options.debug || args.options.verbose) {
-                const chalk = (await import('chalk')).default;
-                await logger.logToStderr(chalk.green('DONE'));
-            }
-        }
-        finally {
-            // restore the original command name
-            cli.currentCommandName = parentCommandName;
-            /* c8 ignore next 3 */
-            if (cli.spinner.isSpinning) {
-                cli.spinner.stop();
-            }
-            const endCommand = process.hrtime.bigint();
-            timings.command.push(Number(endCommand - startCommand));
-        }
-    }
-    static async executeCommandWithOutput(command, args, listener) {
-        const log = [];
-        const logErr = [];
-        const logger = {
-            log: async (message) => {
-                const formattedMessage = await Cli.formatOutput(command, message, args.options);
-                if (listener && listener.stdout) {
-                    listener.stdout(formattedMessage);
-                }
-                log.push(formattedMessage);
-            },
-            logRaw: async (message) => {
-                const formattedMessage = await Cli.formatOutput(command, message, args.options);
-                if (listener && listener.stdout) {
-                    listener.stdout(formattedMessage);
-                }
-                log.push(formattedMessage);
-            },
-            logToStderr: async (message) => {
-                if (listener && listener.stderr) {
-                    listener.stderr(message);
-                }
-                logErr.push(message);
-            }
-        };
-        if (args.options.debug && args.options.output !== 'none') {
-            const message = `Executing command ${command.name} with options ${JSON.stringify(args)}`;
-            if (listener && listener.stderr) {
-                listener.stderr(message);
-            }
-            logErr.push(message);
-        }
-        // store the current command name, if any and set the name to the name of
-        // the command to execute
-        const cli = Cli.getInstance();
-        const parentCommandName = cli.currentCommandName;
-        cli.currentCommandName = command.getCommandName();
-        // store the current logger if any
-        const currentLogger = request.logger;
-        try {
-            await command.action(logger, args);
-            return ({
-                stdout: log.join(os.EOL),
-                stderr: logErr.join(os.EOL)
-            });
-        }
-        catch (err) {
-            // restoring the command and logger is done here instead of in a 'finally' because there were issues with the code coverage tool
-            // restore the original command name
-            cli.currentCommandName = parentCommandName;
-            // restore the original logger
-            request.logger = currentLogger;
-            throw {
-                error: err,
-                stderr: logErr.join(os.EOL)
-            };
-        }
-        /* c8 ignore next */
-        finally {
-            // restore the original command name
-            cli.currentCommandName = parentCommandName;
-            // restore the original logger
-            request.logger = currentLogger;
-        }
-    }
-    loadAllCommandsInfo(loadFull = false) {
-        const commandsInfoFileName = loadFull ? 'allCommandsFull.json' : 'allCommands.json';
-        this.commands = require(path.join(__dirname, '..', '..', commandsInfoFileName));
-    }
-    /**
-     * Loads command files into CLI based on the specified arguments.
-     *
-     * @param commandNameWords Array of words specified as args
-    */
-    async loadCommandFromArgs(commandNameWords) {
-        if (commandNameWords.length === 0) {
-            return;
-        }
-        this.currentCommandName = commandNameWords.join(' ');
-        const commandFilePath = this.commands
-            .find(c => c.name === this.currentCommandName ||
-            c.aliases?.find(a => a === this.currentCommandName))?.file ?? '';
-        if (commandFilePath) {
-            await this.loadCommandFromFile(commandFilePath);
-        }
-    }
-    async loadOptionsFromContext(commandOptions, debug) {
-        const filePath = '.m365rc.json';
-        let m365rc = {};
-        if (!fs.existsSync(filePath)) {
-            return;
-        }
-        if (debug) {
-            await Cli.error('found .m365rc.json file');
-        }
-        try {
-            const fileContents = fs.readFileSync(filePath, 'utf8');
-            if (fileContents) {
-                m365rc = JSON.parse(fileContents);
-            }
-        }
-        catch (e) {
-            await this.closeWithError(`Error parsing ${filePath}`, { options: {} });
-            /* c8 ignore next */
-        }
-        if (!m365rc.context) {
-            return;
-        }
-        if (debug) {
-            await Cli.error('found context in .m365rc.json file');
-        }
-        const context = m365rc.context;
-        const foundOptions = {};
-        await commandOptions.forEach(async (option) => {
-            if (context[option.name]) {
-                foundOptions[option.name] = context[option.name];
-                if (debug) {
-                    await Cli.error(`returning ${option.name} option from context`);
-                }
-            }
-        });
-        return foundOptions;
-    }
-    /**
-     * Loads command from the specified file into CLI. If can't find the file
-     * or the file doesn't contain a command, loads all available commands.
-     *
-     * @param commandFilePathUrl File path of the file with command to load
-     */
-    async loadCommandFromFile(commandFileUrl) {
-        const commandsFolder = path.join(__dirname, '../m365');
-        const filePath = path.join(commandsFolder, commandFileUrl);
-        if (!fs.existsSync(filePath)) {
-            // reset command name
-            this.currentCommandName = undefined;
-            return;
-        }
-        try {
-            const command = await import(pathToFileURL(filePath).toString());
-            if (command.default instanceof Command) {
-                const commandInfo = this.commands.find(c => c.file === commandFileUrl);
-                this.commandToExecute = Cli.getCommandInfo(command.default, commandFileUrl, commandInfo?.help);
-            }
-        }
-        catch { }
-    }
-    static getCommandInfo(command, filePath = '', helpFilePath = '') {
-        return {
-            aliases: command.alias(),
-            name: command.name,
-            description: command.description,
-            command: command,
-            options: this.getCommandOptions(command),
-            defaultProperties: command.defaultProperties(),
-            file: filePath,
-            help: helpFilePath
-        };
-    }
-    static getCommandOptions(command) {
-        const options = [];
-        command.options.forEach(option => {
-            const required = option.option.indexOf('<') > -1;
-            const optionArgs = option.option.split(/[ ,|]+/);
-            let short;
-            let long;
-            let name = '';
-            optionArgs.forEach(o => {
-                if (o.startsWith('--')) {
-                    long = o.replace('--', '');
-                    name = long;
-                }
-                else if (o.startsWith('-')) {
-                    short = o.replace('-', '');
-                    name = short;
-                }
-            });
-            options.push({
-                autocomplete: option.autocomplete,
-                long: long,
-                name: name,
-                required: required,
-                short: short
-            });
-        });
-        return options;
-    }
-    getCommandOptionsFromArgs(args, commandInfo) {
-        const minimistOptions = {
-            alias: {}
-        };
-        let argsToParse = args;
-        if (commandInfo) {
-            const commandTypes = commandInfo.command.types;
-            if (commandTypes) {
-                minimistOptions.string = commandTypes.string;
-                // minimist will parse unused boolean options to 'false' (unused options => options that are not included in the args)
-                // But in the CLI booleans are nullable. They can can be true, false or undefined.
-                // For this reason we only pass boolean types that are actually used as arg.
-                minimistOptions.boolean = commandTypes.boolean.filter(optionName => args.some(arg => `--${optionName}` === arg || `-${optionName}` === arg));
-            }
-            minimistOptions.alias = {};
-            commandInfo.options.forEach(option => {
-                if (option.short && option.long) {
-                    minimistOptions.alias[option.short] = option.long;
-                }
-            });
-            argsToParse = this.getRewrittenArgs(args, commandTypes);
-        }
-        return minimist(argsToParse, minimistOptions);
-    }
-    /**
-     * Rewrites arguments (if necessary) before passing them into minimist.
-     * Currently only boolean values are checked and fixed.
-     * Args are only checked and rewritten if the option has been added to the 'types.boolean' array.
-     */
-    getRewrittenArgs(args, commandTypes) {
-        const booleanTypes = commandTypes.boolean;
-        if (booleanTypes.length === 0) {
-            return args;
-        }
-        return args.map((arg, index, array) => {
-            if (arg.startsWith('-') || index === 0) {
-                return arg;
-            }
-            // This line checks if the current arg is a value that belongs to a boolean option.
-            if (booleanTypes.some(t => `--${t}` === array[index - 1] || `-${t}` === array[index - 1])) {
-                const rewrittenBoolean = formatting.rewriteBooleanValue(arg);
-                if (!validation.isValidBoolean(rewrittenBoolean)) {
-                    const optionName = array[index - 1];
-                    throw new Error(`The value '${arg}' for option '${optionName}' is not a valid boolean`);
-                }
-                return rewrittenBoolean;
-            }
-            return arg;
-        });
-    }
-    static async formatOutput(command, logStatement, options) {
-        if (logStatement instanceof Date) {
-            return logStatement.toString();
-        }
-        let logStatementType = typeof logStatement;
-        if (logStatementType === 'undefined') {
-            return logStatement;
-        }
-        // we need to get the list of object's properties to see if the specified
-        // JMESPath query (if any) filters object's properties or not. We need to
-        // know this in order to decide if we should use default command's
-        // properties or custom ones from JMESPath
-        const originalObject = Array.isArray(logStatement) ? Cli.getFirstNonUndefinedArrayItem(logStatement) : logStatement;
-        const originalProperties = originalObject && typeof originalObject !== 'string' ? Object.getOwnPropertyNames(originalObject) : [];
-        if (options.query &&
-            !options.help) {
-            const jmespath = await import('jmespath');
-            try {
-                logStatement = jmespath.search(logStatement, options.query);
-            }
-            catch (e) {
-                const message = `JMESPath query error. ${e.message}. See https://jmespath.org/specification.html for more information`;
-                await Cli.getInstance().closeWithError(message, { options }, false);
-                /* c8 ignore next */
-            }
-            // we need to update the statement type in case the JMESPath query
-            // returns an object of different shape than the original message to log
-            // #2095
-            logStatementType = typeof logStatement;
-        }
-        if (!options.output || options.output === 'json') {
-            return command.getJsonOutput(logStatement);
-        }
-        if (logStatement instanceof CommandError) {
-            const chalk = (await import('chalk')).default;
-            return chalk.red(`Error: ${logStatement.message}`);
-        }
-        let arrayType = '';
-        if (!Array.isArray(logStatement)) {
-            logStatement = [logStatement];
-            arrayType = logStatementType;
-        }
-        else {
-            for (let i = 0; i < logStatement.length; i++) {
-                if (Array.isArray(logStatement[i])) {
-                    arrayType = 'array';
-                    break;
-                }
-                const t = typeof logStatement[i];
-                if (t !== 'undefined') {
-                    arrayType = t;
-                    break;
-                }
-            }
-        }
-        if (arrayType !== 'object') {
-            return logStatement.join(os.EOL);
-        }
-        // if output type has been set to 'text', process the retrieved
-        // data so that returned objects contain only default properties specified
-        // on the current command. If there is no current command or the
-        // command doesn't specify default properties, return original data
-        if (this.shouldTrimOutput(options.output)) {
-            const cli = Cli.getInstance();
-            const currentCommand = cli.commandToExecute;
-            if (arrayType === 'object' &&
-                currentCommand && currentCommand.defaultProperties) {
-                // the log statement contains the same properties as the original object
-                // so it can be filtered following the default properties specified on
-                // the command
-                if (JSON.stringify(originalProperties) === JSON.stringify(Object.getOwnPropertyNames(logStatement[0]))) {
-                    // in some cases we return properties wrapped in `value` array
-                    // returned by the API. We'll remove it in the future, but for now
-                    // we'll use a workaround to drop the `value` array here
-                    if (logStatement[0].value &&
-                        Array.isArray(logStatement[0].value)) {
-                        logStatement = logStatement[0].value;
-                    }
-                    logStatement = logStatement.map((s) => formatting.filterObject(s, currentCommand.defaultProperties));
-                }
-            }
-        }
-        switch (options.output) {
-            case 'csv':
-                return command.getCsvOutput(logStatement, options);
-            case 'md':
-                return command.getMdOutput(logStatement, command, options);
-            default:
-                return command.getTextOutput(logStatement);
-        }
-    }
-    static getFirstNonUndefinedArrayItem(arr) {
-        for (let i = 0; i < arr.length; i++) {
-            const a = arr[i];
-            if (typeof a !== 'undefined') {
-                return a;
-            }
-        }
-        return undefined;
-    }
-    printHelp(helpMode, exitCode = 0) {
-        const properties = {};
-        if (this.commandToExecute) {
-            properties.command = this.commandToExecute.name;
-            this.printCommandHelp(helpMode);
-        }
-        else {
-            Cli.log();
-            Cli.log(`CLI for Microsoft 365 v${app.packageJson().version}`);
-            Cli.log(`${app.packageJson().description}`);
-            Cli.log();
-            properties.command = 'commandList';
-            this.printAvailableCommands();
-        }
-        telemetry.trackEvent('help', properties);
-        process.exit(exitCode);
-    }
-    printCommandHelp(helpMode) {
-        const docsRootDir = path.join(__dirname, '..', '..', 'docs');
-        const helpFilePath = path.join(docsRootDir, 'docs', 'cmd', this.commandToExecute.help);
-        if (fs.existsSync(helpFilePath)) {
-            let helpContents = fs.readFileSync(helpFilePath, 'utf8');
-            helpContents = this.getHelpSection(helpMode, helpContents);
-            helpContents = md.md2plain(helpContents, docsRootDir);
-            Cli.log();
-            Cli.log(helpContents);
-        }
-    }
-    async getHelpMode(options) {
-        const { h, help } = options;
-        if (!h && !help) {
-            return this.getSettingWithDefaultValue(settingsNames.helpMode, Cli.defaultHelpMode);
-        }
-        // user passed -h or --help, let's see if they passed a specific mode
-        // or requested the default
-        const helpMode = h ?? help;
-        if (typeof helpMode === 'boolean' || typeof helpMode !== 'string') {
-            // requested default mode or passed a number, let's use default
-            return this.getSettingWithDefaultValue(settingsNames.helpMode, Cli.defaultHelpMode);
-        }
-        else {
-            const lowerCaseHelpMode = helpMode.toLowerCase();
-            if (Cli.helpModes.indexOf(lowerCaseHelpMode) < 0) {
-                await Cli.getInstance().closeWithError(`Unknown help mode ${helpMode}. Allowed values are ${Cli.helpModes.join(', ')}`, { options }, false);
-                /* c8 ignore next 2 */
-                return ''; // noop
-            }
-            else {
-                return lowerCaseHelpMode;
-            }
-        }
-    }
-    getHelpSection(helpMode, helpContents) {
-        if (helpMode === 'full') {
-            return helpContents;
-        }
-        // options is the first section, so get help up to options
-        const titleAndUsage = helpContents.substring(0, helpContents.indexOf('## Options'));
-        // find the requested section
-        const sectionLines = [];
-        const sectionName = helpMode[0].toUpperCase() + helpMode.substring(1);
-        const lines = helpContents.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (line.indexOf(`## ${sectionName}`) === 0) {
-                sectionLines.push(line);
-            }
-            else if (sectionLines.length > 0) {
-                if (line.indexOf('## ') === 0) {
-                    // we've reached the next section, stop
-                    break;
-                }
-                else {
-                    sectionLines.push(line);
-                }
-            }
-        }
-        return titleAndUsage + sectionLines.join('\n');
-    }
-    printAvailableCommands() {
-        // commands that match the current group
-        const commandsToPrint = {};
-        // sub-commands in the current group
-        const commandGroupsToPrint = {};
-        // current command group, eg. 'spo', 'spo site'
-        let currentGroup = '';
-        const addToList = (commandName, command) => {
-            const pos = commandName.indexOf(' ', currentGroup.length + 1);
-            if (pos === -1) {
-                commandsToPrint[commandName] = command;
-            }
-            else {
-                const subCommandsGroup = commandName.substr(0, pos);
-                if (!commandGroupsToPrint[subCommandsGroup]) {
-                    commandGroupsToPrint[subCommandsGroup] = 0;
-                }
-                commandGroupsToPrint[subCommandsGroup]++;
-            }
-        };
-        // get current command group
-        if (this.optionsFromArgs &&
-            this.optionsFromArgs.options &&
-            this.optionsFromArgs.options._ &&
-            this.optionsFromArgs.options._.length > 0) {
-            currentGroup = this.optionsFromArgs.options._.join(' ');
-            if (currentGroup) {
-                currentGroup += ' ';
-            }
-        }
-        const getCommandsForGroup = () => {
-            for (let i = 0; i < this.commands.length; i++) {
-                const command = this.commands[i];
-                if (command.name.startsWith(currentGroup)) {
-                    addToList(command.name, command);
-                }
-                if (command.aliases) {
-                    for (let j = 0; j < command.aliases.length; j++) {
-                        const alias = command.aliases[j];
-                        if (alias.startsWith(currentGroup)) {
-                            addToList(alias, command);
-                        }
-                    }
-                }
-            }
-        };
-        getCommandsForGroup();
-        if (Object.keys(commandsToPrint).length === 0 &&
-            Object.keys(commandGroupsToPrint).length === 0) {
-            // specified string didn't match any commands. Reset group and try again
-            currentGroup = '';
-            getCommandsForGroup();
-        }
-        const namesOfCommandsToPrint = Object.keys(commandsToPrint);
-        if (namesOfCommandsToPrint.length > 0) {
-            // determine the length of the longest command name to pad strings + ' [options]'
-            const maxLength = Math.max(...namesOfCommandsToPrint.map(s => s.length)) + 10;
-            Cli.log(`Commands:`);
-            Cli.log();
-            const sortedCommandNamesToPrint = Object.getOwnPropertyNames(commandsToPrint).sort();
-            sortedCommandNamesToPrint.forEach(commandName => {
-                Cli.log(`  ${`${commandName} [options]`.padEnd(maxLength, ' ')}  ${commandsToPrint[commandName].description}`);
-            });
-        }
-        const namesOfCommandGroupsToPrint = Object.keys(commandGroupsToPrint);
-        if (namesOfCommandGroupsToPrint.length > 0) {
-            if (namesOfCommandsToPrint.length > 0) {
-                Cli.log();
-            }
-            // determine the longest command group name to pad strings + ' *'
-            const maxLength = Math.max(...namesOfCommandGroupsToPrint.map(s => s.length)) + 2;
-            Cli.log(`Commands groups:`);
-            Cli.log();
-            // sort commands groups (because of aliased commands)
-            const sortedCommandGroupsToPrint = Object
-                .keys(commandGroupsToPrint)
-                .sort()
-                .reduce((object, key) => {
-                object[key] = commandGroupsToPrint[key];
-                return object;
-            }, {});
-            for (const commandGroup in sortedCommandGroupsToPrint) {
-                Cli.log(`  ${`${commandGroup} *`.padEnd(maxLength, ' ')}  ${commandGroupsToPrint[commandGroup]} command${commandGroupsToPrint[commandGroup] === 1 ? '' : 's'}`);
-            }
-        }
-        Cli.log();
-    }
-    async closeWithError(error, args, showHelpIfEnabled = false) {
-        let exitCode = 1;
-        if (args.options.output === 'none') {
-            return process.exit(exitCode);
-        }
-        const chalk = (await import('chalk')).default;
-        let errorMessage = error instanceof CommandError ? error.message : error;
-        if ((!args.options.output || args.options.output === 'json') &&
-            !this.getSettingWithDefaultValue(settingsNames.printErrorsAsPlainText, true)) {
-            errorMessage = JSON.stringify({ error: errorMessage });
-        }
-        else {
-            errorMessage = chalk.red(`Error: ${errorMessage}`);
-        }
-        if (error instanceof CommandError && error.code) {
-            exitCode = error.code;
-        }
-        await Cli.error(errorMessage);
-        if (showHelpIfEnabled &&
-            await this.getSettingWithDefaultValue(settingsNames.showHelpOnFailure, showHelpIfEnabled)) {
-            this.printHelp(await this.getHelpMode(args.options), exitCode);
-        }
-        else {
-            process.exit(exitCode);
-        }
-        // will never be run. Required for testing where we're stubbing process.exit
-        /* c8 ignore next */
-        throw new Error(errorMessage);
-        /* c8 ignore next */
-    }
-    static log(message, ...optionalParams) {
-        const cli = Cli.getInstance();
-        const spinnerSpinning = cli.spinner.isSpinning;
-        /* c8 ignore next 3 */
-        if (spinnerSpinning) {
-            cli.spinner.stop();
-        }
-        if (message) {
-            console.log(message, ...optionalParams);
-        }
-        else {
-            console.log();
-        }
-        // Restart the spinner if it was running before the log
-        /* c8 ignore next 3 */
-        if (spinnerSpinning) {
-            cli.spinner.start();
-        }
-    }
-    static async error(message, ...optionalParams) {
-        const cli = Cli.getInstance();
-        const spinnerSpinning = cli.spinner.isSpinning;
-        /* c8 ignore next 3 */
-        if (spinnerSpinning) {
-            cli.spinner.stop();
-        }
-        const errorOutput = cli.getSettingWithDefaultValue(settingsNames.errorOutput, 'stderr');
-        if (errorOutput === 'stdout') {
-            console.log(message, ...optionalParams);
-        }
-        else {
-            console.error(message, ...optionalParams);
-        }
-        // Restart the spinner if it was running before the log
-        /* c8 ignore next 3 */
-        if (spinnerSpinning) {
-            cli.spinner.start();
-        }
-    }
-    static async promptForSelection(config) {
-        const cli = Cli.getInstance();
-        const spinnerSpinning = cli.spinner.isSpinning;
-        /* c8 ignore next 3 */
-        if (spinnerSpinning) {
-            cli.spinner.stop();
-        }
-        const answer = await prompt.forSelection(config);
-        Cli.error('');
-        // Restart the spinner if it was running before the prompt
-        /* c8 ignore next 3 */
-        if (spinnerSpinning) {
-            cli.spinner.start();
-        }
-        return answer;
-    }
-    static async promptForConfirmation(config) {
-        const cli = Cli.getInstance();
-        const spinnerSpinning = cli.spinner.isSpinning;
-        /* c8 ignore next 3 */
-        if (spinnerSpinning) {
-            cli.spinner.stop();
-        }
-        const answer = await prompt.forConfirmation(config);
-        Cli.error('');
-        // Restart the spinner if it was running before the prompt
-        /* c8 ignore next 3 */
-        if (spinnerSpinning) {
-            cli.spinner.start();
-        }
-        return answer;
-    }
-    static async handleMultipleResultsFound(message, values) {
-        const prompt = Cli.getInstance().getSettingWithDefaultValue(settingsNames.prompt, true);
-        if (!prompt) {
-            throw new Error(`${message} Found: ${Object.keys(values).join(', ')}.`);
-        }
-        Cli.error(`🌶️  ${message}`);
-        const choices = Object.keys(values).map((choice) => { return { name: choice, value: choice }; });
-        const response = await Cli.promptForSelection({ message: `Please choose one:`, choices });
-        return values[response];
-    }
-    static removeShortOptions(args) {
-        const filteredArgs = JSON.parse(JSON.stringify(args));
-        const optionsToRemove = Object.getOwnPropertyNames(args.options)
-            .filter(option => option.length === 1 || option === '--');
-        optionsToRemove.forEach(option => delete filteredArgs.options[option]);
-        return filteredArgs;
-    }
-    static loadOptionValuesFromFiles(args) {
-        const optionNames = Object.getOwnPropertyNames(args.options);
-        optionNames.forEach(option => {
-            const value = args.options[option];
-            if (!value ||
-                typeof value !== 'string' ||
-                !value.startsWith('@')) {
-                return;
-            }
-            const filePath = value.substr(1);
-            // if the file doesn't exist, leave as-is, if it exists replace with
-            // contents from the file
-            if (fs.existsSync(filePath)) {
-                args.options[option] = fs.readFileSync(filePath, 'utf-8');
-            }
-        });
-    }
-    static shouldTrimOutput(output) {
-        return output === 'text';
-    }
-}
-Cli.defaultHelpMode = 'options';
-Cli.helpModes = ['options', 'examples', 'remarks', 'response', 'full'];
-//# sourceMappingURL=Cli.js.map