@pnp/cli-microsoft365 7.2.0-beta.6775e3a → 7.2.0-beta.8577f52

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

@@ -78,19 +78,22 @@ class Command {
         const shouldPrompt = Cli.getInstance().getSettingWithDefaultValue(settingsNames.prompt, true);
         let prompted = false;
         for (let i = 0; i < command.options.length; i++) {
-            if (!command.options[i].required ||
-                typeof args.options[command.options[i].name] !== 'undefined') {
+            const optionInfo = command.options[i];
+            if (!optionInfo.required ||
+                typeof args.options[optionInfo.name] !== 'undefined') {
                 continue;
             }
             if (!shouldPrompt) {
-                return `Required option ${command.options[i].name} not specified`;
+                return `Required option ${optionInfo.name} not specified`;
             }
             if (!prompted) {
                 prompted = true;
                 Cli.error('🌶️  Provide values for the following parameters:');
             }
-            const answer = await prompt.forInput({ message: `${command.options[i].name}: ` });
-            args.options[command.options[i].name] = answer;
+            const answer = optionInfo.autocomplete !== undefined
+                ? await prompt.forSelection({ message: `${optionInfo.name}: `, choices: optionInfo.autocomplete.map((choice) => { return { name: choice, value: choice }; }) })
+                : await prompt.forInput({ message: `${optionInfo.name}: ` });
+            args.options[optionInfo.name] = answer;
         }
         if (prompted) {
             Cli.error('');
@@ -457,7 +460,11 @@ class Command {
         if (logStatement && logStatement.length > 0 && !options.query) {
             logStatement.map(l => {
                 for (const x of Object.keys(l)) {
-                    if (typeof l[x] === 'object') {
+                    // Remove object-properties from the output
+                    // Excludes null from the check, because null is an object in JavaScript.  
+                    //  Properties with null values are not removed from the output, 
+                    //  as this can cause missing columns
+                    if (typeof l[x] === 'object' && l[x] !== null) {
                         delete l[x];
                     }
                 }

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/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);
+                const commandInfo = this.commands.find(c => c.file === commandFileUrl);
+                this.commandToExecute = Cli.getCommandInfo(command.default, commandFileUrl, commandInfo?.help);
             }
-            else {
-                await this.loadAllCommands();
-            }
-        }
-        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 => {
@@ -508,7 +505,7 @@ export class Cli {
         if (arrayType !== 'object') {
             return logStatement.join(os.EOL);
         }
-        // if output type has been set to 'text' or 'csv', process the retrieved
+        // 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
@@ -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);

package/dist/cli/timings.js

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

package/dist/index.js

@@ -1,11 +1,7 @@
 #!/usr/bin/env node
-import fs from 'fs';
-import path from 'path';
-import url from 'url';
 import { Cli } from './cli/Cli.js';
 import { telemetry } from './telemetry.js';
 import { app } from './utils/app.js';
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
 // required to make console.log() in combination with piped output synchronous
 // on Windows/in PowerShell so that the output is not trimmed by calling
 // process.exit() after executing the command, while the output is still
@@ -18,14 +14,12 @@ if (!process.env.CLIMICROSOFT365_NOUPDATE) {
         updateNotifier.default({ pkg: app.packageJson() }).notify({ defer: false });
     });
 }
-fs.realpath(__dirname, async (err, resolvedPath) => {
-    try {
-        const cli = Cli.getInstance();
-        await cli.execute(path.join(resolvedPath, 'm365'), process.argv.slice(2));
-    }
-    catch (e) {
-        telemetry.trackException(e);
-        process.exit(1);
-    }
-});
+try {
+    const cli = Cli.getInstance();
+    cli.execute(process.argv.slice(2));
+}
+catch (e) {
+    telemetry.trackException(e);
+    process.exit(1);
+}
 //# sourceMappingURL=index.js.map

package/dist/m365/cli/commands/config/config-set.js

@@ -70,10 +70,23 @@ _a = CliConfigSetCommand, _CliConfigSetCommand_instances = new WeakSet(), _CliCo
             allowedErrorOutputs.indexOf(args.options.value) === -1) {
             return `${args.options.value} is not a valid value for the option ${args.options.key}. Allowed values: ${allowedErrorOutputs.join(', ')}`;
         }
+        if (args.options.key === settingsNames.promptListPageSize &&
+            typeof args.options.value !== 'number') {
+            return `${args.options.value} is not a valid value for the option ${args.options.key}. The value has to be a number.`;
+        }
+        if (args.options.key === settingsNames.promptListPageSize &&
+            args.options.value <= 0) {
+            return `${args.options.value} is not a valid value for the option ${args.options.key}. The number has to be higher than 0.`;
+        }
         if (args.options.key === settingsNames.helpMode &&
             Cli.helpModes.indexOf(args.options.value) === -1) {
             return `${args.options.value} is not a valid value for the option ${args.options.key}. Allowed values: ${Cli.helpModes.join(', ')}`;
         }
+        const allowedAuthTypes = ['certificate', 'deviceCode', 'password', 'identity', 'browser', 'secret'];
+        if (args.options.key === settingsNames.authType &&
+            allowedAuthTypes.indexOf(args.options.value) === -1) {
+            return `${args.options.value} is not a valid value for the option ${args.options.key}. Allowed values: ${allowedAuthTypes.join(', ')}`;
+        }
         return true;
     });
 };

package/dist/m365/commands/login.js

@@ -11,6 +11,8 @@ import config from '../../config.js';
 import { accessToken } from '../../utils/accessToken.js';
 import { misc } from '../../utils/misc.js';
 import commands from './commands.js';
+import { settingsNames } from '../../settingsNames.js';
+import { Cli } from '../../cli/Cli.js';
 class LoginCommand extends Command {
     get name() {
         return commands.LOGIN;
@@ -35,9 +37,10 @@ class LoginCommand extends Command {
             if (this.verbose) {
                 await logger.logToStderr(`Signing in to Microsoft 365...`);
             }
+            const authType = args.options.authType || Cli.getInstance().getSettingWithDefaultValue(settingsNames.authType, 'deviceCode');
             auth.service.appId = args.options.appId || config.cliAadAppId;
             auth.service.tenant = args.options.tenant || config.tenant;
-            switch (args.options.authType) {
+            switch (authType) {
                 case 'password':
                     auth.service.authType = AuthType.Password;
                     auth.service.userName = args.options.userName;
@@ -126,7 +129,7 @@ class LoginCommand extends Command {
 _a = LoginCommand, _LoginCommand_instances = new WeakSet(), _LoginCommand_initTelemetry = function _LoginCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
-            authType: args.options.authType || 'deviceCode',
+            authType: args.options.authType || Cli.getInstance().getSettingWithDefaultValue(settingsNames.authType, 'deviceCode'),
             cloud: args.options.cloud ?? CloudType.Public
         });
     });
@@ -156,7 +159,8 @@ _a = LoginCommand, _LoginCommand_instances = new WeakSet(), _LoginCommand_initTe
     });
 }, _LoginCommand_initValidators = function _LoginCommand_initValidators() {
     this.validators.push(async (args) => {
-        if (args.options.authType === 'password') {
+        const authType = args.options.authType || Cli.getInstance().getSettingWithDefaultValue(settingsNames.authType, 'deviceCode');
+        if (authType === 'password') {
             if (!args.options.userName) {
                 return 'Required option userName missing';
             }
@@ -164,7 +168,7 @@ _a = LoginCommand, _LoginCommand_instances = new WeakSet(), _LoginCommand_initTe
                 return 'Required option password missing';
             }
         }
-        if (args.options.authType === 'certificate') {
+        if (authType === 'certificate') {
             if (args.options.certificateFile && args.options.certificateBase64Encoded) {
                 return 'Specify either certificateFile or certificateBase64Encoded, but not both.';
             }
@@ -177,11 +181,11 @@ _a = LoginCommand, _LoginCommand_instances = new WeakSet(), _LoginCommand_initTe
                 }
             }
         }
-        if (args.options.authType &&
-            _a.allowedAuthTypes.indexOf(args.options.authType) < 0) {
-            return `'${args.options.authType}' is not a valid authentication type. Allowed authentication types are ${_a.allowedAuthTypes.join(', ')}`;
+        if (authType &&
+            _a.allowedAuthTypes.indexOf(authType) < 0) {
+            return `'${authType}' is not a valid authentication type. Allowed authentication types are ${_a.allowedAuthTypes.join(', ')}`;
         }
-        if (args.options.authType === 'secret') {
+        if (authType === 'secret') {
             if (!args.options.secret) {
                 return 'Required option secret missing';
             }

package/dist/m365/flow/commands/environment/environment-list.js

@@ -17,10 +17,12 @@ class FlowEnvironmentListCommand extends AzmgmtCommand {
         }
         try {
             const res = await odata.getAllItems(`${this.resource}providers/Microsoft.ProcessSimple/environments?api-version=2016-11-01`);
-            if (args.options.output !== 'json' && res.length > 0) {
-                res.forEach(e => {
-                    e.displayName = e.properties.displayName;
-                });
+            if (res.length > 0) {
+                if (args.options.output !== 'json') {
+                    res.forEach(e => {
+                        e.displayName = e.properties.displayName;
+                    });
+                }
                 await logger.log(res);
             }
         }

package/dist/m365/spfx/commands/project/DeployWorkflow.js

@@ -16,10 +16,10 @@ export const workflow = {
                     uses: "actions/checkout@v3.5.3"
                 },
                 {
-                    name: "Use Node.js 16.x",
+                    name: "Use Node.js",
                     uses: "actions/setup-node@v3.7.0",
                     with: {
-                        "node-version": "16.x"
+                        "node-version": "18.x"
                     }
                 },
                 {
@@ -32,7 +32,7 @@ export const workflow = {
                 },
                 {
                     name: "CLI for Microsoft 365 Login",
-                    uses: "pnp/action-cli-login@v2.2.2",
+                    uses: "pnp/action-cli-login@v2.2.4",
                     with: {
                         "CERTIFICATE_ENCODED": "${{ secrets.CERTIFICATE_ENCODED }}",
                         "CERTIFICATE_PASSWORD": "${{ secrets.CERTIFICATE_PASSWORD }}",
@@ -41,7 +41,7 @@ export const workflow = {
                 },
                 {
                     name: "CLI for Microsoft 365 Deploy App",
-                    uses: "pnp/action-cli-deploy@v3.0.1",
+                    uses: "pnp/action-cli-deploy@v4.0.0",
                     with: {
                         "APP_FILE_PATH": "sharepoint/solution/{{ solutionName }}.sppkg",
                         "SKIP_FEATURE_DEPLOYMENT": false,

package/dist/m365/spfx/commands/project/project-doctor/{doctor-1.18.1-rc.0.js → doctor-1.18.1.js}

@@ -18,4 +18,4 @@ export default [
     new FN002016_DEVDEP_types_react_dom('17'),
     new FN002019_DEVDEP_microsoft_rush_stack_compiler(['4.7'])
 ];
-//# sourceMappingURL=doctor-1.18.1-rc.0.js.map
+//# sourceMappingURL=doctor-1.18.1.js.map