@mcp-consultant-tools/powerplatform-customization 25.0.0-beta.5 → 26.0.0-beta.2

package/build/index.js

@@ -5,7 +5,7 @@ import { pathToFileURL } from 'node:url';
 import { realpathSync } from 'node:fs';
 import { createMcpServer, createEnvLoader } from '@mcp-consultant-tools/core';
 import { PowerPlatformService } from './PowerPlatformService.js';
-import { initializePublisherPrefix } from './utils/publisherConfig.js';
+import { initializePublisherPrefix } from '@mcp-consultant-tools/powerplatform-core';
 const POWERPLATFORM_DEFAULT_SOLUTION = process.env.POWERPLATFORM_DEFAULT_SOLUTION || "";
 /**
  * Register powerplatform-customization tools with an MCP server
@@ -1110,25 +1110,12 @@ export function registerPowerplatformCustomizationTools(server, service) {
     }, async (params) => {
         try {
             const service = getPowerPlatformService();
-            // Look up the global option set to get its MetadataId
-            const globalOptionSet = await service.getGlobalOptionSet(params.globalOptionSetName);
-            const metadataId = globalOptionSet.MetadataId;
-            const attributeDefinition = {
-                "@odata.type": "Microsoft.Dynamics.CRM.PicklistAttributeMetadata",
-                SchemaName: params.schemaName,
-                DisplayName: {
-                    "@odata.type": "Microsoft.Dynamics.CRM.Label",
-                    LocalizedLabels: [{ "@odata.type": "Microsoft.Dynamics.CRM.LocalizedLabel", Label: params.displayName, LanguageCode: 1033 }]
-                },
-                Description: {
-                    "@odata.type": "Microsoft.Dynamics.CRM.Label",
-                    LocalizedLabels: [{ "@odata.type": "Microsoft.Dynamics.CRM.LocalizedLabel", Label: params.description || "", LanguageCode: 1033 }]
-                },
-                RequiredLevel: { Value: params.requiredLevel || "None", CanBeChanged: true },
-                "GlobalOptionSet@odata.bind": `/GlobalOptionSetDefinitions(${metadataId})`
-            };
             const solution = params.solutionUniqueName || POWERPLATFORM_DEFAULT_SOLUTION;
-            const result = await service.createGlobalOptionSetAttribute(params.entityLogicalName, attributeDefinition, solution);
+            const result = await service.createGlobalOptionSetAttribute(params.entityLogicalName, params.schemaName, params.displayName, params.globalOptionSetName, {
+                description: params.description,
+                requiredLevel: params.requiredLevel,
+                solutionUniqueName: solution
+            });
             return {
                 content: [{ type: "text", text: `✅ Successfully created global option set attribute '${params.schemaName}' using '${params.globalOptionSetName}'\n\n⚠️ IMPORTANT: You must publish this customization using the 'publish-customizations' tool before it becomes active.` }]
             };
@@ -1325,16 +1312,8 @@ export function registerPowerplatformCustomizationTools(server, service) {
     }, async ({ name, entityLogicalName, formType, formXml, description, solutionUniqueName }) => {
         try {
             const service = getPowerPlatformService();
-            const typeMap = { Main: 2, QuickCreate: 7, QuickView: 8, Card: 10 };
-            const form = {
-                name,
-                objecttypecode: entityLogicalName,
-                type: typeMap[formType],
-                formxml: formXml,
-                description: description || ""
-            };
             const solution = solutionUniqueName || POWERPLATFORM_DEFAULT_SOLUTION;
-            const result = await service.createForm(form, solution);
+            const result = await service.createForm(name, entityLogicalName, formType, formXml, { description, solutionUniqueName: solution });
             return {
                 content: [
                     {
@@ -1474,17 +1453,13 @@ export function registerPowerplatformCustomizationTools(server, service) {
     }, async ({ name, entityLogicalName, fetchXml, layoutXml, queryType, isDefault, description, solutionUniqueName }) => {
         try {
             const service = getPowerPlatformService();
-            const view = {
-                name,
-                returnedtypecode: entityLogicalName,
-                fetchxml: fetchXml,
-                layoutxml: layoutXml,
-                querytype: queryType || 0,
-                isdefault: isDefault || false,
-                description: description || ""
-            };
             const solution = solutionUniqueName || POWERPLATFORM_DEFAULT_SOLUTION;
-            const result = await service.createView(view, solution);
+            const result = await service.createView(name, entityLogicalName, fetchXml, layoutXml, {
+                queryType: queryType || 0,
+                isDefault: isDefault || false,
+                description,
+                solutionUniqueName: solution
+            });
             return {
                 content: [
                     {
@@ -1604,15 +1579,8 @@ export function registerPowerplatformCustomizationTools(server, service) {
     }, async ({ name, displayName, webResourceType, content, description, solutionUniqueName }) => {
         try {
             const service = getPowerPlatformService();
-            const webResource = {
-                name,
-                displayname: displayName,
-                webresourcetype: webResourceType,
-                content,
-                description: description || ""
-            };
             const solution = solutionUniqueName || POWERPLATFORM_DEFAULT_SOLUTION;
-            const result = await service.createWebResource(webResource, solution);
+            const result = await service.createWebResource(name, displayName, webResourceType, content, { description, solutionUniqueName: solution });
             return {
                 content: [
                     {
@@ -1701,14 +1669,7 @@ export function registerPowerplatformCustomizationTools(server, service) {
     }, async ({ uniqueName, friendlyName, customizationPrefix, customizationOptionValuePrefix, description }) => {
         try {
             const service = getPowerPlatformService();
-            const publisher = {
-                uniquename: uniqueName,
-                friendlyname: friendlyName,
-                customizationprefix: customizationPrefix,
-                customizationoptionvalueprefix: customizationOptionValuePrefix,
-                description: description || ""
-            };
-            const result = await service.createPublisher(publisher);
+            const result = await service.createPublisher(uniqueName, friendlyName, customizationPrefix, customizationOptionValuePrefix, description);
             return {
                 content: [
                     {
@@ -1739,14 +1700,7 @@ export function registerPowerplatformCustomizationTools(server, service) {
     }, async ({ uniqueName, friendlyName, version, publisherId, description }) => {
         try {
             const service = getPowerPlatformService();
-            const solution = {
-                uniquename: uniqueName,
-                friendlyname: friendlyName,
-                version,
-                "publisherid@odata.bind": `/publishers(${publisherId})`,
-                description: description || ""
-            };
-            const result = await service.createSolution(solution);
+            const result = await service.createSolution(uniqueName, friendlyName, version, publisherId, description);
             return {
                 content: [
                     {
@@ -1773,10 +1727,10 @@ export function registerPowerplatformCustomizationTools(server, service) {
         componentType: z.number().describe("Component type: 1=Entity, 2=Attribute, 9=OptionSet, 24=Form, 26=SavedQuery, 29=Workflow, 60=SystemForm, 61=WebResource"),
         addRequiredComponents: z.boolean().optional().describe("Add required components (default: true)"),
         includedComponentSettingsValues: z.string().optional().describe("Component settings values")
-    }, async ({ solutionUniqueName, componentId, componentType, addRequiredComponents, includedComponentSettingsValues }) => {
+    }, async ({ solutionUniqueName, componentId, componentType, addRequiredComponents }) => {
         try {
             const service = getPowerPlatformService();
-            await service.addComponentToSolution(solutionUniqueName, componentId, componentType, addRequiredComponents ?? true, includedComponentSettingsValues);
+            await service.addComponentToSolution(solutionUniqueName, componentId, componentType, addRequiredComponents ?? true);
             return {
                 content: [
                     {
@@ -1831,7 +1785,7 @@ export function registerPowerplatformCustomizationTools(server, service) {
                     {
                         type: "text",
                         text: `✅ Successfully exported solution '${solutionName}' as ${managed ? 'managed' : 'unmanaged'}\n\n` +
-                            `Export File (Base64): ${result.ExportSolutionFile.substring(0, 100)}...`
+                            `Export File (Base64): ${(result.ExportSolutionFile || result).substring(0, 100)}...`
                     }
                 ]
             };
@@ -1851,7 +1805,7 @@ export function registerPowerplatformCustomizationTools(server, service) {
     }, async ({ customizationFile, publishWorkflows, overwriteUnmanagedCustomizations }) => {
         try {
             const service = getPowerPlatformService();
-            const result = await service.importSolution(customizationFile, publishWorkflows ?? true, overwriteUnmanagedCustomizations ?? false);
+            const result = await service.importSolution(customizationFile, overwriteUnmanagedCustomizations ?? false, publishWorkflows ?? true);
             return {
                 content: [
                     {
@@ -1937,7 +1891,7 @@ export function registerPowerplatformCustomizationTools(server, service) {
                             `🔢 Version: ${extractedVersion}\n` +
                             `💾 Size: ${(dllBuffer.length / 1024).toFixed(2)} KB\n` +
                             `🔌 Plugin Types Created: ${result.pluginTypes.length}\n\n` +
-                            `Plugin Types:\n${result.pluginTypes.map(t => `  • ${t.typeName} (${t.pluginTypeId})`).join('\n') || '  (none created yet - check System Jobs)'}`
+                            `Plugin Types:\n${result.pluginTypes.map((t) => `  • ${t.typeName} (${t.pluginTypeId})`).join('\n') || '  (none created yet - check System Jobs)'}`
                     }]
             };
         }
@@ -2420,13 +2374,16 @@ export function registerPowerplatformCustomizationTools(server, service) {
             const service = getPowerPlatformService();
             const result = await service.documentAutomation(automationId, type);
             // Format the response with preserved line breaks in description
+            const actionSummary = result.analysis.actionCount > 0
+                ? `${result.analysis.actionCount} actions${result.analysis.actions.length > 0 ? ': ' + result.analysis.actions.slice(0, 5).join(', ') + (result.analysis.actionCount > 5 ? '...' : '') : ''}`
+                : 'none';
             const responseText = `✅ Successfully documented automation
 
 **Analysis:**
 - Tables Modified: ${result.analysis.tablesModified.join(', ') || 'none'}
 - Trigger: ${result.analysis.trigger}
 - Trigger Fields: ${result.analysis.triggerFields.join(', ') || 'none'}
-- Actions: ${result.analysis.actions.join(', ')}
+- Actions: ${actionSummary}
 
 **Description Updated:** ${result.descriptionUpdated ? 'Yes' : 'No'}
 
@@ -2453,7 +2410,309 @@ ${result.newDescription}`;
             };
         }
     });
-    console.error(`powerplatform-customization tools registered (${49} tools)`);
+    server.tool("deactivate-workflow", "Deactivate a workflow (set to Draft state). Required before modifying classic workflow definitions.", {
+        workflowId: z.string().describe("GUID of the workflow to deactivate")
+    }, async ({ workflowId }) => {
+        try {
+            const service = getPowerPlatformService();
+            const result = await service.deactivateWorkflow(workflowId);
+            const responseText = `✅ Workflow deactivated successfully
+
+**Workflow:** ${result.workflowName}
+**Previous State:** ${result.previousState}
+**New State:** ${result.newState}
+
+${result.previousState === 'Draft' ? '⚠️ Workflow was already in Draft state' : ''}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }]
+            };
+        }
+        catch (error) {
+            console.error("Error deactivating workflow:", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to deactivate workflow: ${error.message}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.tool("activate-workflow", "Activate a workflow (set to Activated state). Use after modifying classic workflow definitions.", {
+        workflowId: z.string().describe("GUID of the workflow to activate")
+    }, async ({ workflowId }) => {
+        try {
+            const service = getPowerPlatformService();
+            const result = await service.activateWorkflow(workflowId);
+            const responseText = `✅ Workflow activated successfully
+
+**Workflow:** ${result.workflowName}
+**Previous State:** ${result.previousState}
+**New State:** ${result.newState}
+
+${result.previousState === 'Activated' ? '⚠️ Workflow was already in Activated state' : ''}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }]
+            };
+        }
+        catch (error) {
+            console.error("Error activating workflow:", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to activate workflow: ${error.message}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.tool("document-workflow-safe", "Safely document a workflow by automatically deactivating → documenting → reactivating. Atomic operation with rollback on failure. Recommended for classic workflows that require deactivation before modification.", {
+        workflowId: z.string().describe("GUID of the workflow to document"),
+        type: z.enum(['flow', 'workflow']).optional().describe("Type of automation (auto-detected if not provided)")
+    }, async ({ workflowId, type }) => {
+        try {
+            const service = getPowerPlatformService();
+            const result = await service.documentWorkflowSafe(workflowId, type);
+            // Format the response
+            const actionSummary = result.analysis.actionCount > 0
+                ? `${result.analysis.actionCount} actions${result.analysis.actions.length > 0 ? ': ' + result.analysis.actions.slice(0, 5).join(', ') + (result.analysis.actionCount > 5 ? '...' : '') : ''}`
+                : 'none';
+            const stateWarning = result.stateManagement.finalState.includes('⚠️')
+                ? `\n\n⚠️ **WARNING:** ${result.stateManagement.finalState}`
+                : '';
+            const responseText = `✅ Successfully documented workflow
+
+**Workflow:** ${result.workflowName}
+
+**Analysis:**
+- Tables Modified: ${result.analysis.tablesModified.join(', ') || 'none'}
+- Trigger: ${result.analysis.trigger}
+- Trigger Fields: ${result.analysis.triggerFields.join(', ') || 'none'}
+- Actions: ${actionSummary}
+
+**Description Updated:** ${result.descriptionUpdated ? 'Yes' : 'No'}
+
+**State Management:**
+- Initial State: ${result.stateManagement.initialState}
+- Was Deactivated: ${result.stateManagement.wasDeactivated ? 'Yes' : 'No'}
+- Was Reactivated: ${result.stateManagement.wasReactivated ? 'Yes' : 'No'}
+- Final State: ${result.stateManagement.finalState}${stateWarning}
+
+**Previous Description:**
+${result.previousDescription || '(empty)'}
+
+**New Description:**
+${result.newDescription}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }]
+            };
+        }
+        catch (error) {
+            console.error("Error documenting workflow safely:", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to document workflow: ${error.message}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.tool("create-flow", "Create a new Power Automate flow from an existing template flow. Uses template-based creation by copying an existing flow's definition and modifying it.", {
+        name: z.string().describe("Display name for the new flow"),
+        templateFlowId: z.string().describe("GUID of the template flow to copy from"),
+        description: z.string().optional().describe("Description for the new flow"),
+        state: z.enum(['draft', 'activated']).optional().describe("Initial state (default: draft)"),
+        connectionReferenceMappings: z.record(z.string()).optional().describe("Map of connection reference names to new connection IDs. Format: {'connectionRefName': 'newConnectionId'}")
+    }, async ({ name, templateFlowId, description, state, connectionReferenceMappings }) => {
+        try {
+            const service = getPowerPlatformService();
+            const result = await service.createFlow(name, templateFlowId, {
+                description,
+                state,
+                connectionReferenceMappings
+            });
+            const responseText = `✅ Flow created successfully
+
+**Flow ID:** ${result.flowId}
+**Flow Name:** ${result.flowName}
+**State:** ${result.state}
+**Connection References Updated:** ${result.connectionReferencesUpdated}
+${result.warnings.length > 0 ? `\n⚠️ **Warnings:**\n${result.warnings.map((w) => `- ${w}`).join('\n')}` : ''}
+
+${result.state === 'draft' ? '💡 Use activate-flow to activate the flow when ready.' : ''}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }]
+            };
+        }
+        catch (error) {
+            console.error("Error creating flow:", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to create flow: ${error.message}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.tool("delete-flow", "Delete a Power Automate flow. This operation is permanent and cannot be undone. Flow must be in Draft state before deletion.", {
+        flowId: z.string().describe("GUID of the flow to delete"),
+        confirm: z.boolean().describe("Confirmation flag - must be true to proceed with deletion (safety check)")
+    }, async ({ flowId, confirm }) => {
+        try {
+            if (!confirm) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "❌ Deletion cancelled: confirm parameter must be true to proceed"
+                        }],
+                    isError: true
+                };
+            }
+            const service = getPowerPlatformService();
+            const result = await service.deleteFlow(flowId);
+            const responseText = `✅ Flow deleted successfully
+
+**Flow ID:** ${result.flowId}
+**Flow Name:** ${result.flowName}
+**Previous State:** ${result.previousState}
+
+⚠️ This operation is permanent and cannot be undone.`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }]
+            };
+        }
+        catch (error) {
+            console.error("Error deleting flow:", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to delete flow: ${error.message}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.tool("clone-flow", "Clone an existing Power Automate flow with a new name. Creates an exact copy in Draft state with optional connection reference updates.", {
+        sourceFlowId: z.string().describe("GUID of the flow to clone"),
+        newName: z.string().describe("Display name for the cloned flow"),
+        description: z.string().optional().describe("Description for the cloned flow (defaults to original description)"),
+        updateConnectionReferences: z.boolean().optional().describe("If true, update connection references using mappings (default: false)"),
+        connectionReferenceMappings: z.record(z.string()).optional().describe("Map of connection reference names to new connection IDs (only used if updateConnectionReferences=true)")
+    }, async ({ sourceFlowId, newName, description, updateConnectionReferences, connectionReferenceMappings }) => {
+        try {
+            const service = getPowerPlatformService();
+            const result = await service.cloneFlow(sourceFlowId, newName, {
+                description,
+                updateConnectionReferences,
+                connectionReferenceMappings
+            });
+            const responseText = `✅ Flow cloned successfully
+
+**Source Flow:** ${result.sourceFlowName} (${result.sourceFlowId})
+**New Flow ID:** ${result.newFlowId}
+**New Flow Name:** ${result.newFlowName}
+**State:** ${result.state}
+**Connection References Updated:** ${result.connectionReferencesUpdated}
+
+💡 Use activate-flow to activate the cloned flow when ready.`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }]
+            };
+        }
+        catch (error) {
+            console.error("Error cloning flow:", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to clone flow: ${error.message}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.tool("activate-flow", "Activate a Power Automate flow (set to Activated state). Flow must be valid and connections must be configured.", {
+        flowId: z.string().describe("GUID of the flow to activate")
+    }, async ({ flowId }) => {
+        try {
+            const service = getPowerPlatformService();
+            const result = await service.activateFlow(flowId);
+            const responseText = `✅ Flow activated successfully
+
+**Flow:** ${result.workflowName}
+**Previous State:** ${result.previousState}
+**New State:** ${result.newState}
+
+${result.previousState === 'Activated' ? '⚠️ Flow was already in Activated state' : ''}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }]
+            };
+        }
+        catch (error) {
+            console.error("Error activating flow:", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to activate flow: ${error.message}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    server.tool("deactivate-flow", "Deactivate a Power Automate flow (set to Draft state). Use before modifying flow definition or deleting.", {
+        flowId: z.string().describe("GUID of the flow to deactivate")
+    }, async ({ flowId }) => {
+        try {
+            const service = getPowerPlatformService();
+            const result = await service.deactivateFlow(flowId);
+            const responseText = `✅ Flow deactivated successfully
+
+**Flow:** ${result.workflowName}
+**Previous State:** ${result.previousState}
+**New State:** ${result.newState}
+
+${result.previousState === 'Draft' ? '⚠️ Flow was already in Draft state' : ''}`;
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }]
+            };
+        }
+        catch (error) {
+            console.error("Error deactivating flow:", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Failed to deactivate flow: ${error.message}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    console.error(`powerplatform-customization tools registered (${57} tools)`);
 }
 // CLI entry point (standalone execution)
 // Uses realpathSync to resolve symlinks created by npx