@pnp/cli-microsoft365 6.8.0-beta.74dea8a → 6.8.0-beta.85a1ca9

package/dist/Command.js

@@ -420,6 +420,12 @@ class Command {
                 return;
             }
             const lowerCaseValue = value.toLowerCase().trim();
+            if (lowerCaseValue === '@meid' || lowerCaseValue === '@meusername') {
+                const isAppOnlyAccessToken = accessToken_1.accessToken.isAppOnlyAccessToken(Auth_1.default.service.accessTokens[Auth_1.default.defaultResource].accessToken);
+                if (isAppOnlyAccessToken) {
+                    throw `It's not possible to use ${value} with application permissions`;
+                }
+            }
             if (lowerCaseValue === '@meid') {
                 args.options[option] = accessToken_1.accessToken.getUserIdFromAccessToken(token);
             }

package/dist/chili/chili.js

@@ -0,0 +1,298 @@
+"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 });
+exports.chili = void 0;
+const fs = require("fs");
+const inquirer = require("inquirer");
+const ora = require("ora");
+const path = require("path");
+const Cli_1 = require("../cli/Cli");
+const request_1 = require("../request");
+const settingsNames_1 = require("../settingsNames");
+const md_1 = require("../utils/md");
+const mendableApiKey = 'd3313d54-6f8e-40e0-90d3-4095019d4be7';
+let showHelp = false;
+let debug = false;
+let promptForRating = true;
+let conversationId = 0;
+let initialPrompt = '';
+let history = [];
+const cli = Cli_1.Cli.getInstance();
+const showSpinner = cli.getSettingWithDefaultValue(settingsNames_1.settingsNames.showSpinner, true) && typeof global.it === 'undefined';
+request_1.default.logger = {
+    /* c8 ignore next 3 */
+    log: (msg) => console.log(msg),
+    logRaw: (msg) => console.log(msg),
+    logToStderr: (msg) => console.error(msg)
+};
+request_1.default.debug = debug;
+function getPromptFromArgs(args) {
+    showHelp = args.indexOf('--help') > -1 || args.indexOf('-h') > -1;
+    if (showHelp) {
+        const commandsFolder = path.join(__dirname, '..', 'm365');
+        const pathChunks = [commandsFolder, '..', '..', 'docs', 'docs', 'user-guide', 'chili.md'];
+        const helpFilePath = path.join(...pathChunks);
+        if (fs.existsSync(helpFilePath)) {
+            let helpContents = fs.readFileSync(helpFilePath, 'utf8');
+            helpContents = md_1.md.md2plain(helpContents, path.join(commandsFolder, '..', '..', 'docs'));
+            console.log(helpContents);
+            return '';
+        }
+        else {
+            console.error('Help file not found');
+            return '';
+        }
+    }
+    else {
+        // reset to default. needed for tests
+        showHelp = false;
+    }
+    const debugPos = args.indexOf('--debug');
+    if (debugPos > -1) {
+        debug = true;
+        request_1.default.debug = true;
+        args.splice(debugPos, 1);
+    }
+    else {
+        // reset to default. needed for tests
+        debug = false;
+    }
+    const noRatingPos = args.indexOf('--no-rating');
+    if (noRatingPos > -1) {
+        promptForRating = false;
+        args.splice(noRatingPos, 1);
+    }
+    else {
+        // reset to default. needed for tests
+        promptForRating = true;
+    }
+    return args.join(' ');
+}
+function startConversation(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        history = [];
+        initialPrompt = getPromptFromArgs(args);
+        if (showHelp) {
+            return;
+        }
+        conversationId = yield getConversationId();
+        if (!initialPrompt) {
+            initialPrompt = yield promptForPrompt();
+        }
+        yield runConversationTurn(conversationId, initialPrompt);
+    });
+}
+function promptForPrompt() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const answer = yield inquirer.prompt([{
+                type: 'input',
+                name: 'prompt',
+                message: '🌶️  How can I help you?'
+            }]);
+        return answer.prompt;
+    });
+}
+function runConversationTurn(conversationId, question) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log('');
+        const spinner = ora('Searching documentation...');
+        /* c8 ignore next 3 */
+        if (showSpinner) {
+            spinner.start();
+        }
+        const response = yield runMendableChat(conversationId, question);
+        history.push({
+            prompt: question,
+            response: response.answer.text
+        });
+        /* c8 ignore next 3 */
+        if (showSpinner) {
+            spinner.stop();
+        }
+        console.log(md_1.md.md2plain(response.answer.text, ''));
+        console.log('');
+        console.log('Source:');
+        // remove duplicates
+        const sources = response.sources.filter((src, index, self) => index === self.findIndex(s => s.link === src.link));
+        sources.forEach(src => console.log(`⬥ ${src.link}`));
+        console.log('');
+        if (promptForRating) {
+            try {
+                yield rateResponse(response.message_id);
+            }
+            catch (err) {
+                if (debug) {
+                    console.error(`An error has occurred while rating the response: ${err}`);
+                }
+            }
+            console.log('');
+        }
+        const result = yield 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) {
+            case 'ask':
+                const prompt = yield promptForPrompt();
+                return yield runConversationTurn(conversationId, prompt);
+            case 'end':
+                yield endConversation(conversationId);
+                console.log('');
+                console.log('🌶️   Bye!');
+                return;
+            case 'new':
+                initialPrompt = '';
+                return startConversation([]);
+        }
+    });
+}
+function rateResponse(messageId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield 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) {
+            return;
+        }
+        console.log('Thanks for letting us know! 😊');
+        const requestOptions = {
+            url: 'https://api.mendable.ai/v0/rateMessage',
+            headers: {
+                'content-type': 'application/json',
+                'x-anonymous': true
+            },
+            responseType: 'json',
+            data: {
+                // eslint-disable-next-line camelcase
+                api_key: mendableApiKey,
+                // eslint-disable-next-line camelcase
+                conversation_id: conversationId,
+                // eslint-disable-next-line camelcase
+                message_id: messageId,
+                // eslint-disable-next-line camelcase
+                rating_value: result.rating
+            }
+        };
+        const spinner = ora('Sending rating...');
+        /* c8 ignore next 3 */
+        if (showSpinner) {
+            spinner.start();
+        }
+        yield request_1.default.post(requestOptions);
+        /* c8 ignore next 3 */
+        if (showSpinner) {
+            spinner.stop();
+        }
+    });
+}
+function endConversation(conversationId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requestOptions = {
+            url: 'https://api.mendable.ai/v0/endConversation',
+            headers: {
+                'content-type': 'application/json',
+                'x-anonymous': true
+            },
+            responseType: 'json',
+            data: {
+                // eslint-disable-next-line camelcase
+                api_key: mendableApiKey,
+                // eslint-disable-next-line camelcase
+                conversation_id: conversationId
+            }
+        };
+        const spinner = ora('Ending conversation...');
+        /* c8 ignore next 3 */
+        if (showSpinner) {
+            spinner.start();
+        }
+        yield request_1.default.post(requestOptions);
+        /* c8 ignore next 3 */
+        if (showSpinner) {
+            spinner.stop();
+        }
+    });
+}
+function runMendableChat(conversationId, question) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requestOptions = {
+            url: 'https://api.mendable.ai/v0/mendableChat',
+            headers: {
+                'content-type': 'application/json',
+                'x-anonymous': true
+            },
+            responseType: 'json',
+            data: {
+                // eslint-disable-next-line camelcase
+                api_key: mendableApiKey,
+                // eslint-disable-next-line camelcase
+                conversation_id: conversationId,
+                question,
+                history,
+                shouldStream: false
+            }
+        };
+        return yield request_1.default.post(requestOptions);
+    });
+}
+function getConversationId() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requestOptions = {
+            url: 'https://api.mendable.ai/v0/newConversation',
+            headers: {
+                'content-type': 'application/json',
+                'x-anonymous': true
+            },
+            responseType: 'json',
+            data: {
+                // eslint-disable-next-line camelcase
+                api_key: mendableApiKey
+            }
+        };
+        const response = yield request_1.default.post(requestOptions);
+        return response.conversation_id;
+    });
+}
+exports.chili = {
+    startConversation
+};
+//# sourceMappingURL=chili.js.map

package/dist/chili/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+"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 chili_1 = require("./chili");
+try {
+    (() => __awaiter(void 0, void 0, void 0, function* () { return yield chili_1.chili.startConversation(process.argv.slice(2)); }))();
+}
+catch (err) {
+    console.error(`🛑 An error has occurred while searching documentation: ${err}`);
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/Cli.js

@@ -783,7 +783,7 @@ class Cli {
             console.error(message, ...optionalParams);
         }
     }
-    static prompt(options) {
+    static prompt(options, answers) {
         return __awaiter(this, void 0, void 0, function* () {
             const inquirer = require('inquirer');
             const cli = Cli.getInstance();
@@ -792,7 +792,7 @@ class Cli {
             if (spinnerSpinning) {
                 cli.spinner.stop();
             }
-            const response = yield inquirer.prompt(options);
+            const response = yield inquirer.prompt(options, answers);
             // Restart the spinner if it was running before the prompt
             /* c8 ignore next 3 */
             if (spinnerSpinning) {

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/commands/commands.js

@@ -5,6 +5,7 @@ exports.default = {
     LOGIN: `login`,
     LOGOUT: `logout`,
     REQUEST: `request`,
+    SETUP: `setup`,
     STATUS: `status`,
     VERSION: 'version'
 };