powerplatform-mcp 0.4.5 → 1.0.0

package/build/services/PluginService.js

@@ -0,0 +1,288 @@
+/**
+ * PluginService
+ *
+ * Read-only service for plugin assemblies, types, steps, images, and trace logs.
+ */
+export class PluginService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get all plugin assemblies in the environment
+     */
+    async getPluginAssemblies(includeManaged = false, maxRecords = 100) {
+        const managedFilter = includeManaged ? '' : '$filter=ismanaged eq false&';
+        const assemblies = await this.client.get(`api/data/v9.2/pluginassemblies?${managedFilter}$select=pluginassemblyid,name,version,culture,publickeytoken,isolationmode,sourcetype,major,minor,createdon,modifiedon,ismanaged,ishidden&$expand=modifiedby($select=fullname)&$orderby=name&$top=${maxRecords}`);
+        // Filter out hidden assemblies and format results
+        const formattedAssemblies = assemblies.value
+            .filter((assembly) => {
+            const isHidden = assembly.ishidden?.Value !== undefined
+                ? assembly.ishidden.Value
+                : assembly.ishidden;
+            return !isHidden;
+        })
+            .map((assembly) => ({
+            pluginassemblyid: assembly.pluginassemblyid,
+            name: assembly.name,
+            version: assembly.version,
+            isolationMode: assembly.isolationmode === 1
+                ? 'None'
+                : assembly.isolationmode === 2
+                    ? 'Sandbox'
+                    : 'External',
+            isManaged: assembly.ismanaged,
+            modifiedOn: assembly.modifiedon,
+            modifiedBy: assembly.modifiedby?.fullname,
+            major: assembly.major,
+            minor: assembly.minor,
+        }));
+        return {
+            totalCount: formattedAssemblies.length,
+            assemblies: formattedAssemblies,
+        };
+    }
+    /**
+     * Get a plugin assembly by name with all related plugin types, steps, and images
+     */
+    async getPluginAssemblyComplete(assemblyName, includeDisabled = false) {
+        // Get the plugin assembly
+        const assemblies = await this.client.get(`api/data/v9.2/pluginassemblies?$filter=name eq '${assemblyName}'&$select=pluginassemblyid,name,version,culture,publickeytoken,isolationmode,sourcetype,major,minor,createdon,modifiedon,ismanaged,ishidden,description&$expand=modifiedby($select=fullname)`);
+        if (!assemblies.value || assemblies.value.length === 0) {
+            throw new Error(`Plugin assembly '${assemblyName}' not found`);
+        }
+        const assembly = assemblies.value[0];
+        const assemblyId = assembly.pluginassemblyid;
+        // Get plugin types
+        const pluginTypes = await this.client.get(`api/data/v9.2/plugintypes?$filter=_pluginassemblyid_value eq ${assemblyId}&$select=plugintypeid,typename,friendlyname,name,assemblyname,description,workflowactivitygroupname`);
+        // Get all steps for each plugin type
+        const pluginTypeIds = pluginTypes.value.map((pt) => pt.plugintypeid);
+        let allSteps = [];
+        if (pluginTypeIds.length > 0) {
+            const statusFilter = includeDisabled ? '' : ' and statuscode eq 1';
+            const typeFilter = pluginTypeIds
+                .map((id) => `_plugintypeid_value eq ${id}`)
+                .join(' or ');
+            const steps = await this.client.get(`api/data/v9.2/sdkmessageprocessingsteps?$filter=(${typeFilter})${statusFilter}&$select=sdkmessageprocessingstepid,name,stage,mode,rank,statuscode,asyncautodelete,filteringattributes,supporteddeployment,configuration,description,invocationsource,_plugintypeid_value,_sdkmessagefilterid_value,_impersonatinguserid_value,_eventhandler_value&$expand=sdkmessageid($select=name),plugintypeid($select=typename),impersonatinguserid($select=fullname),modifiedby($select=fullname),sdkmessagefilterid($select=primaryobjecttypecode)&$orderby=stage,rank`);
+            allSteps = steps.value;
+        }
+        // Get all images for these steps
+        const stepIds = allSteps.map((s) => s.sdkmessageprocessingstepid);
+        let allImages = [];
+        if (stepIds.length > 0) {
+            const imageFilter = stepIds
+                .map((id) => `_sdkmessageprocessingstepid_value eq ${id}`)
+                .join(' or ');
+            const images = await this.client.get(`api/data/v9.2/sdkmessageprocessingstepimages?$filter=${imageFilter}&$select=sdkmessageprocessingstepimageid,name,imagetype,messagepropertyname,entityalias,attributes,_sdkmessageprocessingstepid_value`);
+            allImages = images.value;
+        }
+        // Attach images to their respective steps
+        const stepsWithImages = allSteps.map((step) => ({
+            ...step,
+            images: allImages.filter((img) => img._sdkmessageprocessingstepid_value ===
+                step.sdkmessageprocessingstepid),
+        }));
+        // Validation checks
+        const validation = {
+            hasDisabledSteps: allSteps.some((s) => s.statuscode !== 1),
+            hasAsyncSteps: allSteps.some((s) => s.mode === 1),
+            hasSyncSteps: allSteps.some((s) => s.mode === 0),
+            stepsWithoutFilteringAttributes: stepsWithImages
+                .filter((s) => {
+                const sdkmsg = s.sdkmessageid;
+                const msgName = sdkmsg?.name;
+                return ((msgName === 'Update' || msgName === 'Delete') &&
+                    !s.filteringattributes);
+            })
+                .map((s) => s.name),
+            stepsWithoutImages: stepsWithImages
+                .filter((s) => {
+                const sdkmsg = s.sdkmessageid;
+                const msgName = sdkmsg?.name;
+                return (s.images.length === 0 &&
+                    (msgName === 'Update' || msgName === 'Delete'));
+            })
+                .map((s) => s.name),
+            potentialIssues: [],
+        };
+        if (validation.stepsWithoutFilteringAttributes.length > 0) {
+            validation.potentialIssues.push(`${validation.stepsWithoutFilteringAttributes.length} Update/Delete steps without filtering attributes (performance concern)`);
+        }
+        if (validation.stepsWithoutImages.length > 0) {
+            validation.potentialIssues.push(`${validation.stepsWithoutImages.length} Update/Delete steps without images (may need entity data)`);
+        }
+        return {
+            assembly,
+            pluginTypes: pluginTypes.value,
+            steps: stepsWithImages,
+            validation,
+        };
+    }
+    /**
+     * Get all plugins that execute on a specific entity
+     */
+    async getEntityPluginPipeline(entityName, messageFilter, includeDisabled = false) {
+        const statusFilter = includeDisabled ? '' : ' and statuscode eq 1';
+        const msgFilter = messageFilter
+            ? ` and sdkmessageid/name eq '${messageFilter}'`
+            : '';
+        const steps = await this.client.get(`api/data/v9.2/sdkmessageprocessingsteps?$filter=sdkmessagefilterid/primaryobjecttypecode eq '${entityName}'${statusFilter}${msgFilter}&$select=sdkmessageprocessingstepid,name,stage,mode,rank,statuscode,asyncautodelete,filteringattributes,supporteddeployment,configuration,description,_plugintypeid_value,_sdkmessagefilterid_value,_impersonatinguserid_value&$expand=sdkmessageid($select=name),plugintypeid($select=typename),impersonatinguserid($select=fullname),sdkmessagefilterid($select=primaryobjecttypecode)&$orderby=stage,rank`);
+        // Get assembly information for each plugin type
+        const pluginTypeIds = [
+            ...new Set(steps.value
+                .map((s) => s._plugintypeid_value)
+                .filter((id) => id != null)),
+        ];
+        const assemblyMap = new Map();
+        for (const typeId of pluginTypeIds) {
+            const pluginType = await this.client.get(`api/data/v9.2/plugintypes(${typeId})?$expand=pluginassemblyid($select=name,version)`);
+            assemblyMap.set(typeId, pluginType.pluginassemblyid);
+        }
+        // Get images for all steps
+        const stepIds = steps.value.map((s) => s.sdkmessageprocessingstepid);
+        let allImages = [];
+        if (stepIds.length > 0) {
+            const imageFilter = stepIds
+                .map((id) => `_sdkmessageprocessingstepid_value eq ${id}`)
+                .join(' or ');
+            const images = await this.client.get(`api/data/v9.2/sdkmessageprocessingstepimages?$filter=${imageFilter}&$select=sdkmessageprocessingstepimageid,name,imagetype,messagepropertyname,entityalias,attributes,_sdkmessageprocessingstepid_value`);
+            allImages = images.value;
+        }
+        // Format steps
+        const formattedSteps = steps.value.map((step) => {
+            const assembly = assemblyMap.get(step._plugintypeid_value);
+            const images = allImages.filter((img) => img._sdkmessageprocessingstepid_value ===
+                step.sdkmessageprocessingstepid);
+            return {
+                sdkmessageprocessingstepid: step.sdkmessageprocessingstepid,
+                name: step.name,
+                stage: step.stage,
+                stageName: step.stage === 10
+                    ? 'PreValidation'
+                    : step.stage === 20
+                        ? 'PreOperation'
+                        : 'PostOperation',
+                mode: step.mode,
+                modeName: step.mode === 0 ? 'Synchronous' : 'Asynchronous',
+                rank: step.rank,
+                message: step.sdkmessageid?.name,
+                pluginType: step.plugintypeid?.typename,
+                assemblyName: assembly?.name,
+                assemblyVersion: assembly?.version,
+                filteringAttributes: step.filteringattributes
+                    ? step.filteringattributes.split(',')
+                    : [],
+                statuscode: step.statuscode,
+                enabled: step.statuscode === 1,
+                deployment: step.supporteddeployment === 0
+                    ? 'Server'
+                    : step.supporteddeployment === 1
+                        ? 'Offline'
+                        : 'Both',
+                impersonatingUser: step.impersonatinguserid
+                    ?.fullname,
+                hasPreImage: images.some((img) => img.imagetype === 0 || img.imagetype === 2),
+                hasPostImage: images.some((img) => img.imagetype === 1 || img.imagetype === 2),
+                images,
+            };
+        });
+        // Organize by message
+        const messageGroups = new Map();
+        formattedSteps.forEach((step) => {
+            if (!messageGroups.has(step.message)) {
+                messageGroups.set(step.message, {
+                    messageName: step.message,
+                    stages: {
+                        preValidation: [],
+                        preOperation: [],
+                        postOperation: [],
+                    },
+                });
+            }
+            const msg = messageGroups.get(step.message);
+            if (step.stage === 10)
+                msg.stages.preValidation.push(step);
+            else if (step.stage === 20)
+                msg.stages.preOperation.push(step);
+            else if (step.stage === 40)
+                msg.stages.postOperation.push(step);
+        });
+        return {
+            entity: entityName,
+            messages: Array.from(messageGroups.values()),
+            steps: formattedSteps,
+            executionOrder: formattedSteps.map((s) => s.name),
+        };
+    }
+    /**
+     * Get plugin trace logs with filtering
+     */
+    async getPluginTraceLogs(options) {
+        const { entityName, messageName, correlationId, pluginStepId, exceptionOnly = false, hoursBack = 24, maxRecords = 50, } = options;
+        // Build filter
+        const filters = [];
+        const dateThreshold = new Date();
+        dateThreshold.setHours(dateThreshold.getHours() - hoursBack);
+        filters.push(`createdon gt ${dateThreshold.toISOString()}`);
+        if (entityName)
+            filters.push(`primaryentity eq '${entityName}'`);
+        if (messageName)
+            filters.push(`messagename eq '${messageName}'`);
+        if (correlationId)
+            filters.push(`correlationid eq '${correlationId}'`);
+        if (pluginStepId)
+            filters.push(`_sdkmessageprocessingstepid_value eq ${pluginStepId}`);
+        if (exceptionOnly)
+            filters.push(`exceptiondetails ne null`);
+        const filterString = filters.join(' and ');
+        const logs = await this.client.get(`api/data/v9.2/plugintracelogs?$filter=${filterString}&$orderby=createdon desc&$top=${maxRecords}`);
+        // Parse logs for better readability
+        const parsedLogs = logs.value.map((log) => ({
+            ...log,
+            modeName: log.mode === 0 ? 'Synchronous' : 'Asynchronous',
+            operationTypeName: this.getOperationTypeName(log.operationtype),
+            parsed: {
+                hasException: !!log.exceptiondetails,
+                exceptionType: log.exceptiondetails
+                    ? this.extractExceptionType(log.exceptiondetails)
+                    : null,
+                exceptionMessage: log.exceptiondetails
+                    ? this.extractExceptionMessage(log.exceptiondetails)
+                    : null,
+                stackTrace: log.exceptiondetails,
+            },
+        }));
+        return {
+            totalCount: parsedLogs.length,
+            logs: parsedLogs,
+        };
+    }
+    getOperationTypeName(operationType) {
+        const types = {
+            0: 'None',
+            1: 'Create',
+            2: 'Update',
+            3: 'Delete',
+            4: 'Retrieve',
+            5: 'RetrieveMultiple',
+            6: 'Associate',
+            7: 'Disassociate',
+        };
+        return types[operationType] || 'Unknown';
+    }
+    extractExceptionType(exceptionDetails) {
+        const match = exceptionDetails.match(/^([^:]+):/);
+        return match ? match[1].trim() : null;
+    }
+    extractExceptionMessage(exceptionDetails) {
+        const lines = exceptionDetails.split('\n');
+        if (lines.length > 0) {
+            const firstLine = lines[0];
+            const colonIndex = firstLine.indexOf(':');
+            if (colonIndex > 0) {
+                return firstLine.substring(colonIndex + 1).trim();
+            }
+        }
+        return null;
+    }
+}

package/build/services/RecordService.js

@@ -0,0 +1,29 @@
+/**
+ * Service for record operations.
+ * Handles CRUD operations on Dataverse records.
+ */
+export class RecordService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a specific record by entity name (plural) and ID
+     * @param entityNamePlural The plural name of the entity (e.g., 'accounts', 'contacts')
+     * @param recordId The GUID of the record
+     * @returns The record data
+     */
+    async getRecord(entityNamePlural, recordId) {
+        return this.client.get(`api/data/v9.2/${entityNamePlural}(${recordId})`);
+    }
+    /**
+     * Query records using entity name (plural) and a filter expression
+     * @param entityNamePlural The plural name of the entity (e.g., 'accounts', 'contacts')
+     * @param filter OData filter expression (e.g., "name eq 'test'")
+     * @param maxRecords Maximum number of records to retrieve (default: 50)
+     * @returns Filtered list of records
+     */
+    async queryRecords(entityNamePlural, filter, maxRecords = 50) {
+        return this.client.get(`api/data/v9.2/${entityNamePlural}?$filter=${encodeURIComponent(filter)}&$top=${maxRecords}`);
+    }
+}

package/build/services/index.js

@@ -0,0 +1,4 @@
+export { EntityService } from './EntityService.js';
+export { RecordService } from './RecordService.js';
+export { OptionSetService } from './OptionSetService.js';
+export { PluginService } from './PluginService.js';

package/build/tools/entityTools.js

@@ -0,0 +1,156 @@
+import { z } from "zod";
+/**
+ * Register entity metadata tools with the MCP server.
+ */
+export function registerEntityTools(server, ctx) {
+    // Get Entity Metadata
+    server.registerTool("get-entity-metadata", {
+        title: "Get Entity Metadata",
+        description: "Get metadata about a PowerPlatform entity",
+        inputSchema: {
+            entityName: z.string().describe("The logical name of the entity"),
+        },
+        outputSchema: z.object({
+            entityName: z.string(),
+            metadata: z.any(),
+        }),
+    }, async ({ entityName }) => {
+        try {
+            const service = ctx.getEntityService();
+            const metadata = await service.getEntityMetadata(entityName);
+            return {
+                structuredContent: { entityName, metadata },
+                content: [
+                    {
+                        type: "text",
+                        text: `Entity metadata for '${entityName}':\n\n${JSON.stringify(metadata, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error("Error getting entity metadata:", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get entity metadata: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    });
+    // Get Entity Attributes
+    server.registerTool("get-entity-attributes", {
+        title: "Get Entity Attributes",
+        description: "Get attributes/fields of a PowerPlatform entity",
+        inputSchema: {
+            entityName: z.string().describe("The logical name of the entity"),
+        },
+        outputSchema: z.object({
+            entityName: z.string(),
+            attributes: z.any(),
+        }),
+    }, async ({ entityName }) => {
+        try {
+            const service = ctx.getEntityService();
+            const attributes = await service.getEntityAttributes(entityName);
+            return {
+                structuredContent: { entityName, attributes },
+                content: [
+                    {
+                        type: "text",
+                        text: `Attributes for entity '${entityName}':\n\n${JSON.stringify(attributes, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error("Error getting entity attributes:", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get entity attributes: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    });
+    // Get Entity Attribute
+    server.registerTool("get-entity-attribute", {
+        title: "Get Entity Attribute",
+        description: "Get a specific attribute/field of a PowerPlatform entity",
+        inputSchema: {
+            entityName: z.string().describe("The logical name of the entity"),
+            attributeName: z.string().describe("The logical name of the attribute"),
+        },
+        outputSchema: z.object({
+            entityName: z.string(),
+            attributeName: z.string(),
+            attribute: z.any(),
+        }),
+    }, async ({ entityName, attributeName }) => {
+        try {
+            const service = ctx.getEntityService();
+            const attribute = await service.getEntityAttribute(entityName, attributeName);
+            return {
+                structuredContent: { entityName, attributeName, attribute },
+                content: [
+                    {
+                        type: "text",
+                        text: `Attribute '${attributeName}' for entity '${entityName}':\n\n${JSON.stringify(attribute, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error("Error getting entity attribute:", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get entity attribute: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    });
+    // Get Entity Relationships
+    server.registerTool("get-entity-relationships", {
+        title: "Get Entity Relationships",
+        description: "Get relationships (one-to-many and many-to-many) for a PowerPlatform entity",
+        inputSchema: {
+            entityName: z.string().describe("The logical name of the entity"),
+        },
+        outputSchema: z.object({
+            entityName: z.string(),
+            relationships: z.any(),
+        }),
+    }, async ({ entityName }) => {
+        try {
+            const service = ctx.getEntityService();
+            const relationships = await service.getEntityRelationships(entityName);
+            return {
+                structuredContent: { entityName, relationships },
+                content: [
+                    {
+                        type: "text",
+                        text: `Relationships for entity '${entityName}':\n\n${JSON.stringify(relationships, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error("Error getting entity relationships:", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get entity relationships: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/index.js

@@ -0,0 +1,17 @@
+import { registerEntityTools } from "./entityTools.js";
+import { registerRecordTools } from "./recordTools.js";
+import { registerOptionSetTools } from "./optionSetTools.js";
+import { registerPluginTools } from "./pluginTools.js";
+export { registerEntityTools } from "./entityTools.js";
+export { registerRecordTools } from "./recordTools.js";
+export { registerOptionSetTools } from "./optionSetTools.js";
+export { registerPluginTools } from "./pluginTools.js";
+/**
+ * Register all tools with the MCP server.
+ */
+export function registerAllTools(server, ctx) {
+    registerEntityTools(server, ctx);
+    registerRecordTools(server, ctx);
+    registerOptionSetTools(server, ctx);
+    registerPluginTools(server, ctx);
+}

package/build/tools/optionSetTools.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+/**
+ * Register option set tools with the MCP server.
+ */
+export function registerOptionSetTools(server, ctx) {
+    // Get Global Option Set
+    server.registerTool("get-global-option-set", {
+        title: "Get Global Option Set",
+        description: "Get a global option set definition by name",
+        inputSchema: {
+            optionSetName: z.string().describe("The name of the global option set"),
+        },
+        outputSchema: z.object({
+            optionSetName: z.string(),
+            optionSet: z.any(),
+        }),
+    }, async ({ optionSetName }) => {
+        try {
+            const service = ctx.getOptionSetService();
+            const optionSet = await service.getGlobalOptionSet(optionSetName);
+            return {
+                structuredContent: { optionSetName, optionSet },
+                content: [
+                    {
+                        type: "text",
+                        text: `Global option set '${optionSetName}':\n\n${JSON.stringify(optionSet, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error("Error getting global option set:", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to get global option set: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    });
+}