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

package/build/index.js

@@ -5,6 +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';
 const POWERPLATFORM_DEFAULT_SOLUTION = process.env.POWERPLATFORM_DEFAULT_SOLUTION || "";
 /**
  * Register powerplatform-customization tools with an MCP server
@@ -19,12 +20,15 @@ export function registerPowerplatformCustomizationTools(server, service) {
                 'POWERPLATFORM_URL',
                 'POWERPLATFORM_CLIENT_ID',
                 'POWERPLATFORM_CLIENT_SECRET',
-                'POWERPLATFORM_TENANT_ID'
+                'POWERPLATFORM_TENANT_ID',
+                'PUBLISHER_PREFIX'
             ];
             const missing = requiredVars.filter(v => !process.env[v]);
             if (missing.length > 0) {
                 throw new Error(`Missing required PowerPlatform configuration: ${missing.join(', ')}`);
             }
+            // Initialize publisher prefix for validation
+            initializePublisherPrefix();
             const config = {
                 organizationUrl: process.env.POWERPLATFORM_URL,
                 clientId: process.env.POWERPLATFORM_CLIENT_ID,
@@ -788,12 +792,39 @@ export function registerPowerplatformCustomizationTools(server, service) {
             };
         }
     });
-    server.tool("update-attribute", "Update an existing attribute on an entity. Supports converting String attributes to AutoNumber by setting autoNumberFormat.", {
+    server.tool("update-attribute", "Update an existing attribute on an entity. Supports updating display properties, numeric constraints, date/time format, string format, and auditing settings.", {
         entityLogicalName: z.string().describe("Entity logical name"),
         attributeLogicalName: z.string().describe("Attribute logical name"),
         displayName: z.string().optional().describe("New display name"),
         description: z.string().optional().describe("New description"),
         requiredLevel: z.enum(["None", "Recommended", "ApplicationRequired"]).optional().describe("Required level"),
+        // String/Memo properties
+        maxLength: z.number().optional().describe("Maximum length for String/Memo attributes. " +
+            "String (single-line): 1-4000 characters. " +
+            "Memo (multi-line): 1-1048576 characters. " +
+            "Note: Reducing maxLength won't truncate existing data."),
+        formatName: z.enum(["Text", "TextArea", "Email", "Phone", "Url", "TickerSymbol"]).optional().describe("Format for String attributes. Text=single line, TextArea=multi-line, " +
+            "Email/Phone/Url/TickerSymbol=formatted input with validation."),
+        // Numeric properties (Integer, Decimal, Money)
+        minValue: z.number().optional().describe("Minimum value for Integer/Decimal/Money attributes. " +
+            "Integer: -2147483648 to 2147483647. " +
+            "Decimal: -100000000000 to 100000000000. " +
+            "Money: -922337203685477 to 922337203685477."),
+        maxValue: z.number().optional().describe("Maximum value for Integer/Decimal/Money attributes. " +
+            "Integer: -2147483648 to 2147483647. " +
+            "Decimal: -100000000000 to 100000000000. " +
+            "Money: -922337203685477 to 922337203685477."),
+        precision: z.number().optional().describe("Decimal precision for Decimal/Money attributes (0-10 decimal places)."),
+        precisionSource: z.enum(["Precision", "Pricing", "Currency"]).optional().describe("Precision source for Money attributes. " +
+            "Precision=use precision property, Pricing=org pricing setting, Currency=currency precision."),
+        // DateTime properties
+        format: z.enum(["DateAndTime", "DateOnly"]).optional().describe("Display format for DateTime attributes."),
+        dateTimeBehavior: z.enum(["UserLocal", "DateOnly", "TimeZoneIndependent"]).optional().describe("Time zone behavior for DateTime attributes. Only changeable if CanChangeDateTimeBehavior=true. " +
+            "UserLocal=adjusted to user timezone, DateOnly=date without time, TimeZoneIndependent=stored as-is."),
+        // Auditing and search properties
+        isAuditEnabled: z.boolean().optional().describe("Enable/disable auditing for this attribute. Tracks changes to field values."),
+        isValidForAdvancedFind: z.boolean().optional().describe("Show this attribute in Advanced Find queries."),
+        // AutoNumber conversion
         autoNumberFormat: z.string().optional().describe("Auto-number format string to convert String attribute to AutoNumber. " +
             "Use placeholders: {SEQNUM:n} for sequential number (min length n), " +
             "{RANDSTRING:n} for random alphanumeric (length 1-6 only), " +
@@ -819,6 +850,69 @@ export function registerPowerplatformCustomizationTools(server, service) {
             if (params.requiredLevel) {
                 updates.RequiredLevel = { Value: params.requiredLevel, CanBeChanged: true };
             }
+            // Handle MaxLength update for String/Memo attributes
+            if (params.maxLength !== undefined) {
+                if (params.maxLength < 1) {
+                    throw new Error("maxLength must be at least 1 character.");
+                }
+                if (params.maxLength > 1048576) {
+                    throw new Error("maxLength cannot exceed 1,048,576 characters (Memo maximum).");
+                }
+                updates.MaxLength = params.maxLength;
+            }
+            // Handle FormatName update for String attributes
+            if (params.formatName) {
+                updates.FormatName = { Value: params.formatName };
+            }
+            // Handle MinValue update for Integer/Decimal/Money attributes
+            if (params.minValue !== undefined) {
+                updates.MinValue = params.minValue;
+            }
+            // Handle MaxValue update for Integer/Decimal/Money attributes
+            if (params.maxValue !== undefined) {
+                updates.MaxValue = params.maxValue;
+            }
+            // Handle Precision update for Decimal/Money attributes
+            if (params.precision !== undefined) {
+                if (params.precision < 0 || params.precision > 10) {
+                    throw new Error("precision must be between 0 and 10 decimal places.");
+                }
+                updates.Precision = params.precision;
+            }
+            // Handle PrecisionSource update for Money attributes
+            if (params.precisionSource) {
+                const precisionSourceMap = {
+                    "Precision": 0,
+                    "Pricing": 1,
+                    "Currency": 2
+                };
+                updates.PrecisionSource = precisionSourceMap[params.precisionSource];
+            }
+            // Handle Format update for DateTime attributes
+            if (params.format) {
+                updates.Format = params.format;
+            }
+            // Handle DateTimeBehavior update for DateTime attributes
+            if (params.dateTimeBehavior) {
+                updates.DateTimeBehavior = {
+                    "@odata.type": "Microsoft.Dynamics.CRM.DateTimeBehavior",
+                    Value: params.dateTimeBehavior
+                };
+            }
+            // Handle IsAuditEnabled update
+            if (params.isAuditEnabled !== undefined) {
+                updates.IsAuditEnabled = {
+                    Value: params.isAuditEnabled,
+                    CanBeChanged: true
+                };
+            }
+            // Handle IsValidForAdvancedFind update
+            if (params.isValidForAdvancedFind !== undefined) {
+                updates.IsValidForAdvancedFind = {
+                    Value: params.isValidForAdvancedFind,
+                    CanBeChanged: true
+                };
+            }
             // Handle AutoNumber format conversion
             if (params.autoNumberFormat) {
                 // Validate RANDSTRING lengths (common error - API rejects length > 6)
@@ -841,10 +935,45 @@ export function registerPowerplatformCustomizationTools(server, service) {
             }
             await service.updateAttribute(params.entityLogicalName, params.attributeLogicalName, updates, params.solutionUniqueName);
             let successMessage = `✅ Successfully updated attribute '${params.attributeLogicalName}' on entity '${params.entityLogicalName}'`;
+            // Build list of changes made
+            const changes = [];
+            if (params.displayName)
+                changes.push(`Display name: "${params.displayName}"`);
+            if (params.description)
+                changes.push(`Description updated`);
+            if (params.requiredLevel)
+                changes.push(`Required level: ${params.requiredLevel}`);
+            if (params.maxLength !== undefined)
+                changes.push(`Max length: ${params.maxLength} characters`);
+            if (params.formatName)
+                changes.push(`Format: ${params.formatName}`);
+            if (params.minValue !== undefined)
+                changes.push(`Min value: ${params.minValue}`);
+            if (params.maxValue !== undefined)
+                changes.push(`Max value: ${params.maxValue}`);
+            if (params.precision !== undefined)
+                changes.push(`Precision: ${params.precision} decimal places`);
+            if (params.precisionSource)
+                changes.push(`Precision source: ${params.precisionSource}`);
+            if (params.format)
+                changes.push(`DateTime format: ${params.format}`);
+            if (params.dateTimeBehavior)
+                changes.push(`DateTime behavior: ${params.dateTimeBehavior}`);
+            if (params.isAuditEnabled !== undefined)
+                changes.push(`Auditing: ${params.isAuditEnabled ? 'enabled' : 'disabled'}`);
+            if (params.isValidForAdvancedFind !== undefined)
+                changes.push(`Advanced Find: ${params.isValidForAdvancedFind ? 'enabled' : 'disabled'}`);
+            if (params.autoNumberFormat)
+                changes.push(`AutoNumber format: ${params.autoNumberFormat}`);
+            if (changes.length > 0) {
+                successMessage += `\n\n📝 Changes made:\n${changes.map(c => `  • ${c}`).join('\n')}`;
+            }
             if (params.autoNumberFormat) {
-                successMessage += `\n\n📋 Auto-number format set to: ${params.autoNumberFormat}`;
                 successMessage += `\n\n⚠️ NOTE: Converting to AutoNumber is irreversible. The attribute will now auto-generate values based on the format.`;
             }
+            if (params.dateTimeBehavior) {
+                successMessage += `\n\n⚠️ NOTE: DateTimeBehavior changes may affect existing data interpretation. Review dependent workflows and business rules.`;
+            }
             successMessage += `\n\n⚠️ IMPORTANT: You must publish this customization using the 'publish-customizations' tool before it becomes active.`;
             return {
                 content: [{ type: "text", text: successMessage }]
@@ -1979,43 +2108,51 @@ export function registerPowerplatformCustomizationTools(server, service) {
         solutionUniqueName: z.string().optional(),
         replaceExisting: z.boolean().optional().describe("Update existing assembly vs. create new"),
     }, async (params) => {
+        const service = getPowerPlatformService();
+        // Track created resources for potential rollback
+        let createdAssemblyId = null;
+        let isNewAssembly = false;
+        const createdStepIds = [];
+        const summary = {
+            phases: {
+                deploy: {},
+                register: { stepsCreated: 0, imagesCreated: 0 },
+            },
+        };
+        let dllBuffer;
         try {
-            const service = getPowerPlatformService();
-            const summary = {
-                phases: {
-                    deploy: {},
-                    register: { stepsCreated: 0, imagesCreated: 0 },
-                },
-            };
             // Read DLL file
             const fs = await import('fs/promises');
             const normalizedPath = params.assemblyPath.replace(/\\/g, '/');
-            const dllBuffer = await fs.readFile(normalizedPath);
+            dllBuffer = await fs.readFile(normalizedPath);
             const dllBase64 = dllBuffer.toString('base64');
             const version = await service.extractAssemblyVersion(params.assemblyPath);
-            // Phase 1: Deploy assembly
-            if (params.replaceExisting) {
-                // Find existing assembly ID
-                const assemblyId = await service.queryPluginAssemblyByName(params.assemblyName);
-                if (assemblyId) {
-                    await service.updatePluginAssembly(assemblyId, dllBase64, version, params.solutionUniqueName || POWERPLATFORM_DEFAULT_SOLUTION);
-                    summary.phases.deploy = {
-                        action: 'updated',
-                        assemblyId: assemblyId,
-                        version,
-                    };
-                }
-                else {
-                    throw new Error(`Assembly '${params.assemblyName}' not found for update`);
-                }
+            // Phase 1: Deploy assembly (UPSERT logic)
+            const existingAssemblyId = await service.queryPluginAssemblyByName(params.assemblyName);
+            if (existingAssemblyId) {
+                // Assembly exists - update it (no rollback needed for updates)
+                await service.updatePluginAssembly(existingAssemblyId, dllBase64, version, params.solutionUniqueName || POWERPLATFORM_DEFAULT_SOLUTION);
+                summary.phases.deploy = {
+                    action: 'updated',
+                    assemblyId: existingAssemblyId,
+                    version,
+                    pluginTypes: await service.getPluginTypesForAssembly(existingAssemblyId),
+                };
             }
             else {
+                // Assembly doesn't exist - create it
+                if (params.replaceExisting) {
+                    // User expected update but assembly not found - warn but proceed with create
+                    console.error(`Warning: Assembly '${params.assemblyName}' not found for update. Creating new assembly instead.`);
+                }
                 const uploadResult = await service.createPluginAssembly({
                     name: params.assemblyName,
                     content: dllBase64,
                     version,
                     solutionUniqueName: params.solutionUniqueName || POWERPLATFORM_DEFAULT_SOLUTION,
                 });
+                createdAssemblyId = uploadResult.pluginAssemblyId; // Track for rollback
+                isNewAssembly = true;
                 summary.phases.deploy = {
                     action: 'created',
                     assemblyId: uploadResult.pluginAssemblyId,
@@ -2023,7 +2160,7 @@ export function registerPowerplatformCustomizationTools(server, service) {
                     pluginTypes: uploadResult.pluginTypes,
                 };
             }
-            // Phase 2: Register steps
+            // Phase 2: Register steps (with rollback tracking)
             if (params.stepConfigurations) {
                 const stageMap = {
                     PreValidation: 10,
@@ -2046,6 +2183,7 @@ export function registerPowerplatformCustomizationTools(server, service) {
                         filteringAttributes: stepConfig.filteringAttributes?.join(','),
                         solutionUniqueName: params.solutionUniqueName || POWERPLATFORM_DEFAULT_SOLUTION,
                     });
+                    createdStepIds.push(stepResult.stepId); // Track for rollback
                     summary.phases.register.stepsCreated++;
                     // Register pre-image
                     if (stepConfig.preImage) {
@@ -2077,28 +2215,154 @@ export function registerPowerplatformCustomizationTools(server, service) {
             return {
                 content: [{
                         type: "text",
-                        text: `✅ Plugin deployment completed successfully!\n\n` +
-                            `📦 Assembly: ${summary.phases.deploy.action === 'created' ? 'Created' : 'Updated'}\n` +
-                            `🆔 Assembly ID: ${summary.phases.deploy.assemblyId}\n` +
-                            `🔢 Version: ${summary.phases.deploy.version}\n` +
-                            `💾 Size: ${(dllBuffer.length / 1024).toFixed(2)} KB\n` +
-                            (summary.phases.deploy.pluginTypes ? `🔌 Plugin Types: ${summary.phases.deploy.pluginTypes.length}\n` : '') +
-                            `📝 Steps Created: ${summary.phases.register.stepsCreated}\n` +
-                            `🖼️ Images Created: ${summary.phases.register.imagesCreated}\n` +
-                            `📢 Published: ${summary.phases.publish.success ? 'Yes' : 'No'}\n\n` +
-                            `⚡ Deployment is complete and active in the environment!`
+                        text: `Plugin deployment completed successfully!\n\n` +
+                            `Assembly: ${summary.phases.deploy.action === 'created' ? 'Created' : 'Updated'}\n` +
+                            `Assembly ID: ${summary.phases.deploy.assemblyId}\n` +
+                            `Version: ${summary.phases.deploy.version}\n` +
+                            `Size: ${(dllBuffer.length / 1024).toFixed(2)} KB\n` +
+                            (summary.phases.deploy.pluginTypes ? `Plugin Types: ${summary.phases.deploy.pluginTypes.length}\n` : '') +
+                            `Steps Created: ${summary.phases.register.stepsCreated}\n` +
+                            `Images Created: ${summary.phases.register.imagesCreated}\n` +
+                            `Published: ${summary.phases.publish.success ? 'Yes' : 'No'}\n\n` +
+                            `Deployment is complete and active in the environment!`
                     }]
             };
         }
         catch (error) {
+            // ROLLBACK: Clean up created resources on failure
+            let rollbackMessage = '';
+            if (createdStepIds.length > 0 || (createdAssemblyId && isNewAssembly)) {
+                rollbackMessage = '\n\nRollback initiated:\n';
+                // Delete created steps first (reverse order)
+                for (const stepId of createdStepIds.reverse()) {
+                    try {
+                        await service.deletePluginStep(stepId);
+                        rollbackMessage += `- Deleted step: ${stepId}\n`;
+                    }
+                    catch (rollbackError) {
+                        rollbackMessage += `- Failed to delete step ${stepId}: ${rollbackError.message}\n`;
+                    }
+                }
+                // Delete the assembly if we created it (cascade deletes remaining components)
+                if (createdAssemblyId && isNewAssembly) {
+                    try {
+                        await service.deletePluginAssembly(createdAssemblyId);
+                        rollbackMessage += `- Deleted assembly: ${createdAssemblyId}\n`;
+                    }
+                    catch (rollbackError) {
+                        rollbackMessage += `- Failed to delete assembly ${createdAssemblyId}: ${rollbackError.message}\n`;
+                    }
+                }
+                rollbackMessage += '\nPlease verify cleanup in Power Platform.';
+            }
             console.error("Error deploying plugin:", error);
             return {
-                content: [{ type: "text", text: `❌ Failed to deploy plugin: ${error.message}` }],
+                content: [{ type: "text", text: `Failed to deploy plugin: ${error.message}${rollbackMessage}` }],
+                isError: true
+            };
+        }
+    });
+    server.tool("get-plugin-deployment-status", "Get the current deployment status of a plugin assembly, including all registered types, steps, and images. Useful for verifying deployments and troubleshooting.", {
+        assemblyName: z.string().describe("Name of the plugin assembly to check"),
+        includeDisabled: z.boolean().optional().describe("Include disabled steps (default: false)"),
+    }, async (params) => {
+        try {
+            const service = getPowerPlatformService();
+            // Check if assembly exists
+            const assemblyId = await service.queryPluginAssemblyByName(params.assemblyName);
+            if (!assemblyId) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Assembly '${params.assemblyName}' not found in Dataverse.\n\n` +
+                                `Possible reasons:\n` +
+                                `- Assembly has not been deployed yet\n` +
+                                `- Assembly name is incorrect (case-sensitive)\n` +
+                                `- Assembly was deleted\n\n` +
+                                `Use 'create-plugin-assembly' or 'deploy-plugin-complete' to deploy.`
+                        }]
+                };
+            }
+            // Get complete assembly information
+            const result = await service.getPluginAssemblyComplete(params.assemblyName, params.includeDisabled || false);
+            // Build status report
+            let statusReport = `PLUGIN DEPLOYMENT STATUS\n`;
+            statusReport += `${'='.repeat(50)}\n\n`;
+            // Assembly info
+            statusReport += `ASSEMBLY\n`;
+            statusReport += `---------\n`;
+            statusReport += `Name: ${result.assembly.name}\n`;
+            statusReport += `Version: ${result.assembly.version}\n`;
+            statusReport += `ID: ${result.assembly.pluginassemblyid}\n`;
+            statusReport += `Isolation Mode: ${result.assembly.isolationmode === 2 ? 'Sandbox' : 'None'}\n`;
+            statusReport += `Is Managed: ${result.assembly.ismanaged ? 'Yes' : 'No'}\n`;
+            statusReport += `Modified: ${result.assembly.modifiedon}\n`;
+            statusReport += `Modified By: ${result.assembly.modifiedby?.fullname || 'Unknown'}\n\n`;
+            // Plugin types
+            statusReport += `PLUGIN TYPES (${result.pluginTypes.length})\n`;
+            statusReport += `-------------\n`;
+            if (result.pluginTypes.length === 0) {
+                statusReport += `No plugin types found. This may indicate:\n`;
+                statusReport += `- Dataverse is still processing the assembly\n`;
+                statusReport += `- The DLL does not contain any IPlugin implementations\n\n`;
+            }
+            else {
+                for (const type of result.pluginTypes) {
+                    statusReport += `- ${type.typename}\n`;
+                    statusReport += `  ID: ${type.plugintypeid}\n`;
+                }
+                statusReport += `\n`;
+            }
+            // Steps
+            const stageNames = { 10: 'PreValidation', 20: 'PreOperation', 40: 'PostOperation' };
+            const modeNames = { 0: 'Sync', 1: 'Async' };
+            statusReport += `REGISTERED STEPS (${result.steps.length})\n`;
+            statusReport += `------------------\n`;
+            if (result.steps.length === 0) {
+                statusReport += `No steps registered.\n\n`;
+            }
+            else {
+                for (const step of result.steps) {
+                    const status = step.statuscode === 1 ? 'Active' : 'Disabled';
+                    statusReport += `- ${step.name}\n`;
+                    statusReport += `  Message: ${step.sdkmessageid?.name || 'Unknown'} on ${step.sdkmessagefilterid?.primaryobjecttypecode || 'Unknown'}\n`;
+                    statusReport += `  Stage: ${stageNames[step.stage] || step.stage}, Mode: ${modeNames[step.mode] || step.mode}\n`;
+                    statusReport += `  Status: ${status}, Rank: ${step.rank}\n`;
+                    statusReport += `  ID: ${step.sdkmessageprocessingstepid}\n`;
+                    if (step.images && step.images.length > 0) {
+                        statusReport += `  Images:\n`;
+                        for (const img of step.images) {
+                            const imgType = img.imagetype === 0 ? 'Pre' : img.imagetype === 1 ? 'Post' : 'Both';
+                            statusReport += `    - ${img.name} (${imgType}Image, alias: ${img.entityalias})\n`;
+                        }
+                    }
+                    statusReport += `\n`;
+                }
+            }
+            // Validation
+            statusReport += `VALIDATION\n`;
+            statusReport += `----------\n`;
+            if (result.validation.potentialIssues.length === 0) {
+                statusReport += `No issues detected.\n`;
+            }
+            else {
+                for (const issue of result.validation.potentialIssues) {
+                    statusReport += `Warning: ${issue}\n`;
+                }
+            }
+            return {
+                content: [{ type: "text", text: statusReport }]
+            };
+        }
+        catch (error) {
+            console.error("Error getting plugin deployment status:", error);
+            return {
+                content: [{ type: "text", text: `Failed to get plugin deployment status: ${error.message}` }],
                 isError: true
             };
         }
     });
-    console.error(`✅ powerplatform-customization tools registered (${45} tools)`);
+    console.error(`powerplatform-customization tools registered (${46} tools)`);
 }
 // CLI entry point (standalone execution)
 // Uses realpathSync to resolve symlinks created by npx