@pnp/cli-microsoft365 10.6.0-beta.add4854 → 10.7.0-beta.4bcc4fe

package/dist/m365/entra/commands/app/app-set.js

@@ -11,6 +11,7 @@ import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 import { cli } from '../../../../cli/cli.js';
 import { optionsUtils } from '../../../../utils/optionsUtils.js';
+import { entraApp } from '../../../../utils/entraApp.js';
 class EntraAppSetCommand extends GraphCommand {
     get name() {
         return commands.APP_SET;
@@ -51,27 +52,29 @@ class EntraAppSetCommand extends GraphCommand {
         if (this.verbose) {
             await logger.logToStderr(`Retrieving information about Microsoft Entra app ${appId ? appId : name}...`);
         }
-        const filter = appId ?
-            `appId eq '${formatting.encodeQueryParameter(appId)}'` :
-            `displayName eq '${formatting.encodeQueryParameter(name)}'`;
-        const requestOptions = {
-            url: `${this.resource}/v1.0/myorganization/applications?$filter=${filter}&$select=id`,
-            headers: {
-                accept: 'application/json;odata.metadata=none'
-            },
-            responseType: 'json'
-        };
-        const res = await request.get(requestOptions);
-        if (res.value.length === 1) {
-            return res.value[0].id;
+        if (appId) {
+            const app = await entraApp.getAppRegistrationByAppId(appId, ['id']);
+            return app.id;
         }
-        if (res.value.length === 0) {
-            const applicationIdentifier = appId ? `ID ${appId}` : `name ${name}`;
-            throw `No Microsoft Entra application registration with ${applicationIdentifier} found`;
+        else {
+            const requestOptions = {
+                url: `${this.resource}/v1.0/myorganization/applications?$filter=displayName eq '${formatting.encodeQueryParameter(name)}'&$select=id`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            const res = await request.get(requestOptions);
+            if (res.value.length === 1) {
+                return res.value[0].id;
+            }
+            if (res.value.length === 0) {
+                throw `No Microsoft Entra application registration with name ${name} found`;
+            }
+            const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', res.value);
+            const result = await cli.handleMultipleResultsFound(`Multiple Microsoft Entra application registration with name '${name}' found.`, resultAsKeyValuePair);
+            return result.id;
         }
-        const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', res.value);
-        const result = await cli.handleMultipleResultsFound(`Multiple Microsoft Entra application registration with name '${name}' found.`, resultAsKeyValuePair);
-        return result.id;
     }
     async updateUnknownOptions(args, objectId) {
         const unknownOptions = optionsUtils.getUnknownOptions(args.options, this.options);

package/dist/m365/entra/commands/group/group-member-add.js

@@ -15,7 +15,7 @@ class EntraGroupMemberAddCommand extends GraphCommand {
         return commands.GROUP_MEMBER_ADD;
     }
     get description() {
-        return 'Adds a member to a Microsoft Entra ID group';
+        return 'Adds members to a Microsoft Entra group';
     }
     constructor() {
         super();

package/dist/m365/entra/commands/group/group-member-remove.js

@@ -0,0 +1,197 @@
+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 _EntraGroupMemberRemoveCommand_instances, _EntraGroupMemberRemoveCommand_initTelemetry, _EntraGroupMemberRemoveCommand_initOptions, _EntraGroupMemberRemoveCommand_initValidators, _EntraGroupMemberRemoveCommand_initOptionSets, _EntraGroupMemberRemoveCommand_initTypes;
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import request from '../../../../request.js';
+import { cli } from '../../../../cli/cli.js';
+import { entraGroup } from '../../../../utils/entraGroup.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { validation } from '../../../../utils/validation.js';
+class EntraGroupMemberRemoveCommand extends GraphCommand {
+    get name() {
+        return commands.GROUP_MEMBER_REMOVE;
+    }
+    get description() {
+        return 'Removes members from a Microsoft Entra group';
+    }
+    constructor() {
+        super();
+        _EntraGroupMemberRemoveCommand_instances.add(this);
+        this.roleValues = ['Owner', 'Member'];
+        __classPrivateFieldGet(this, _EntraGroupMemberRemoveCommand_instances, "m", _EntraGroupMemberRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraGroupMemberRemoveCommand_instances, "m", _EntraGroupMemberRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _EntraGroupMemberRemoveCommand_instances, "m", _EntraGroupMemberRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _EntraGroupMemberRemoveCommand_instances, "m", _EntraGroupMemberRemoveCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _EntraGroupMemberRemoveCommand_instances, "m", _EntraGroupMemberRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            const removeUsers = async () => {
+                if (this.verbose) {
+                    await logger.logToStderr(`Removing user(s) ${args.options.userIds || args.options.userNames || args.options.subgroupIds || args.options.subgroupNames} from group ${args.options.groupId || args.options.groupName}...`);
+                }
+                const groupId = await this.getGroupId(logger, args.options);
+                const userIds = await this.getPrincipalIds(logger, args.options);
+                const endpoints = [];
+                if (!args.options.role || args.options.role === 'Owner') {
+                    endpoints.push(...userIds.map(id => `/groups/${groupId}/owners/${id}/$ref`));
+                }
+                if (!args.options.role || args.options.role === 'Member') {
+                    endpoints.push(...userIds.map(id => `/groups/${groupId}/members/${id}/$ref`));
+                }
+                for (let i = 0; i < endpoints.length; i += 20) {
+                    const endpointsBatch = endpoints.slice(i, i + 20);
+                    const requestOptions = {
+                        url: `${this.resource}/v1.0/$batch`,
+                        headers: {
+                            'content-type': 'application/json;odata.metadata=none'
+                        },
+                        responseType: 'json',
+                        data: {
+                            requests: endpointsBatch.map((ep, index) => ({
+                                id: index + 1,
+                                method: 'DELETE',
+                                url: ep,
+                                headers: {
+                                    'content-type': 'application/json;odata.metadata=none'
+                                }
+                            }))
+                        }
+                    };
+                    const res = await request.post(requestOptions);
+                    for (const response of res.responses) {
+                        // Suppress 404 errors if suppressNotFound is set
+                        if (response.status !== 204 && (!args.options.suppressNotFound || response.status !== 404)) {
+                            throw response.body;
+                        }
+                    }
+                }
+            };
+            if (args.options.force) {
+                await removeUsers();
+            }
+            else {
+                const principals = args.options.userIds || args.options.userNames || args.options.subgroupIds || args.options.subgroupNames;
+                const principalsList = principals.split(',');
+                const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove ${principalsList.length} principal(s) from group '${args.options.groupId || args.options.groupName}'?` });
+                if (result) {
+                    await removeUsers();
+                }
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getGroupId(logger, options) {
+        if (options.groupId) {
+            return options.groupId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Retrieving ID of group '${options.groupName}'...`);
+        }
+        return entraGroup.getGroupIdByDisplayName(options.groupName);
+    }
+    async getPrincipalIds(logger, options) {
+        if (options.userIds) {
+            return options.userIds.split(',').map(i => i.trim());
+        }
+        if (options.subgroupIds) {
+            return options.subgroupIds.split(',').map(i => i.trim());
+        }
+        if (options.userNames) {
+            if (this.verbose) {
+                await logger.logToStderr('Retrieving ID(s) of user(s)...');
+            }
+            return entraUser.getUserIdsByUpns(options.userNames.split(',').map(u => u.trim()));
+        }
+        // Subgroup names were specified
+        if (this.verbose) {
+            await logger.logToStderr('Retrieving ID(s) of subgroup(s)...');
+        }
+        const subGroupIds = [];
+        for (const subgroupName of options.subgroupNames.split(',')) {
+            const groupId = await entraGroup.getGroupIdByDisplayName(subgroupName.trim());
+            subGroupIds.push(groupId);
+        }
+        return subGroupIds;
+    }
+}
+_EntraGroupMemberRemoveCommand_instances = new WeakSet(), _EntraGroupMemberRemoveCommand_initTelemetry = function _EntraGroupMemberRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            groupId: typeof args.options.groupId !== 'undefined',
+            groupName: typeof args.options.groupName !== 'undefined',
+            userIds: typeof args.options.userIds !== 'undefined',
+            userNames: typeof args.options.userNames !== 'undefined',
+            subgroupIds: typeof args.options.subgroupIds !== 'undefined',
+            subgroupNames: typeof args.options.subgroupNames !== 'undefined',
+            role: typeof args.options.role !== 'undefined',
+            suppressNotFound: !!args.options.suppressNotFound,
+            force: !!args.options.force
+        });
+    });
+}, _EntraGroupMemberRemoveCommand_initOptions = function _EntraGroupMemberRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --groupId [groupId]'
+    }, {
+        option: '-n, --groupName [groupName]'
+    }, {
+        option: '--userIds [userIds]'
+    }, {
+        option: '--userNames [userNames]'
+    }, {
+        option: '--subgroupIds [subgroupIds]'
+    }, {
+        option: '--subgroupNames [subgroupNames]'
+    }, {
+        option: '-r, --role [role]',
+        autocomplete: this.roleValues
+    }, {
+        option: '--suppressNotFound'
+    }, {
+        option: '-f, --force'
+    });
+}, _EntraGroupMemberRemoveCommand_initValidators = function _EntraGroupMemberRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.groupId !== undefined && !validation.isValidGuid(args.options.groupId)) {
+            return `'${args.options.groupId}' is not a valid GUID for option 'groupId'.`;
+        }
+        if (args.options.userIds !== undefined) {
+            const invalidGuids = validation.isValidGuidArray(args.options.userIds);
+            if (invalidGuids !== true) {
+                return `Invalid GUIDs found for option 'ids': ${invalidGuids}.`;
+            }
+        }
+        if (args.options.userNames !== undefined) {
+            const invalidUpns = validation.isValidUserPrincipalNameArray(args.options.userNames);
+            if (invalidUpns !== true) {
+                return `Invalid UPNs found for option 'userNames': ${invalidUpns}.`;
+            }
+        }
+        if (args.options.subgroupIds !== undefined) {
+            const invalidGuids = validation.isValidGuidArray(args.options.subgroupIds);
+            if (invalidGuids !== true) {
+                return `Invalid GUIDs found for option 'subgroupIds': ${invalidGuids}.`;
+            }
+        }
+        if (args.options.role !== undefined && this.roleValues.indexOf(args.options.role) === -1) {
+            return `Option 'role' must be one of the following values: ${this.roleValues.join(', ')}.`;
+        }
+        if ((args.options.subgroupIds !== undefined || args.options.subgroupNames !== undefined) && args.options.role?.toLowerCase() !== 'member') {
+            return `When removing subgroups, the 'role' option must be set to 'Member'.`;
+        }
+        return true;
+    });
+}, _EntraGroupMemberRemoveCommand_initOptionSets = function _EntraGroupMemberRemoveCommand_initOptionSets() {
+    this.optionSets.push({ options: ['groupId', 'groupName'] }, { options: ['userIds', 'userNames', 'subgroupIds', 'subgroupNames'] });
+}, _EntraGroupMemberRemoveCommand_initTypes = function _EntraGroupMemberRemoveCommand_initTypes() {
+    this.types.string.push('groupId', 'groupName', 'ids', 'userNames', 'subgroupIds', 'subgroupNames', 'role');
+    this.types.boolean.push('force', 'suppressNotFound');
+};
+export default new EntraGroupMemberRemoveCommand();
+//# sourceMappingURL=group-member-remove.js.map

package/dist/m365/entra/commands/policy/policy-list.js

@@ -9,10 +9,22 @@ import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 const policyEndPoints = {
     activitybasedtimeout: "activityBasedTimeoutPolicies",
+    adminconsentrequest: "adminConsentRequestPolicy",
+    appManagement: "appManagementPolicies",
+    authenticationflows: "authenticationFlowsPolicy",
+    authenticationmethods: "authenticationMethodsPolicy",
+    authenticationstrength: "authenticationStrengthPolicies",
     authorization: "authorizationPolicy",
     claimsmapping: "claimsMappingPolicies",
+    conditionalaccess: "conditionalAccessPolicies",
+    crosstenantaccess: "crossTenantAccessPolicy",
+    defaultappmanagement: "defaultAppManagementPolicy",
+    deviceregistration: "deviceRegistrationPolicy",
+    featurerolloutpolicy: "featureRolloutPolicies",
     homerealmdiscovery: "homeRealmDiscoveryPolicies",
     identitysecuritydefaultsenforcement: "identitySecurityDefaultsEnforcementPolicy",
+    permissiongrant: "permissionGrantPolicies",
+    rolemanagement: "roleManagementPolicies",
     tokenissuance: "tokenIssuancePolicies",
     tokenlifetime: "tokenLifetimePolicies"
 };
@@ -56,15 +68,26 @@ class EntraPolicyListCommand extends GraphCommand {
     }
     async getPolicies(policyType) {
         const endpoint = policyEndPoints[policyType];
+        let requestUrl = `${this.resource}/v1.0/policies/${endpoint}`;
+        if (endpoint === policyEndPoints.rolemanagement) {
+            // roleManagementPolicies endpoint requires $filter query parameter
+            requestUrl += `?$filter=scopeId eq '/' and scopeType eq 'DirectoryRole'`;
+        }
         const requestOptions = {
-            url: `${this.resource}/v1.0/policies/${endpoint}`,
+            url: requestUrl,
             headers: {
                 accept: 'application/json;odata.metadata=none'
             },
             responseType: 'json'
         };
         const response = await request.get(requestOptions);
-        if (endpoint === policyEndPoints.authorization ||
+        if (endpoint === policyEndPoints.adminconsentrequest ||
+            endpoint === policyEndPoints.authenticationflows ||
+            endpoint === policyEndPoints.authenticationmethods ||
+            endpoint === policyEndPoints.authorization ||
+            endpoint === policyEndPoints.crosstenantaccess ||
+            endpoint === policyEndPoints.defaultappmanagement ||
+            endpoint === policyEndPoints.deviceregistration ||
             endpoint === policyEndPoints.identitysecuritydefaultsenforcement) {
             return response;
         }
@@ -95,6 +118,26 @@ _a = EntraPolicyListCommand, _EntraPolicyListCommand_instances = new WeakSet(),
         return true;
     });
 };
-EntraPolicyListCommand.supportedPolicyTypes = ['activityBasedTimeout', 'authorization', 'claimsMapping', 'homeRealmDiscovery', 'identitySecurityDefaultsEnforcement', 'tokenIssuance', 'tokenLifetime'];
+EntraPolicyListCommand.supportedPolicyTypes = [
+    'activityBasedTimeout',
+    'adminConsentRequest',
+    'appManagement',
+    'authenticationFlows',
+    'authenticationMethods',
+    'authenticationStrength',
+    'authorization',
+    'claimsMapping',
+    'conditionalAccess',
+    'crossTenantAccess',
+    'defaultAppManagement',
+    'deviceRegistration',
+    'featureRolloutPolicy',
+    'homeRealmDiscovery',
+    'identitySecurityDefaultsEnforcement',
+    'permissionGrant',
+    'roleManagement',
+    'tokenIssuance',
+    'tokenLifetime'
+];
 export default new EntraPolicyListCommand();
 //# sourceMappingURL=policy-list.js.map

package/dist/m365/entra/commands.js

@@ -39,6 +39,7 @@ export default {
     GROUP_ADD: `${prefix} group add`,
     GROUP_GET: `${prefix} group get`,
     GROUP_LIST: `${prefix} group list`,
+    GROUP_MEMBER_REMOVE: `${prefix} group member remove`,
     GROUP_REMOVE: `${prefix} group remove`,
     GROUP_SET: `${prefix} group set`,
     GROUP_MEMBER_ADD: `${prefix} group member add`,

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

@@ -29,7 +29,7 @@ class FlowListCommand extends PowerAutomateCommand {
     }
     async commandAction(logger, args) {
         if (this.verbose) {
-            await logger.logToStderr(`Getting Power Automate flows${args.options.asAdmin && ' as admin'} in environment '${args.options.environmentName}'...`);
+            await logger.logToStderr(`Getting Power Automate flows${args.options.asAdmin ? ' as admin' : ''} in environment '${args.options.environmentName}'...`);
         }
         try {
             const { environmentName, asAdmin, sharingStatus, includeSolutions } = args.options;

package/dist/m365/graph/commands/openextension/openextension-get.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { globalOptionsZod } from '../../../../Command.js';
+import { zod } from '../../../../utils/zod.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import request from '../../../../request.js';
+const options = globalOptionsZod
+    .extend({
+    resourceId: zod.alias('i', z.string()),
+    resourceType: zod.alias('t', z.enum(['user', 'group', 'device', 'organization'])),
+    name: zod.alias('n', z.string())
+})
+    .strict();
+class GraphOpenExtensionGetCommand extends GraphCommand {
+    get name() {
+        return commands.OPENEXTENSION_GET;
+    }
+    get description() {
+        return 'Retrieves a specific open extension for a resource';
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), options => ({
+            message: `The '${options.resourceId}' must be a valid GUID`,
+            path: ['resourceId']
+        }))
+            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), options => ({
+            message: `The '${options.resourceId}' must be a valid GUID or user principal name`,
+            path: ['resourceId']
+        }));
+    }
+    async commandAction(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving open extension for resource ${args.options.resourceId}...`);
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/${args.options.resourceType}${args.options.resourceType === 'organization' ? '' : 's'}/${args.options.resourceId}/extensions/${args.options.name}`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            const res = await request.get(requestOptions);
+            await logger.log(res);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new GraphOpenExtensionGetCommand();
+//# sourceMappingURL=openextension-get.js.map

package/dist/m365/graph/commands/openextension/openextension-list.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { globalOptionsZod } from '../../../../Command.js';
+import { zod } from '../../../../utils/zod.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import { odata } from '../../../../utils/odata.js';
+const options = globalOptionsZod
+    .extend({
+    resourceId: zod.alias('i', z.string()),
+    resourceType: zod.alias('t', z.enum(['user', 'group', 'device', 'organization']))
+})
+    .strict();
+class GraphOpenExtensionListCommand extends GraphCommand {
+    get name() {
+        return commands.OPENEXTENSION_LIST;
+    }
+    get description() {
+        return 'Retrieves all open extensions for a resource';
+    }
+    defaultProperties() {
+        return ['id', 'extensionName'];
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' ||
+            (options.resourceId && validation.isValidGuid(options.resourceId)), options => ({
+            message: `The '${options.resourceId}' must be a valid GUID`,
+            path: ['resourceId']
+        }))
+            .refine(options => options.resourceType !== 'user' ||
+            (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), options => ({
+            message: `The '${options.resourceId}' must be a valid GUID or user principal name`,
+            path: ['resourceId']
+        }));
+    }
+    async commandAction(logger, args) {
+        try {
+            const requestOptions = {
+                url: `${this.resource}/v1.0/${args.options.resourceType}${args.options.resourceType === 'organization' ? '' : 's'}/${args.options.resourceId}/extensions`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none',
+                    'content-type': 'application/json'
+                },
+                responseType: 'json'
+            };
+            if (args.options.verbose) {
+                await logger.logToStderr(`Retrieving open extensions for the ${args.options.resourceType} with id '${args.options.resourceId}'...`);
+            }
+            const res = await odata.getAllItems(requestOptions);
+            await logger.log(res);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new GraphOpenExtensionListCommand();
+//# sourceMappingURL=openextension-list.js.map

package/dist/m365/graph/commands/openextension/openextension-remove.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { globalOptionsZod } from '../../../../Command.js';
+import { zod } from '../../../../utils/zod.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import { cli } from '../../../../cli/cli.js';
+import request from '../../../../request.js';
+const options = globalOptionsZod
+    .extend({
+    resourceId: zod.alias('i', z.string()),
+    resourceType: zod.alias('t', z.enum(['user', 'group', 'device', 'organization'])),
+    name: zod.alias('n', z.string()),
+    force: zod.alias('f', z.boolean().optional())
+})
+    .strict();
+class GraphOpenExtensionRemoveCommand extends GraphCommand {
+    get name() {
+        return commands.OPENEXTENSION_REMOVE;
+    }
+    get description() {
+        return 'Removes a specific open extension for a resource';
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), options => ({
+            message: `The '${options.resourceId}' must be a valid GUID`,
+            path: ['resourceId']
+        }))
+            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), options => ({
+            message: `The '${options.resourceId}' must be a valid GUID or user principal name`,
+            path: ['resourceId']
+        }));
+    }
+    async commandAction(logger, args) {
+        const removeOpenExtension = async () => {
+            try {
+                if (this.verbose) {
+                    await logger.logToStderr(`Removing open extension for resource ${args.options.resourceId}...`);
+                }
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/${args.options.resourceType}${args.options.resourceType === 'organization' ? '' : 's'}/${args.options.resourceId}/extensions/${args.options.name}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    }
+                };
+                await request.delete(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeOpenExtension();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove open extension '${args.options.name}' from resource '${args.options.resourceId}' of type '${args.options.resourceType}'?` });
+            if (result) {
+                await removeOpenExtension();
+            }
+        }
+    }
+}
+export default new GraphOpenExtensionRemoveCommand();
+//# sourceMappingURL=openextension-remove.js.map

package/dist/m365/graph/commands.js

@@ -5,6 +5,9 @@ export default {
     DIRECTORYEXTENSION_GET: `${prefix} directoryextension get`,
     DIRECTORYEXTENSION_REMOVE: `${prefix} directoryextension remove`,
     OPENEXTENSION_ADD: `${prefix} openextension add`,
+    OPENEXTENSION_GET: `${prefix} openextension get`,
+    OPENEXTENSION_LIST: `${prefix} openextension list`,
+    OPENEXTENSION_REMOVE: `${prefix} openextension remove`,
     SCHEMAEXTENSION_ADD: `${prefix} schemaextension add`,
     SCHEMAEXTENSION_GET: `${prefix} schemaextension get`,
     SCHEMAEXTENSION_LIST: `${prefix} schemaextension list`,

package/dist/m365/pp/commands/card/card-clone.js

@@ -35,13 +35,19 @@ class PpCardCloneCommand extends PowerPlatformCommand {
         if (args.options.id) {
             return args.options.id;
         }
-        const card = await powerPlatform.getCardByName(dynamicsApiUrl, args.options.name, logger, this.verbose);
+        if (this.verbose) {
+            await logger.logToStderr(`Retrieving the card Id for card '${args.options.name}'`);
+        }
+        const card = await powerPlatform.getCardByName(dynamicsApiUrl, args.options.name);
         return card.cardid;
     }
     async cloneCard(args, logger) {
         try {
             const dynamicsApiUrl = await powerPlatform.getDynamicsInstanceApiUrl(args.options.environmentName, args.options.asAdmin);
             const cardId = await this.getCardId(args, dynamicsApiUrl, logger);
+            if (this.verbose) {
+                await logger.logToStderr(`Cloning the card with id '${cardId}'`);
+            }
             const requestOptions = {
                 url: `${dynamicsApiUrl}/api/data/v9.1/CardCreateClone`,
                 headers: {

package/dist/m365/pp/commands/card/card-get.js

@@ -39,10 +39,13 @@ class PpCardGetCommand extends PowerPlatformCommand {
     }
     async getCard(dynamicsApiUrl, options, logger) {
         if (options.name) {
-            return await powerPlatform.getCardByName(dynamicsApiUrl, options.name, logger, this.verbose);
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving the card with name '${options.name}'`);
+            }
+            return await powerPlatform.getCardByName(dynamicsApiUrl, options.name);
         }
         if (this.verbose) {
-            await logger.logToStderr(`Retrieving the card with id ${options.id}`);
+            await logger.logToStderr(`Retrieving the card with id '${options.id}'`);
         }
         const requestOptions = {
             url: `${dynamicsApiUrl}/api/data/v9.1/cards(${options.id})`,

package/dist/m365/pp/commands/card/card-remove.js

@@ -43,13 +43,19 @@ class PpCardRemoveCommand extends PowerPlatformCommand {
         if (args.options.id) {
             return args.options.id;
         }
-        const card = await powerPlatform.getCardByName(dynamicsApiUrl, args.options.name, logger, this.verbose);
+        if (this.verbose) {
+            await logger.logToStderr(`Retrieving the card with name '${args.options.name}'`);
+        }
+        const card = await powerPlatform.getCardByName(dynamicsApiUrl, args.options.name);
         return card.cardid;
     }
     async deleteCard(args, logger) {
         try {
             const dynamicsApiUrl = await powerPlatform.getDynamicsInstanceApiUrl(args.options.environmentName, args.options.asAdmin);
             const cardId = await this.getCardId(args, dynamicsApiUrl, logger);
+            if (this.verbose) {
+                await logger.logToStderr(`Deleting card with Id '${cardId}'`);
+            }
             const requestOptions = {
                 url: `${dynamicsApiUrl}/api/data/v9.1/cards(${cardId})`,
                 headers: {

package/dist/m365/pp/commands/solution/solution-get.js

@@ -49,23 +49,17 @@ class PpSolutionGetCommand extends PowerPlatformCommand {
         }
     }
     async getSolution(dynamicsApiUrl, options) {
+        if (options.name) {
+            return powerPlatform.getSolutionByName(dynamicsApiUrl, options.name);
+        }
         const requestOptions = {
             headers: {
                 accept: 'application/json;odata.metadata=none'
             },
             responseType: 'json'
         };
-        if (options.id) {
-            requestOptions.url = `${dynamicsApiUrl}/api/data/v9.0/solutions(${options.id})?$expand=publisherid($select=friendlyname)&$select=solutionid,uniquename,version,publisherid,installedon,solutionpackageversion,friendlyname,versionnumber&api-version=9.1`;
-            const result = await request.get(requestOptions);
-            return result;
-        }
-        requestOptions.url = `${dynamicsApiUrl}/api/data/v9.0/solutions?$filter=isvisible eq true and uniquename eq \'${options.name}\'&$expand=publisherid($select=friendlyname)&$select=solutionid,uniquename,version,publisherid,installedon,solutionpackageversion,friendlyname,versionnumber&api-version=9.1`;
-        const result = await request.get(requestOptions);
-        if (result.value.length === 0) {
-            throw `The specified solution '${options.name}' does not exist.`;
-        }
-        return result.value[0];
+        requestOptions.url = `${dynamicsApiUrl}/api/data/v9.0/solutions(${options.id})?$expand=publisherid($select=friendlyname)&$select=solutionid,uniquename,version,publisherid,installedon,solutionpackageversion,friendlyname,versionnumber&api-version=9.1`;
+        return request.get(requestOptions);
     }
 }
 _PpSolutionGetCommand_instances = new WeakSet(), _PpSolutionGetCommand_initTelemetry = function _PpSolutionGetCommand_initTelemetry() {