@pnp/cli-microsoft365 8.1.0-beta.3dec9fa → 8.1.0-beta.96dc207

package/dist/m365/commands/login.js

@@ -1,17 +1,29 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _LoginCommand_instances, _a, _LoginCommand_initTelemetry, _LoginCommand_initOptions, _LoginCommand_initValidators;
 import fs from 'fs';
+import { z } from 'zod';
 import auth, { AuthType, CloudType } from '../../Auth.js';
-import Command, { CommandError } from '../../Command.js';
-import config from '../../config.js';
-import { misc } from '../../utils/misc.js';
-import commands from './commands.js';
-import { settingsNames } from '../../settingsNames.js';
+import Command, { CommandError, globalOptionsZod } from '../../Command.js';
 import { cli } from '../../cli/cli.js';
+import { settingsNames } from '../../settingsNames.js';
+import { zod } from '../../utils/zod.js';
+import commands from './commands.js';
+const options = globalOptionsZod
+    .extend({
+    authType: zod.alias('t', z.nativeEnum(AuthType).optional()),
+    cloud: z.nativeEnum(CloudType).optional().default(CloudType.Public),
+    userName: zod.alias('u', z.string().optional()),
+    password: zod.alias('p', z.string().optional()),
+    certificateFile: zod.alias('c', z.string().optional()
+        .refine(filePath => !filePath || fs.existsSync(filePath), filePath => ({
+        message: `Certificate file ${filePath} does not exist`
+    }))),
+    certificateBase64Encoded: z.string().optional(),
+    thumbprint: z.string().optional(),
+    appId: z.string().optional(),
+    tenant: z.string().optional(),
+    secret: zod.alias('s', z.string().optional()),
+    connectionName: z.string().optional()
+})
+    .strict();
 class LoginCommand extends Command {
     get name() {
         return commands.LOGIN;
@@ -19,12 +31,40 @@ class LoginCommand extends Command {
     get description() {
         return 'Log in to Microsoft 365';
     }
-    constructor() {
-        super();
-        _LoginCommand_instances.add(this);
-        __classPrivateFieldGet(this, _LoginCommand_instances, "m", _LoginCommand_initTelemetry).call(this);
-        __classPrivateFieldGet(this, _LoginCommand_instances, "m", _LoginCommand_initOptions).call(this);
-        __classPrivateFieldGet(this, _LoginCommand_instances, "m", _LoginCommand_initValidators).call(this);
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => typeof options.appId !== 'undefined' || cli.getConfig().get(settingsNames.clientId), {
+            message: `appId is required. TIP: use the "m365 setup" command to configure the default appId`
+        })
+            .refine(options => options.authType !== 'password' || options.userName, {
+            message: 'Username is required when using password authentication',
+            path: ['userName']
+        })
+            .refine(options => options.authType !== 'password' || options.password, {
+            message: 'Password is required when using password authentication',
+            path: ['password']
+        })
+            .refine(options => options.authType !== 'certificate' || !(options.certificateFile && options.certificateBase64Encoded), {
+            message: 'Specify either certificateFile or certificateBase64Encoded, but not both.',
+            path: ['certificateBase64Encoded']
+        })
+            .refine(options => options.authType !== 'certificate' ||
+            options.certificateFile ||
+            options.certificateBase64Encoded ||
+            cli.getConfig().get(settingsNames.clientCertificateFile) ||
+            cli.getConfig().get(settingsNames.clientCertificateBase64Encoded), {
+            message: 'Specify either certificateFile or certificateBase64Encoded',
+            path: ['certificateFile']
+        })
+            .refine(options => options.authType !== 'secret' ||
+            options.secret ||
+            cli.getConfig().get(settingsNames.clientSecret), {
+            message: 'Secret is required when using secret authentication',
+            path: ['secret']
+        });
     }
     async commandAction(logger, args) {
         // disconnect before re-connecting
@@ -32,13 +72,24 @@ class LoginCommand extends Command {
             await logger.logToStderr(`Logging out from Microsoft 365...`);
         }
         const deactivate = () => auth.connection.deactivate();
+        const getCertificate = (options) => {
+            // command args take precedence over settings
+            if (options.certificateFile) {
+                return fs.readFileSync(options.certificateFile).toString('base64');
+            }
+            if (options.certificateBase64Encoded) {
+                return options.certificateBase64Encoded;
+            }
+            return cli.getConfig().get(settingsNames.clientCertificateFile) ||
+                cli.getConfig().get(settingsNames.clientCertificateBase64Encoded);
+        };
         const login = async () => {
             if (this.verbose) {
                 await logger.logToStderr(`Signing in to Microsoft 365...`);
             }
             const authType = args.options.authType || cli.getSettingWithDefaultValue(settingsNames.authType, 'deviceCode');
-            auth.connection.appId = args.options.appId || config.cliEntraAppId;
-            auth.connection.tenant = args.options.tenant || config.tenant;
+            auth.connection.appId = args.options.appId || cli.getClientId();
+            auth.connection.tenant = args.options.tenant || cli.getTenant();
             auth.connection.name = args.options.connectionName;
             switch (authType) {
                 case 'password':
@@ -48,9 +99,9 @@ class LoginCommand extends Command {
                     break;
                 case 'certificate':
                     auth.connection.authType = AuthType.Certificate;
-                    auth.connection.certificate = args.options.certificateBase64Encoded ? args.options.certificateBase64Encoded : fs.readFileSync(args.options.certificateFile, 'base64');
+                    auth.connection.certificate = getCertificate(args.options);
                     auth.connection.thumbprint = args.options.thumbprint;
-                    auth.connection.password = args.options.password;
+                    auth.connection.password = args.options.password || cli.getConfig().get(settingsNames.clientCertificatePassword);
                     break;
                 case 'identity':
                     auth.connection.authType = AuthType.Identity;
@@ -61,15 +112,10 @@ class LoginCommand extends Command {
                     break;
                 case 'secret':
                     auth.connection.authType = AuthType.Secret;
-                    auth.connection.secret = args.options.secret;
+                    auth.connection.secret = args.options.secret || cli.getConfig().get(settingsNames.clientSecret);
                     break;
             }
-            if (args.options.cloud) {
-                auth.connection.cloudType = CloudType[args.options.cloud];
-            }
-            else {
-                auth.connection.cloudType = CloudType.Public;
-            }
+            auth.connection.cloudType = args.options.cloud;
             try {
                 await auth.ensureAccessToken(auth.defaultResource, logger, this.debug);
                 auth.connection.active = true;
@@ -102,79 +148,5 @@ class LoginCommand extends Command {
         await this.commandAction(logger, args);
     }
 }
-_a = LoginCommand, _LoginCommand_instances = new WeakSet(), _LoginCommand_initTelemetry = function _LoginCommand_initTelemetry() {
-    this.telemetry.push((args) => {
-        Object.assign(this.telemetryProperties, {
-            authType: args.options.authType || cli.getSettingWithDefaultValue(settingsNames.authType, 'deviceCode'),
-            cloud: args.options.cloud ?? CloudType.Public
-        });
-    });
-}, _LoginCommand_initOptions = function _LoginCommand_initOptions() {
-    this.options.unshift({
-        option: '-t, --authType [authType]',
-        autocomplete: _a.allowedAuthTypes
-    }, {
-        option: '-u, --userName [userName]'
-    }, {
-        option: '-p, --password [password]'
-    }, {
-        option: '-c, --certificateFile [certificateFile]'
-    }, {
-        option: '--certificateBase64Encoded [certificateBase64Encoded]'
-    }, {
-        option: '--thumbprint [thumbprint]'
-    }, {
-        option: '--appId [appId]'
-    }, {
-        option: '--tenant [tenant]'
-    }, {
-        option: '-s, --secret [secret]'
-    }, {
-        option: '--cloud [cloud]',
-        autocomplete: misc.getEnums(CloudType)
-    }, {
-        option: '--connectionName [connectionName]'
-    });
-}, _LoginCommand_initValidators = function _LoginCommand_initValidators() {
-    this.validators.push(async (args) => {
-        const authType = args.options.authType || cli.getSettingWithDefaultValue(settingsNames.authType, 'deviceCode');
-        if (authType === 'password') {
-            if (!args.options.userName) {
-                return 'Required option userName missing';
-            }
-            if (!args.options.password) {
-                return 'Required option password missing';
-            }
-        }
-        if (authType === 'certificate') {
-            if (args.options.certificateFile && args.options.certificateBase64Encoded) {
-                return 'Specify either certificateFile or certificateBase64Encoded, but not both.';
-            }
-            if (!args.options.certificateFile && !args.options.certificateBase64Encoded) {
-                return 'Specify either certificateFile or certificateBase64Encoded';
-            }
-            if (args.options.certificateFile) {
-                if (!fs.existsSync(args.options.certificateFile)) {
-                    return `File '${args.options.certificateFile}' does not exist`;
-                }
-            }
-        }
-        if (authType &&
-            _a.allowedAuthTypes.indexOf(authType) < 0) {
-            return `'${authType}' is not a valid authentication type. Allowed authentication types are ${_a.allowedAuthTypes.join(', ')}`;
-        }
-        if (authType === 'secret') {
-            if (!args.options.secret) {
-                return 'Required option secret missing';
-            }
-        }
-        if (args.options.cloud &&
-            typeof CloudType[args.options.cloud] === 'undefined') {
-            return `${args.options.cloud} is not a valid value for cloud. Valid options are ${misc.getEnums(CloudType).join(', ')}`;
-        }
-        return true;
-    });
-};
-LoginCommand.allowedAuthTypes = ['certificate', 'deviceCode', 'password', 'identity', 'browser', 'secret'];
 export default new LoginCommand();
 //# sourceMappingURL=login.js.map

package/dist/m365/commands/setup.js

@@ -6,12 +6,44 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _SetupCommand_instances, _SetupCommand_initTelemetry, _SetupCommand_initOptions, _SetupCommand_initValidators;
 import chalk from 'chalk';
 import os from 'os';
+import auth, { AuthType } from '../../Auth.js';
 import { cli } from '../../cli/cli.js';
+import config from '../../config.js';
+import { settingsNames } from '../../settingsNames.js';
+import { accessToken } from '../../utils/accessToken.js';
+import { entraApp } from '../../utils/entraApp.js';
 import { CheckStatus, formatting } from '../../utils/formatting.js';
 import { pid } from '../../utils/pid.js';
+import { validation } from '../../utils/validation.js';
 import AnonymousCommand from '../base/AnonymousCommand.js';
 import commands from './commands.js';
 import { interactivePreset, powerShellPreset, scriptingPreset } from './setupPresets.js';
+export var CliUsageMode;
+(function (CliUsageMode) {
+    CliUsageMode["Interactively"] = "interactively";
+    CliUsageMode["Scripting"] = "scripting";
+})(CliUsageMode || (CliUsageMode = {}));
+export var CliExperience;
+(function (CliExperience) {
+    CliExperience["Beginner"] = "beginner";
+    CliExperience["Proficient"] = "proficient";
+})(CliExperience || (CliExperience = {}));
+export var EntraAppConfig;
+(function (EntraAppConfig) {
+    EntraAppConfig["Create"] = "create";
+    EntraAppConfig["UseExisting"] = "useExisting";
+    EntraAppConfig["Skip"] = "skip";
+})(EntraAppConfig || (EntraAppConfig = {}));
+export var NewEntraAppScopes;
+(function (NewEntraAppScopes) {
+    NewEntraAppScopes["Minimal"] = "minimal";
+    NewEntraAppScopes["All"] = "all";
+})(NewEntraAppScopes || (NewEntraAppScopes = {}));
+export var HelpMode;
+(function (HelpMode) {
+    HelpMode["Full"] = "full";
+    HelpMode["Options"] = "options";
+})(HelpMode || (HelpMode = {}));
 class SetupCommand extends AnonymousCommand {
     get name() {
         return commands.SETUP;
@@ -35,11 +67,11 @@ class SetupCommand extends AnonymousCommand {
             }
             else if (args.options.scripting) {
                 Object.assign(settings, scriptingPreset);
-                if (pid.isPowerShell()) {
-                    Object.assign(settings, powerShellPreset);
-                }
             }
-            await this.configureSettings(settings, true, logger);
+            if (pid.isPowerShell()) {
+                Object.assign(settings, powerShellPreset);
+            }
+            await this.configureSettings({ preferences: {}, settings, silent: true, logger });
             return;
         }
         await logger.logToStderr(`Welcome to the CLI for Microsoft 365 setup!`);
@@ -47,15 +79,45 @@ class SetupCommand extends AnonymousCommand {
         await logger.logToStderr(`Please, answer the following questions and we'll define a set of settings to best match how you intend to use the CLI.`);
         await logger.logToStderr('');
         const preferences = {};
+        if (!args.options.skipApp) {
+            const entraAppConfig = {
+                message: 'CLI for Microsoft 365 requires a Microsoft Entra app. Do you want to create a new app registration or use an existing one?',
+                choices: [
+                    { name: 'Create a new app registration', value: EntraAppConfig.Create },
+                    { name: 'Use an existing app registration', value: EntraAppConfig.UseExisting },
+                    { name: 'Skip configuring app registration', value: EntraAppConfig.Skip }
+                ]
+            };
+            preferences.entraApp = await cli.promptForSelection(entraAppConfig);
+            switch (preferences.entraApp) {
+                case EntraAppConfig.Create:
+                    const newEntraAppScopesConfig = {
+                        message: 'What scopes should the new app registration have?',
+                        choices: [
+                            { name: 'User.Read (you will need to add the necessary permissions yourself)', value: NewEntraAppScopes.Minimal },
+                            { name: 'All (easy way to use all CLI commands)', value: NewEntraAppScopes.All }
+                        ]
+                    };
+                    preferences.newEntraAppScopes = await cli.promptForSelection(newEntraAppScopesConfig);
+                    break;
+                case EntraAppConfig.UseExisting:
+                    const existingApp = await this.configureExistingEntraApp(logger);
+                    Object.assign(preferences, existingApp);
+                    break;
+            }
+        }
+        else {
+            preferences.entraApp = EntraAppConfig.Skip;
+        }
         const usageModeConfig = {
             message: 'How do you plan to use the CLI?',
             choices: [
-                { name: 'Interactively', value: 'Interactively' },
-                { name: 'Scripting', value: 'Scripting' }
+                { name: 'Interactively', value: CliUsageMode.Interactively },
+                { name: 'Scripting', value: CliUsageMode.Scripting }
             ]
         };
         preferences.usageMode = await cli.promptForSelection(usageModeConfig);
-        if (preferences.usageMode === 'Scripting') {
+        if (preferences.usageMode === CliUsageMode.Scripting) {
             const usedInPowerShellConfig = {
                 message: 'Are you going to use the CLI in PowerShell?',
                 default: pid.isPowerShell()
@@ -65,33 +127,149 @@ class SetupCommand extends AnonymousCommand {
         const experienceConfig = {
             message: 'How experienced are you in using the CLI?',
             choices: [
-                { name: 'Beginner', value: 'Beginner' },
-                { name: 'Proficient', value: 'Proficient' }
+                { name: 'Beginner', value: CliExperience.Beginner },
+                { name: 'Proficient', value: CliExperience.Proficient }
             ]
         };
         preferences.experience = await cli.promptForSelection(experienceConfig);
         const summaryConfig = {
-            message: this.getSummaryMessage(this.getSettings(preferences))
+            message: this.getSummaryMessage(preferences)
         };
         preferences.summary = await cli.promptForConfirmation(summaryConfig);
-        if (preferences.summary) {
-            // used only for testing. Normally, we'd get the settings from the answers
-            /* c8 ignore next 3 */
-            if (!settings) {
-                settings = this.getSettings(preferences);
-            }
-            await logger.logToStderr('');
-            await logger.logToStderr('Configuring settings...');
+        if (!preferences.summary) {
+            return;
+        }
+        // used only for testing. Normally, we'd get the settings from the answers
+        /* c8 ignore next 3 */
+        if (!settings) {
+            settings = this.getSettings(preferences);
+        }
+        await logger.logToStderr('');
+        await logger.logToStderr('Configuring settings...');
+        await logger.logToStderr('');
+        await this.configureSettings({ preferences, settings, silent: false, logger });
+        if (!this.verbose) {
             await logger.logToStderr('');
-            await this.configureSettings(settings, false, logger);
-            if (!this.verbose) {
-                await logger.logToStderr('');
-                await logger.logToStderr(chalk.green('DONE'));
+            await logger.logToStderr(chalk.green('DONE'));
+        }
+    }
+    async configureExistingEntraApp(logger) {
+        await logger.logToStderr('Please provide the details of the existing app registration.');
+        let clientCertificateFile;
+        let clientCertificateBase64Encoded;
+        let clientCertificatePassword;
+        const clientId = await cli.promptForInput({
+            message: 'Client ID:',
+            /* c8 ignore next */
+            validate: value => validation.isValidGuid(value) ? true : 'The specified value is not a valid GUID.'
+        });
+        const tenantId = await cli.promptForInput({
+            message: 'Tenant ID (leave common if the app is multitenant):',
+            default: 'common',
+            /* c8 ignore next */
+            validate: value => value === 'common' || validation.isValidGuid(value) ? true : `Tenant ID must be a valid GUID or 'common'.`
+        });
+        const clientSecret = await cli.promptForInput({
+            message: 'Client secret (leave empty if you use a certificate or a public client):'
+        });
+        if (!clientSecret) {
+            clientCertificateFile = await cli.promptForInput({
+                message: `Path to the client certificate file (leave empty if you want to specify a base64-encoded certificate string):`
+            });
+            if (!clientCertificateFile) {
+                clientCertificateBase64Encoded = await cli.promptForInput({
+                    message: `Base64-encoded certificate string (leave empty if you don't connect using a certificate):`
+                });
+            }
+            if (clientCertificateFile || clientCertificateBase64Encoded) {
+                clientCertificatePassword = await cli.promptForInput({
+                    message: 'Password for the client certificate (leave empty if the certificate is not password-protected):'
+                });
             }
         }
+        return {
+            clientId,
+            tenantId,
+            clientSecret,
+            clientCertificateFile,
+            clientCertificateBase64Encoded,
+            clientCertificatePassword
+        };
     }
-    getSummaryMessage(settings) {
+    async createNewEntraApp(preferences, logger) {
+        if (!await cli.promptForConfirmation({
+            message: 'CLI for Microsoft 365 will now sign in to your Microsoft 365 tenant as Microsoft Azure CLI to create a new app registration. Continue?',
+            default: false
+        })) {
+            throw 'Cancelled';
+        }
+        // setup auth
+        auth.connection.authType = AuthType.Browser;
+        // Microsoft Azure CLI app ID
+        auth.connection.appId = '04b07795-8ddb-461a-bbee-02f9e1bf7b46';
+        auth.connection.tenant = 'common';
+        await auth.ensureAccessToken(auth.defaultResource, logger, this.debug);
+        auth.connection.active = true;
+        const options = {
+            allowPublicClientFlows: true,
+            apisDelegated: (preferences.newEntraAppScopes === NewEntraAppScopes.All ? config.allScopes : config.minimalScopes).join(','),
+            implicitFlow: false,
+            multitenant: false,
+            name: 'CLI for Microsoft 365',
+            platform: 'publicClient',
+            redirectUris: 'http://localhost,https://localhost,https://login.microsoftonline.com/common/oauth2/nativeclient'
+        };
+        const apis = await entraApp.resolveApis({
+            options,
+            logger,
+            verbose: this.verbose,
+            debug: this.debug
+        });
+        const appInfo = await entraApp.createAppRegistration({
+            options,
+            apis,
+            logger,
+            verbose: this.verbose,
+            debug: this.debug
+        });
+        appInfo.tenantId = accessToken.getTenantIdFromAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken);
+        await entraApp.grantAdminConsent({
+            appInfo,
+            appPermissions: entraApp.appPermissions,
+            adminConsent: true,
+            logger,
+            debug: this.debug
+        });
+        return appInfo;
+    }
+    getSummaryMessage(preferences) {
         const messageLines = [`Based on your preferences, we'll configure the following settings:`];
+        switch (preferences.entraApp) {
+            case EntraAppConfig.Create:
+                messageLines.push(`- Entra app: Create a new app registration with ${preferences.newEntraAppScopes} scopes`);
+                break;
+            case EntraAppConfig.UseExisting:
+                messageLines.push(`- Entra app: use existing`);
+                messageLines.push(`  - Client ID: ${preferences.clientId}`);
+                messageLines.push(`  - Tenant ID: ${preferences.tenantId}`);
+                if (preferences.clientSecret) {
+                    messageLines.push(`  - Client secret: ${preferences.clientSecret}`);
+                }
+                if (preferences.clientCertificateFile) {
+                    messageLines.push(`  - Client certificate file: ${preferences.clientCertificateFile}`);
+                }
+                if (preferences.clientCertificateBase64Encoded) {
+                    messageLines.push(`  - Client certificate base64-encoded: ${preferences.clientCertificateBase64Encoded}`);
+                }
+                if (preferences.clientCertificatePassword) {
+                    messageLines.push(`  - Client certificate password: ${preferences.clientCertificatePassword}`);
+                }
+                break;
+            case EntraAppConfig.Skip:
+                messageLines.push(`- Entra app: skip`);
+                break;
+        }
+        const settings = this.getSettings(preferences);
         for (const [key, value] of Object.entries(settings)) {
             messageLines.push(`- ${key}: ${value}`);
         }
@@ -101,10 +279,10 @@ class SetupCommand extends AnonymousCommand {
     getSettings(answers) {
         const settings = {};
         switch (answers.usageMode) {
-            case 'Interactively':
+            case CliUsageMode.Interactively:
                 Object.assign(settings, interactivePreset);
                 break;
-            case 'Scripting':
+            case CliUsageMode.Scripting:
                 Object.assign(settings, scriptingPreset);
                 break;
         }
@@ -112,16 +290,60 @@ class SetupCommand extends AnonymousCommand {
             Object.assign(settings, powerShellPreset);
         }
         switch (answers.experience) {
-            case 'Beginner':
-                settings.helpMode = 'full';
+            case CliExperience.Beginner:
+                settings.helpMode = HelpMode.Full;
                 break;
-            case 'Proficient':
-                settings.helpMode = 'options';
+            case CliExperience.Proficient:
+                settings.helpMode = HelpMode.Options;
+                break;
+        }
+        switch (answers.entraApp) {
+            case EntraAppConfig.Create:
+                settings.authType = 'browser';
+                break;
+            case EntraAppConfig.UseExisting:
+                if (answers.clientSecret) {
+                    settings.authType = 'secret';
+                    break;
+                }
+                if (answers.clientCertificateFile || answers.clientCertificateBase64Encoded) {
+                    settings.authType = 'certificate';
+                    break;
+                }
+                settings.authType = 'browser';
                 break;
         }
         return settings;
     }
-    async configureSettings(settings, silent, logger) {
+    async configureSettings({ preferences, settings, silent, logger }) {
+        switch (preferences.entraApp) {
+            case EntraAppConfig.Create:
+                if (this.verbose) {
+                    await logger.logToStderr('Creating a new Entra app...');
+                }
+                const appSettings = await this.createNewEntraApp(preferences, logger);
+                Object.assign(settings, {
+                    clientId: appSettings.appId,
+                    tenantId: appSettings.tenantId
+                });
+                cli.getConfig().delete(settingsNames.clientSecret);
+                cli.getConfig().delete(settingsNames.clientCertificateFile);
+                cli.getConfig().delete(settingsNames.clientCertificateBase64Encoded);
+                cli.getConfig().delete(settingsNames.clientCertificatePassword);
+                break;
+            case EntraAppConfig.UseExisting:
+                Object.assign(settings, {
+                    clientId: preferences.clientId,
+                    tenantId: preferences.tenantId,
+                    clientSecret: preferences.clientSecret,
+                    clientCertificateFile: preferences.clientCertificateFile,
+                    clientCertificateBase64Encoded: preferences.clientCertificateBase64Encoded,
+                    clientCertificatePassword: preferences.clientCertificatePassword
+                });
+                break;
+            case EntraAppConfig.Skip:
+                break;
+        }
         if (this.debug) {
             await logger.logToStderr('Configuring settings...');
             await logger.logToStderr(JSON.stringify(settings, null, 2));
@@ -137,13 +359,14 @@ class SetupCommand extends AnonymousCommand {
 _SetupCommand_instances = new WeakSet(), _SetupCommand_initTelemetry = function _SetupCommand_initTelemetry() {
     this.telemetry.push((args) => {
         const properties = {
-            interactive: args.options.interactive,
-            scripting: args.options.scripting
+            interactive: !!args.options.interactive,
+            scripting: !!args.options.scripting,
+            skipApp: !!args.options.skipApp
         };
         Object.assign(this.telemetryProperties, properties);
     });
 }, _SetupCommand_initOptions = function _SetupCommand_initOptions() {
-    this.options.unshift({ option: '--interactive' }, { option: '--scripting' });
+    this.options.unshift({ option: '--interactive' }, { option: '--scripting' }, { option: '--skipApp' });
 }, _SetupCommand_initValidators = function _SetupCommand_initValidators() {
     this.validators.push(async (args) => {
         if (args.options.interactive && args.options.scripting) {

package/dist/m365/connection/commands/connection-list.js

@@ -1,7 +1,7 @@
-import auth, { AuthType } from '../../../Auth.js';
-import commands from '../commands.js';
-import Command, { CommandError } from '../../../Command.js';
 import assert from 'assert';
+import auth from '../../../Auth.js';
+import Command, { CommandError } from '../../../Command.js';
+import commands from '../commands.js';
 class ConnectionListCommand extends Command {
     get name() {
         return commands.LIST;
@@ -19,7 +19,7 @@ class ConnectionListCommand extends Command {
             return {
                 name: connection.name,
                 connectedAs: connection.identityName,
-                authType: AuthType[connection.authType],
+                authType: connection.authType,
                 active: isCurrentConnection
             };
         }).sort((a, b) => {

package/dist/m365/connection/commands/connection-remove.js

@@ -3,7 +3,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ConnectionRemoveCommand_instances, _ConnectionRemoveCommand_initTelemetry, _ConnectionRemoveCommand_initOptions;
+var _ConnectionRemoveCommand_instances, _ConnectionRemoveCommand_initTelemetry, _ConnectionRemoveCommand_initOptions, _ConnectionRemoveCommand_initTypes;
 import auth from '../../../Auth.js';
 import commands from '../commands.js';
 import Command, { CommandError } from '../../../Command.js';
@@ -20,6 +20,7 @@ class ConnectionRemoveCommand extends Command {
         _ConnectionRemoveCommand_instances.add(this);
         __classPrivateFieldGet(this, _ConnectionRemoveCommand_instances, "m", _ConnectionRemoveCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _ConnectionRemoveCommand_instances, "m", _ConnectionRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _ConnectionRemoveCommand_instances, "m", _ConnectionRemoveCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         const deleteConnection = async () => {
@@ -53,7 +54,7 @@ class ConnectionRemoveCommand extends Command {
 _ConnectionRemoveCommand_instances = new WeakSet(), _ConnectionRemoveCommand_initTelemetry = function _ConnectionRemoveCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
-            force: (!(!args.options.force)).toString()
+            force: !!args.options.force
         });
     });
 }, _ConnectionRemoveCommand_initOptions = function _ConnectionRemoveCommand_initOptions() {
@@ -62,6 +63,9 @@ _ConnectionRemoveCommand_instances = new WeakSet(), _ConnectionRemoveCommand_ini
     }, {
         option: '-f, --force'
     });
+}, _ConnectionRemoveCommand_initTypes = function _ConnectionRemoveCommand_initTypes() {
+    this.types.string.push('name');
+    this.types.boolean.push('force');
 };
 export default new ConnectionRemoveCommand();
 //# sourceMappingURL=connection-remove.js.map