@pnp/cli-microsoft365 7.2.0-beta.194fd07 → 7.2.0-beta.41f58dd

package/dist/Auth.js

@@ -341,7 +341,7 @@ export class Auth {
         const cli = Cli.getInstance();
         cli.spinner.text = response.message;
         cli.spinner.spinner = {
-            frames: ['🌶️']
+            frames: ['🌶️ ']
         };
         // don't show spinner if running tests
         /* c8 ignore next 3 */

package/dist/Command.js

@@ -89,11 +89,8 @@ class Command {
                 prompted = true;
                 Cli.error('🌶️  Provide values for the following parameters:');
             }
-            const missingRequireOptionValue = await prompt.forInput({
-                name: 'missingRequireOptionValue',
-                message: `${command.options[i].name}: `
-            }).then(result => result.missingRequireOptionValue);
-            args.options[command.options[i].name] = missingRequireOptionValue;
+            const answer = await prompt.forInput({ message: `${command.options[i].name}: ` });
+            args.options[command.options[i].name] = answer;
         }
         if (prompted) {
             Cli.error('');
@@ -130,29 +127,15 @@ class Command {
     }
     async promptForOptionSetNameAndValue(args, optionSet) {
         Cli.error(`🌶️  Please specify one of the following options:`);
-        const resultOptionName = await prompt.forInput({
-            type: 'list',
-            name: 'missingRequiredOptionName',
-            message: `Option to use:`,
-            choices: optionSet.options
-        });
-        const missingRequiredOptionName = resultOptionName.missingRequiredOptionName;
-        const resultOptionValue = await prompt.forInput({
-            name: 'missingRequiredOptionValue',
-            message: `${missingRequiredOptionName}:`
-        });
-        args.options[missingRequiredOptionName] = resultOptionValue.missingRequiredOptionValue;
+        const selectedOptionName = await prompt.forSelection({ message: `Option to use:`, choices: optionSet.options.map((choice) => { return { name: choice, value: choice }; }) });
+        const optionValue = await prompt.forInput({ message: `${selectedOptionName}:` });
+        args.options[selectedOptionName] = optionValue;
         Cli.error('');
     }
     async promptForSpecificOption(args, commonOptions) {
         Cli.error(`🌶️  Multiple options for an option set specified. Please specify the correct option that you wish to use.`);
-        const requiredOptionNameResult = await prompt.forInput({
-            type: 'list',
-            name: 'missingRequiredOptionName',
-            message: `Option to use:`,
-            choices: commonOptions
-        });
-        commonOptions.filter(y => y !== requiredOptionNameResult.missingRequiredOptionName).map(optionName => args.options[optionName] = undefined);
+        const selectedOptionName = await prompt.forSelection({ message: `Option to use:`, choices: commonOptions.map((choice) => { return { name: choice, value: choice }; }) });
+        commonOptions.filter(y => y !== selectedOptionName).map(optionName => args.options[optionName] = undefined);
         Cli.error('');
     }
     async validateOutput(args) {

package/dist/api.js

@@ -1,13 +1,11 @@
 import { Cli } from "./cli/Cli.js";
-import path from 'path';
-export function executeCommand(commandName, options, listener) {
+export async function executeCommand(commandName, options, listener) {
     const cli = Cli.getInstance();
-    cli.commandsFolder = path.join(__dirname, 'm365');
-    cli.commands = [];
-    cli.loadCommandFromArgs(commandName.split(' '));
-    if (cli.commands.length !== 1) {
+    cli.loadAllCommandsInfo();
+    await cli.loadCommandFromArgs(commandName.split(' '));
+    if (!cli.commandToExecute) {
         return Promise.reject(`Command not found: ${commandName}`);
     }
-    return Cli.executeCommandWithOutput(cli.commands[0].command, { options: options ?? {} }, listener);
+    return Cli.executeCommandWithOutput(cli.commandToExecute.command, { options: options ?? {} }, listener);
 }
 //# sourceMappingURL=api.js.map

package/dist/chili/chili.js

@@ -1,5 +1,4 @@
 import fs from 'fs';
-import inquirer from 'inquirer';
 import ora from 'ora';
 import path from 'path';
 import url from 'url';
@@ -7,6 +6,7 @@ import { Cli } from '../cli/Cli.js';
 import request from '../request.js';
 import { settingsNames } from '../settingsNames.js';
 import { md } from '../utils/md.js';
+import { prompt } from '../utils/prompt.js';
 const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
 const mendableApiKey = 'd3313d54-6f8e-40e0-90d3-4095019d4be7';
 let showHelp = false;
@@ -79,12 +79,7 @@ async function startConversation(args) {
     await runConversationTurn(conversationId, initialPrompt);
 }
 async function promptForPrompt() {
-    const answer = await inquirer.prompt([{
-            type: 'input',
-            name: 'prompt',
-            message: '🌶️  How can I help you?'
-        }]);
-    return answer.prompt;
+    return await prompt.forInput({ message: '🌶️  How can I help you?' });
 }
 async function runConversationTurn(conversationId, question) {
     console.log('');
@@ -120,60 +115,54 @@ async function runConversationTurn(conversationId, question) {
         }
         console.log('');
     }
-    const result = await inquirer.prompt([{
-            type: 'list',
-            name: 'chat',
-            message: 'What would you like to do next?',
-            choices: [
-                {
-                    name: '📝 I want to know more',
-                    value: 'ask'
-                },
-                {
-                    name: '👋 I know enough. Thanks!',
-                    value: 'end'
-                },
-                {
-                    name: '🔄 I want to ask about something else',
-                    value: 'new'
-                }
-            ]
-        }]);
-    switch (result.chat) {
+    const choices = [
+        {
+            name: '📝 I want to know more',
+            value: 'ask'
+        },
+        {
+            name: '👋 I know enough. Thanks!',
+            value: 'end'
+        },
+        {
+            name: '🔄 I want to ask about something else',
+            value: 'new'
+        }
+    ];
+    const result = await prompt.forSelection({ message: 'What would you like to do next?', choices });
+    switch (result) {
         case 'ask':
             const prompt = await promptForPrompt();
-            return await runConversationTurn(conversationId, prompt);
+            await runConversationTurn(conversationId, prompt);
+            break;
         case 'end':
             await endConversation(conversationId);
             console.log('');
             console.log('🌶️   Bye!');
-            return;
+            break;
         case 'new':
             initialPrompt = '';
-            return startConversation([]);
+            await startConversation([]);
+            break;
     }
 }
 async function rateResponse(messageId) {
-    const result = await inquirer.prompt([{
-            type: 'list',
-            name: 'rating',
-            message: 'Was this helpful?',
-            choices: [
-                {
-                    name: '👍 Yes',
-                    value: 1
-                },
-                {
-                    name: '👎 No',
-                    value: -1
-                },
-                {
-                    name: '🤔 Not sure/skip',
-                    value: 0
-                }
-            ]
-        }]);
-    if (result.rating === 0) {
+    const choices = [
+        {
+            name: '👍 Yes',
+            value: 1
+        },
+        {
+            name: '👎 No',
+            value: -1
+        },
+        {
+            name: '🤔 Not sure/skip',
+            value: 0
+        }
+    ];
+    const rating = await prompt.forSelection({ message: 'Was this helpful?', choices });
+    if (rating === 0) {
         return;
     }
     console.log('Thanks for letting us know! 😊');
@@ -192,7 +181,7 @@ async function rateResponse(messageId) {
             // eslint-disable-next-line camelcase
             message_id: messageId,
             // eslint-disable-next-line camelcase
-            rating_value: result.rating
+            rating_value: rating
         }
     };
     const spinner = ora('Sending rating...');

package/dist/cli/Cli.js

@@ -1,10 +1,11 @@
 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 { pathToFileURL } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import Command, { CommandError } from '../Command.js';
 import config from '../config.js';
 import request from '../request.js';
@@ -12,10 +13,12 @@ import { settingsNames } from '../settingsNames.js';
 import { telemetry } from '../telemetry.js';
 import { app } from '../utils/app.js';
 import { formatting } from '../utils/formatting.js';
-import { fsUtil } from '../utils/fsUtil.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) {
@@ -34,7 +37,6 @@ export class Cli {
     }
     constructor() {
         this.commands = [];
-        this.commandsFolder = '';
         const options = {
             text: 'Running command...',
             /* c8 ignore next 1 */
@@ -48,8 +50,11 @@ export class Cli {
         }
         return Cli.instance;
     }
-    async execute(commandsFolder, rawArgs) {
-        this.commandsFolder = commandsFolder;
+    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
@@ -59,22 +64,10 @@ export class Cli {
             showHelp = true;
             rawArgs.shift();
         }
-        // parse args to see if a command has been specified and can be loaded
-        // rather than loading all commands
+        // parse args to see if a command has been specified
         const parsedArgs = minimist(rawArgs);
-        // load commands
+        // load command
         await this.loadCommandFromArgs(parsedArgs._);
-        if (this.currentCommandName) {
-            for (let i = 0; i < this.commands.length; i++) {
-                const command = this.commands[i];
-                if (command.name === this.currentCommandName ||
-                    (command.aliases &&
-                        command.aliases.indexOf(this.currentCommandName) > -1)) {
-                    this.commandToExecute = command;
-                    break;
-                }
-            }
-        }
         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
@@ -90,6 +83,8 @@ export class Cli {
             }
         }
         else {
+            // we need this to properly support displaying commands
+            // from the current group
             this.optionsFromArgs = {
                 options: parsedArgs
             };
@@ -113,26 +108,56 @@ export class Cli {
         catch (e) {
             return this.closeWithError(e, optionsWithoutShorts);
         }
+        const startProcessing = process.hrtime.bigint();
         try {
             // process options before passing them on to validation stage
             const contextCommandOptions = await this.loadOptionsFromContext(this.commandToExecute.options, optionsWithoutShorts.options.debug);
             optionsWithoutShorts.options = { ...contextCommandOptions, ...optionsWithoutShorts.options };
             await this.commandToExecute.command.processOptions(optionsWithoutShorts.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, optionsWithoutShorts, false);
         }
         // if output not specified, set the configured output value (if any)
         if (optionsWithoutShorts.options.output === undefined) {
             optionsWithoutShorts.options.output = this.getSettingWithDefaultValue(settingsNames.output, 'json');
         }
+        const startValidation = process.hrtime.bigint();
         const validationResult = await this.commandToExecute.command.validate(optionsWithoutShorts, this.commandToExecute);
+        const endValidation = process.hrtime.bigint();
+        timings.validation.push(Number(endValidation - startValidation));
         if (validationResult !== true) {
             return this.closeWithError(validationResult, optionsWithoutShorts, true);
         }
-        return Cli
-            .executeCommand(this.commandToExecute.command, optionsWithoutShorts)
-            .then(_ => process.exit(0), err => this.closeWithError(err, optionsWithoutShorts));
+        const end = process.hrtime.bigint();
+        timings.core.push(Number(end - start));
+        try {
+            await Cli.executeCommand(this.commandToExecute.command, optionsWithoutShorts);
+            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, optionsWithoutShorts);
+            /* 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 = {
@@ -167,6 +192,7 @@ export class Cli {
         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) {
@@ -181,6 +207,8 @@ export class Cli {
             if (cli.spinner.isSpinning) {
                 cli.spinner.stop();
             }
+            const endCommand = process.hrtime.bigint();
+            timings.command.push(Number(endCommand - startCommand));
         }
     }
     static async executeCommandWithOutput(command, args, listener) {
@@ -248,55 +276,26 @@ export class Cli {
             request.logger = currentLogger;
         }
     }
-    async loadAllCommands() {
-        const files = fsUtil.readdirR(this.commandsFolder);
-        await Promise.all(files.map(async (filePath) => {
-            const file = pathToFileURL(filePath).toString();
-            if (file.indexOf(`/commands/`) > -1 &&
-                file.indexOf(`/assets/`) < 0 &&
-                file.endsWith('.js') &&
-                !file.endsWith('.spec.js')) {
-                try {
-                    const command = await import(file);
-                    if (command.default instanceof Command) {
-                        this.loadCommand(command.default);
-                    }
-                }
-                catch (e) {
-                    this.closeWithError(e, { options: {} });
-                }
-            }
-        }));
+    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) {
-        this.currentCommandName = commandNameWords.join(' ');
         if (commandNameWords.length === 0) {
-            await this.loadAllCommands();
-            return;
-        }
-        const isCompletionCommand = commandNameWords.indexOf('completion') > -1;
-        if (isCompletionCommand) {
-            await this.loadAllCommands();
             return;
         }
-        let commandFilePath = '';
-        if (commandNameWords.length === 1) {
-            commandFilePath = path.join(this.commandsFolder, 'commands', `${commandNameWords[0]}.js`);
-        }
-        else {
-            if (commandNameWords.length === 2) {
-                commandFilePath = path.join(this.commandsFolder, commandNameWords[0], 'commands', `${commandNameWords.join('-')}.js`);
-            }
-            else {
-                commandFilePath = path.join(this.commandsFolder, commandNameWords[0], 'commands', commandNameWords[1], commandNameWords.slice(1).join('-') + '.js');
-            }
+        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);
         }
-        await this.loadCommandFromFile(commandFilePath);
     }
     async loadOptionsFromContext(commandOptions, debug) {
         const filePath = '.m365rc.json';
@@ -339,39 +338,37 @@ export class Cli {
      * 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 commandFilePath File path of the file with command to load
+     * @param commandFilePathUrl File path of the file with command to load
      */
-    async loadCommandFromFile(commandFilePath) {
-        if (!fs.existsSync(commandFilePath)) {
-            await this.loadAllCommands();
+    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 commandFileUrl = pathToFileURL(commandFilePath).toString();
-            const command = await import(commandFileUrl);
+            const command = await import(pathToFileURL(filePath).toString());
             if (command.default instanceof Command) {
-                this.loadCommand(command.default);
-            }
-            else {
-                await this.loadAllCommands();
+                const commandInfo = this.commands.find(c => c.file === commandFileUrl);
+                this.commandToExecute = Cli.getCommandInfo(command.default, commandFileUrl, commandInfo?.help);
             }
         }
-        catch {
-            await this.loadAllCommands();
-        }
+        catch { }
     }
-    static getCommandInfo(command) {
+    static getCommandInfo(command, filePath = '', helpFilePath = '') {
         return {
             aliases: command.alias(),
             name: command.name,
+            description: command.description,
             command: command,
             options: this.getCommandOptions(command),
-            defaultProperties: command.defaultProperties()
+            defaultProperties: command.defaultProperties(),
+            file: filePath,
+            help: helpFilePath
         };
     }
-    loadCommand(command) {
-        this.commands.push(Cli.getCommandInfo(command));
-    }
     static getCommandOptions(command) {
         const options = [];
         command.options.forEach(option => {
@@ -568,58 +565,39 @@ export class Cli {
         process.exit(exitCode);
     }
     printCommandHelp(helpMode) {
-        let helpFilePath = '';
-        let commandNameWords = [];
-        if (this.commandToExecute) {
-            commandNameWords = (this.commandToExecute.name).split(' ');
-        }
-        const pathChunks = [this.commandsFolder, '..', '..', 'docs', 'docs', 'cmd'];
-        if (commandNameWords.length === 1) {
-            pathChunks.push(`${commandNameWords[0]}.mdx`);
-        }
-        else {
-            if (commandNameWords.length === 2) {
-                pathChunks.push(commandNameWords[0], `${commandNameWords.join('-')}.mdx`);
-            }
-            else {
-                pathChunks.push(commandNameWords[0], commandNameWords[1], commandNameWords.slice(1).join('-') + '.mdx');
-            }
-        }
-        helpFilePath = path.join(...pathChunks);
+        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, path.join(this.commandsFolder, '..', '..', 'docs'));
+            helpContents = md.md2plain(helpContents, docsRootDir);
             Cli.log();
             Cli.log(helpContents);
         }
     }
     async getHelpMode(options) {
-        const h = options.h;
-        const help = options.help;
+        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
-        if (h || help) {
-            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);
+        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 {
-                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;
-                }
+                return lowerCaseHelpMode;
             }
         }
-        else {
-            return this.getSettingWithDefaultValue(settingsNames.helpMode, Cli.defaultHelpMode);
-        }
     }
     getHelpSection(helpMode, helpContents) {
         if (helpMode === 'full') {
@@ -709,7 +687,7 @@ export class Cli {
             Cli.log();
             const sortedCommandNamesToPrint = Object.getOwnPropertyNames(commandsToPrint).sort();
             sortedCommandNamesToPrint.forEach(commandName => {
-                Cli.log(`  ${`${commandName} [options]`.padEnd(maxLength, ' ')}  ${commandsToPrint[commandName].command.description}`);
+                Cli.log(`  ${`${commandName} [options]`.padEnd(maxLength, ' ')}  ${commandsToPrint[commandName].description}`);
             });
         }
         const namesOfCommandGroupsToPrint = Object.keys(commandGroupsToPrint);
@@ -804,35 +782,47 @@ export class Cli {
             cli.spinner.start();
         }
     }
-    static async prompt(options, answers) {
+    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 response = await prompt.forInput(options, answers);
+        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 response;
+        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(', ')}.`);
         }
-        const response = await Cli.prompt({
-            type: 'list',
-            name: 'select',
-            default: 0,
-            prefix: '🌶️  ',
-            message: `${message} Please choose one:`,
-            choices: Object.keys(values)
-        });
-        return values[response.select];
+        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));

package/dist/cli/timings.js

@@ -0,0 +1,9 @@
+export const timings = {
+    api: [],
+    core: [],
+    command: [],
+    options: [],
+    total: [],
+    validation: []
+};
+//# sourceMappingURL=timings.js.map