@pnp/cli-microsoft365 6.8.0-beta.f473be5 → 6.9.0-beta.1cd2525

package/dist/m365/app/commands/permission/permission-add.js

@@ -0,0 +1,279 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var _AppPermissionAddCommand_instances, _AppPermissionAddCommand_initTelemetry, _AppPermissionAddCommand_initOptions, _AppPermissionAddCommand_initOptionSets;
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = require("../../../../request");
+const formatting_1 = require("../../../../utils/formatting");
+const odata_1 = require("../../../../utils/odata");
+const AppCommand_1 = require("../../../base/AppCommand");
+const commands_1 = require("../../commands");
+var ScopeType;
+(function (ScopeType) {
+    ScopeType["Role"] = "Role";
+    ScopeType["Scope"] = "Scope";
+})(ScopeType || (ScopeType = {}));
+class AppPermissionAddCommand extends AppCommand_1.default {
+    get name() {
+        return commands_1.default.PERMISSION_ADD;
+    }
+    get description() {
+        return 'Adds the specified application and/or delegated permissions to the current AAD app API permissions';
+    }
+    constructor() {
+        super();
+        _AppPermissionAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _AppPermissionAddCommand_instances, "m", _AppPermissionAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _AppPermissionAddCommand_instances, "m", _AppPermissionAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _AppPermissionAddCommand_instances, "m", _AppPermissionAddCommand_initOptionSets).call(this);
+    }
+    commandAction(logger, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const appObject = yield this.getAppObject();
+                const servicePrincipals = yield odata_1.odata.getAllItems(`${this.resource}/v1.0/myorganization/servicePrincipals?$select=appId,appRoles,id,oauth2PermissionScopes,servicePrincipalNames`);
+                const appPermissions = [];
+                if (args.options.delegatedPermission) {
+                    const delegatedPermissions = this.getRequiredResourceAccessForApis(servicePrincipals, args.options.delegatedPermission, ScopeType.Scope, appPermissions, logger);
+                    this.addPermissionsToResourceArray(delegatedPermissions, appObject.requiredResourceAccess);
+                }
+                if (args.options.applicationPermission) {
+                    const applicationPermissions = this.getRequiredResourceAccessForApis(servicePrincipals, args.options.applicationPermission, ScopeType.Role, appPermissions, logger);
+                    this.addPermissionsToResourceArray(applicationPermissions, appObject.requiredResourceAccess);
+                }
+                const addPermissionsRequestOptions = {
+                    url: `${this.resource}/v1.0/myorganization/applications/${appObject.id}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json',
+                    data: {
+                        requiredResourceAccess: appObject.requiredResourceAccess
+                    }
+                };
+                yield request_1.default.patch(addPermissionsRequestOptions);
+                if (args.options.grantAdminConsent) {
+                    const appServicePrincipal = servicePrincipals.find(sp => sp.appId === this.appId);
+                    yield this.grantAdminConsent(appServicePrincipal, appPermissions, logger);
+                }
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        });
+    }
+    getAppObject() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const apps = yield odata_1.odata.getAllItems(`${this.resource}/v1.0/myorganization/applications?$filter=appId eq '${formatting_1.formatting.encodeQueryParameter(this.appId)}'&$select=id,requiredResourceAccess`);
+            if (apps.length === 0) {
+                throw `App with id ${this.appId} not found in Azure Active Directory`;
+            }
+            return apps[0];
+        });
+    }
+    addPermissionsToResourceArray(permissions, existingArray) {
+        permissions.forEach(resolvedRequiredResource => {
+            const requiredResource = existingArray.find(api => api.resourceAppId === resolvedRequiredResource.resourceAppId);
+            if (requiredResource) {
+                // make sure that permission does not yet exist on the app or it will be added twice
+                resolvedRequiredResource.resourceAccess.forEach(resAccess => {
+                    if (!requiredResource.resourceAccess.some(res => res.id === resAccess.id)) {
+                        requiredResource.resourceAccess.push(resAccess);
+                    }
+                });
+            }
+            else {
+                existingArray.push(resolvedRequiredResource);
+            }
+        });
+    }
+    getRequiredResourceAccessForApis(servicePrincipals, apis, scopeType, appPermissions, logger) {
+        const resolvedApis = [];
+        const requestedApis = apis.split(' ').map(a => a.trim());
+        requestedApis.forEach(api => {
+            const pos = api.lastIndexOf('/');
+            const permissionName = api.substring(pos + 1);
+            const servicePrincipalName = api.substring(0, pos);
+            if (this.verbose) {
+                logger.logToStderr(`Resolving ${api}...`);
+                logger.logToStderr(`Permission name: ${permissionName}`);
+                logger.logToStderr(`Service principal name: ${servicePrincipalName}`);
+            }
+            const servicePrincipal = servicePrincipals.find(sp => (sp.servicePrincipalNames.indexOf(servicePrincipalName) > -1 ||
+                sp.servicePrincipalNames.indexOf(`${servicePrincipalName}/`) > -1));
+            if (!servicePrincipal) {
+                throw `Service principal ${servicePrincipalName} not found`;
+            }
+            let permission = undefined;
+            if (scopeType === ScopeType.Scope) {
+                permission = servicePrincipal.oauth2PermissionScopes.find(scope => scope.value === permissionName);
+            }
+            else if (scopeType === ScopeType.Role) {
+                permission = servicePrincipal.appRoles.find(scope => scope.value === permissionName);
+            }
+            if (!permission) {
+                throw `Permission ${permissionName} for service principal ${servicePrincipalName} not found`;
+            }
+            let resolvedApi = resolvedApis.find(a => a.resourceAppId === servicePrincipal.appId);
+            if (!resolvedApi) {
+                resolvedApi = {
+                    resourceAppId: servicePrincipal.appId,
+                    resourceAccess: []
+                };
+                resolvedApis.push(resolvedApi);
+            }
+            const resourceAccessPermission = {
+                id: permission.id,
+                type: scopeType
+            };
+            resolvedApi.resourceAccess.push(resourceAccessPermission);
+            this.updateAppPermissions(servicePrincipal.id, resourceAccessPermission, permission.value, appPermissions);
+        });
+        return resolvedApis;
+    }
+    updateAppPermissions(spId, resourceAccessPermission, oAuth2PermissionValue, appPermissions) {
+        let existingPermission = appPermissions.find(oauth => oauth.resourceId === spId);
+        if (!existingPermission) {
+            existingPermission = {
+                resourceId: spId,
+                resourceAccess: [],
+                scope: []
+            };
+            appPermissions.push(existingPermission);
+        }
+        if (resourceAccessPermission.type === ScopeType.Scope && oAuth2PermissionValue && !existingPermission.scope.find(scp => scp === oAuth2PermissionValue)) {
+            existingPermission.scope.push(oAuth2PermissionValue);
+        }
+        if (!existingPermission.resourceAccess.find(res => res.id === resourceAccessPermission.id)) {
+            existingPermission.resourceAccess.push(resourceAccessPermission);
+        }
+    }
+    grantAdminConsent(servicePrincipal, appPermissions, logger) {
+        var _a, appPermissions_1, appPermissions_1_1;
+        var _b, e_1, _c, _d, _e, e_2, _f, _g;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (_a = true, appPermissions_1 = __asyncValues(appPermissions); appPermissions_1_1 = yield appPermissions_1.next(), _b = appPermissions_1_1.done, !_b;) {
+                    _d = appPermissions_1_1.value;
+                    _a = false;
+                    try {
+                        const permission = _d;
+                        if (permission.scope.length > 0) {
+                            if (this.verbose) {
+                                logger.logToStderr(`Granting consent for delegated permission(s) with resourceId ${permission.resourceId} and scope(s) ${permission.scope.join(' ')}`);
+                            }
+                            yield this.grantOAuth2Permission(servicePrincipal.id, permission.resourceId, permission.scope.join(' '));
+                        }
+                        try {
+                            for (var _h = true, _j = (e_2 = void 0, __asyncValues(permission.resourceAccess.filter(acc => acc.type === ScopeType.Role))), _k; _k = yield _j.next(), _e = _k.done, !_e;) {
+                                _g = _k.value;
+                                _h = false;
+                                try {
+                                    const access = _g;
+                                    if (this.verbose) {
+                                        logger.logToStderr(`Granting consent for application permission with resourceId ${permission.resourceId} and appRoleId ${access.id}`);
+                                    }
+                                    yield this.addRoleToServicePrincipal(servicePrincipal.id, permission.resourceId, access.id);
+                                }
+                                finally {
+                                    _h = true;
+                                }
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (!_h && !_e && (_f = _j.return)) yield _f.call(_j);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                    finally {
+                        _a = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_a && !_b && (_c = appPermissions_1.return)) yield _c.call(appPermissions_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    grantOAuth2Permission(servicePricipalId, resourceId, scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const grantAdminConsentApplicationRequestOptions = {
+                url: `${this.resource}/v1.0/myorganization/oauth2PermissionGrants`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json',
+                data: {
+                    clientId: servicePricipalId,
+                    consentType: 'AllPrincipals',
+                    principalId: null,
+                    resourceId: resourceId,
+                    scope: scope
+                }
+            };
+            return request_1.default.post(grantAdminConsentApplicationRequestOptions);
+        });
+    }
+    addRoleToServicePrincipal(servicePrincipalId, resourceId, appRoleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = {
+                url: `${this.resource}/v1.0/myorganization/servicePrincipals/${servicePrincipalId}/appRoleAssignments`,
+                headers: {
+                    'content-type': 'application/json'
+                },
+                responseType: 'json',
+                data: {
+                    appRoleId: appRoleId,
+                    principalId: servicePrincipalId,
+                    resourceId: resourceId
+                }
+            };
+            return request_1.default.post(requestOptions);
+        });
+    }
+}
+_AppPermissionAddCommand_instances = new WeakSet(), _AppPermissionAddCommand_initTelemetry = function _AppPermissionAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            appId: typeof args.options.appId !== 'undefined',
+            applicationPermission: typeof args.options.applicationPermission !== 'undefined',
+            delegatedPermission: typeof args.options.delegatedPermission !== 'undefined',
+            grantAdminConsent: !!args.options.grantAdminConsent
+        });
+    });
+}, _AppPermissionAddCommand_initOptions = function _AppPermissionAddCommand_initOptions() {
+    this.options.unshift({ option: '--appId [appId]' }, { option: '--applicationPermission [applicationPermission]' }, { option: '--delegatedPermission [delegatedPermission]' }, { option: '--grantAdminConsent' });
+}, _AppPermissionAddCommand_initOptionSets = function _AppPermissionAddCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['applicationPermission', 'delegatedPermission'],
+        runsWhen: (args) => args.options.delegatedPermission === undefined && args.options.applicationPermission === undefined
+    });
+};
+module.exports = new AppPermissionAddCommand();
+//# sourceMappingURL=permission-add.js.map

package/dist/m365/app/commands.js

@@ -4,6 +4,7 @@ const prefix = 'app';
 exports.default = {
     GET: `${prefix} get`,
     OPEN: `${prefix} open`,
+    PERMISSION_ADD: `${prefix} permission add`,
     PERMISSION_LIST: `${prefix} permission list`
 };
 //# sourceMappingURL=commands.js.map

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

@@ -43,6 +43,7 @@ class CliConfigSetCommand extends AnonymousCommand_1.default {
                 case settingsNames_1.settingsNames.csvQuoted:
                 case settingsNames_1.settingsNames.csvQuotedEmpty:
                 case settingsNames_1.settingsNames.disableTelemetry:
+                case settingsNames_1.settingsNames.interactive:
                 case settingsNames_1.settingsNames.printErrorsAsPlainText:
                 case settingsNames_1.settingsNames.prompt:
                 case settingsNames_1.settingsNames.showHelpOnFailure:

package/dist/m365/commands/commands.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    DOCS: 'docs',
     LOGIN: `login`,
     LOGOUT: `logout`,
     REQUEST: `request`,
+    SETUP: `setup`,
     STATUS: `status`,
     VERSION: 'version'
 };

package/dist/m365/commands/docs.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AnonymousCommand_1 = require("../base/AnonymousCommand");
+const Cli_1 = require("../../cli/Cli");
+const commands_1 = require("./commands");
+const settingsNames_1 = require("../../settingsNames");
+const packageJSON = require('../../../package.json');
+class DocsCommand extends AnonymousCommand_1.default {
+    get name() {
+        return commands_1.default.DOCS;
+    }
+    get description() {
+        return 'Returns the CLI for Microsoft 365 docs webpage URL';
+    }
+    commandAction(logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.log(packageJSON.homepage);
+            if (Cli_1.Cli.getInstance().getSettingWithDefaultValue(settingsNames_1.settingsNames.autoOpenLinksInBrowser, false) === false) {
+                return;
+            }
+            // _open is never set before hitting this line, but this check
+            // is implemented so that we can support lazy loading
+            // but also stub it for testing
+            /* c8 ignore next 3 */
+            if (!this._open) {
+                this._open = require('open');
+            }
+            yield this._open(packageJSON.homepage);
+        });
+    }
+}
+module.exports = new DocsCommand();
+//# sourceMappingURL=docs.js.map

package/dist/m365/commands/login.js

@@ -145,7 +145,7 @@ _LoginCommand_instances = new WeakSet(), _LoginCommand_initTelemetry = function
     }, {
         option: '--tenant [tenant]'
     }, {
-        option: '--secret [secret]'
+        option: '-s, --secret [secret]'
     }, {
         option: '--cloud [cloud]',
         autocomplete: misc_1.misc.getEnums(Auth_1.CloudType)

package/dist/m365/commands/setup.js

@@ -0,0 +1,180 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 _SetupCommand_instances, _SetupCommand_initTelemetry, _SetupCommand_initOptions, _SetupCommand_initValidators;
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk = require("chalk");
+const os = require("os");
+const Cli_1 = require("../../cli/Cli");
+const formatting_1 = require("../../utils/formatting");
+const pid_1 = require("../../utils/pid");
+const AnonymousCommand_1 = require("../base/AnonymousCommand");
+const commands_1 = require("./commands");
+const setupPresets_1 = require("./setupPresets");
+class SetupCommand extends AnonymousCommand_1.default {
+    get name() {
+        return commands_1.default.SETUP;
+    }
+    get description() {
+        return 'Sets up CLI for Microsoft 365 based on your preferences';
+    }
+    constructor() {
+        super();
+        _SetupCommand_instances.add(this);
+        // used for injecting answers from tests
+        this.answers = {};
+        __classPrivateFieldGet(this, _SetupCommand_instances, "m", _SetupCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SetupCommand_instances, "m", _SetupCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SetupCommand_instances, "m", _SetupCommand_initValidators).call(this);
+    }
+    commandAction(logger, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let settings;
+            if (args.options.interactive || args.options.scripting) {
+                settings = {};
+                if (args.options.interactive) {
+                    Object.assign(settings, setupPresets_1.interactivePreset);
+                }
+                else if (args.options.scripting) {
+                    Object.assign(settings, setupPresets_1.scriptingPreset);
+                }
+                if (pid_1.pid.isPowerShell()) {
+                    Object.assign(settings, setupPresets_1.powerShellPreset);
+                }
+                this.configureSettings(settings, true, logger);
+                return;
+            }
+            logger.logToStderr(`Welcome to the CLI for Microsoft 365 setup!`);
+            logger.logToStderr(`This command will guide you through the process of configuring the CLI for your needs.`);
+            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.`);
+            logger.logToStderr('');
+            const preferences = yield Cli_1.Cli.prompt([
+                {
+                    type: 'list',
+                    name: 'usageMode',
+                    message: 'How do you plan to use the CLI?',
+                    choices: [
+                        'Interactively',
+                        'Scripting'
+                    ]
+                },
+                {
+                    type: 'confirm',
+                    name: 'usedInPowerShell',
+                    message: 'Are you going to use the CLI in PowerShell?',
+                    when: (answers) => answers.usageMode === 'Scripting',
+                    default: pid_1.pid.isPowerShell()
+                },
+                {
+                    type: 'list',
+                    name: 'experience',
+                    message: 'How experienced are you in using the CLI?',
+                    choices: [
+                        'Beginner',
+                        'Proficient'
+                    ]
+                },
+                {
+                    type: 'confirm',
+                    name: 'summary',
+                    // invoked by inquirer
+                    /* c8 ignore next 4 */
+                    message: (answers) => {
+                        settings = this.getSettings(answers);
+                        return this.getSummaryMessage(settings);
+                    }
+                }
+            ], this.answers);
+            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);
+                }
+                logger.logToStderr('');
+                logger.logToStderr('Configuring settings...');
+                logger.logToStderr('');
+                this.configureSettings(settings, false, logger);
+                if (!this.verbose) {
+                    logger.logToStderr('');
+                    logger.logToStderr(chalk.green('DONE'));
+                }
+            }
+        });
+    }
+    getSummaryMessage(settings) {
+        const messageLines = [`Based on your preferences, we'll configure the following settings:`];
+        for (const [key, value] of Object.entries(settings)) {
+            messageLines.push(`- ${key}: ${value}`);
+        }
+        messageLines.push('', 'You can change any of these settings later using the `m365 cli config set` command or reset them to default using `m365 cli config reset`.', '', 'Do you want to apply these settings now?');
+        return messageLines.join(os.EOL);
+    }
+    getSettings(answers) {
+        const settings = {};
+        switch (answers.usageMode) {
+            case 'Interactively':
+                Object.assign(settings, setupPresets_1.interactivePreset);
+                break;
+            case 'Scripting':
+                Object.assign(settings, setupPresets_1.scriptingPreset);
+                break;
+        }
+        if (answers.usedInPowerShell === true) {
+            Object.assign(settings, setupPresets_1.powerShellPreset);
+        }
+        switch (answers.experience) {
+            case 'Beginner':
+                settings.helpMode = 'full';
+                break;
+            case 'Proficient':
+                settings.helpMode = 'options';
+                break;
+        }
+        return settings;
+    }
+    configureSettings(settings, silent, logger) {
+        if (this.debug) {
+            logger.logToStderr('Configuring settings...');
+            logger.logToStderr(JSON.stringify(settings, null, 2));
+        }
+        for (const [key, value] of Object.entries(settings)) {
+            Cli_1.Cli.getInstance().config.set(key, value);
+            if (!silent) {
+                logger.logToStderr(formatting_1.formatting.getStatus(formatting_1.CheckStatus.Success, `${key}: ${value}`));
+            }
+        }
+    }
+}
+_SetupCommand_instances = new WeakSet(), _SetupCommand_initTelemetry = function _SetupCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        const properties = {
+            interactive: args.options.interactive,
+            scripting: args.options.scripting
+        };
+        Object.assign(this.telemetryProperties, properties);
+    });
+}, _SetupCommand_initOptions = function _SetupCommand_initOptions() {
+    this.options.unshift({ option: '--interactive' }, { option: '--scripting' });
+}, _SetupCommand_initValidators = function _SetupCommand_initValidators() {
+    this.validators.push((args) => __awaiter(this, void 0, void 0, function* () {
+        if (args.options.interactive && args.options.scripting) {
+            return 'Specify either interactive or scripting but not both';
+        }
+        return true;
+    }));
+};
+module.exports = new SetupCommand();
+//# sourceMappingURL=setup.js.map

package/dist/m365/commands/setupPresets.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powerShellPreset = exports.scriptingPreset = exports.interactivePreset = void 0;
+exports.interactivePreset = {
+    autoOpenLinksInBrowser: true,
+    copyDeviceCodeToClipboard: true,
+    output: 'text',
+    printErrorsAsPlainText: true,
+    prompt: true,
+    showHelpOnFailure: true,
+    showSpinner: true
+};
+exports.scriptingPreset = {
+    autoOpenLinksInBrowser: false,
+    copyDeviceCodeToClipboard: false,
+    output: 'json',
+    printErrorsAsPlainText: false,
+    prompt: false,
+    showHelpOnFailure: false,
+    showSpinner: false
+};
+exports.powerShellPreset = {
+    errorOutput: 'stdout'
+};
+//# sourceMappingURL=setupPresets.js.map