snow-flow 1.1.74 → 1.1.76

package/dist/mcp/servicenow-deployment-mcp.js

@@ -1073,6 +1073,17 @@ Use \`snow_deployment_debug\` for more information about this session.`,
                     ],
                 };
             }
+            // Ensure we have a flow definition
+            if (!args.flow_definition) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '❌ Flow deployment failed: No flow_definition provided.\n\n💡 You need to provide a flow_definition with activities.\n\nExample:\n```json\n{\n  "name": "approval_flow",\n  "flow_definition": {\n    "activities": [\n      {\n        "id": "activity_1",\n        "name": "Check Condition",\n        "type": "condition"\n      }\n    ]\n  }\n}\n```\n\nOr use snow_create_flow with natural language for easier flow creation.',
+                        },
+                    ],
+                };
+            }
             const flowType = args.flow_type || 'flow';
             this.logger.info(`Deploying ${flowType} to ServiceNow`, { name: args.name, type: flowType });
             // Validate flow definition first if requested
@@ -1426,9 +1437,12 @@ ${isComposedFlow ? `
             access: 'public'
         };
         const result = await this.client.createScriptInclude(scriptIncludeData);
+        if (!result.data?.sys_id) {
+            throw new Error(`Script Include deployment failed: No sys_id returned from ServiceNow. Result: ${JSON.stringify(result)}`);
+        }
         return {
             originalId: artifact.sys_id,
-            sys_id: result.data?.sys_id || `mock_si_${Date.now()}`,
+            sys_id: result.data.sys_id,
             name: artifact.name,
             api_name: scriptIncludeData.api_name,
             type: 'script_include',
@@ -1450,9 +1464,12 @@ ${isComposedFlow ? `
             order: 100
         };
         const result = await this.client.createBusinessRule(businessRuleData);
+        if (!result.data?.sys_id) {
+            throw new Error(`Business Rule deployment failed: No sys_id returned from ServiceNow. Result: ${JSON.stringify(result)}`);
+        }
         return {
             originalId: artifact.sys_id,
-            sys_id: result.data?.sys_id || `mock_br_${Date.now()}`,
+            sys_id: result.data.sys_id,
             name: artifact.name,
             type: 'business_rule',
             success: result.success
@@ -1483,9 +1500,12 @@ ${isComposedFlow ? `
                 });
             }
         }
+        if (!result.data?.sys_id) {
+            throw new Error(`Table deployment failed: No sys_id returned from ServiceNow. Result: ${JSON.stringify(result)}`);
+        }
         return {
             originalId: artifact.sys_id,
-            sys_id: result.data?.sys_id || `mock_table_${Date.now()}`,
+            sys_id: result.data.sys_id,
             name: artifact.name,
             type: 'table',
             success: result.success
@@ -1662,9 +1682,52 @@ ${this.getScopeBenefits(deploymentResult.scope).map(b => `- ${b}`).join('\n')}`,
     async deployUpdateSet(args) {
         try {
             this.logger.info('Creating update set', { name: args.name });
-            // In a real implementation, this would create an update set and add artifacts
-            // For now, we'll simulate the process
-            const updateSetId = `US${Date.now()}`;
+            // Create the update set using the real ServiceNow API
+            const updateSetResult = await this.client.createUpdateSet({
+                name: args.name,
+                description: args.description || `Update Set created via Snow-Flow deployment`
+            });
+            if (!updateSetResult.success || !updateSetResult.data) {
+                throw new Error(`Failed to create Update Set: ${updateSetResult.error || 'Unknown error'}`);
+            }
+            const updateSetId = updateSetResult.data.sys_id;
+            this.logger.info('Update Set created successfully', { id: updateSetId, name: args.name });
+            // Set as current update set for tracking
+            const activateResult = await this.client.setCurrentUpdateSet(updateSetId);
+            if (!activateResult.success) {
+                this.logger.warn('Warning: Could not set as current Update Set', { id: updateSetId });
+            }
+            // Track all provided artifacts in the update set
+            const trackingResults = [];
+            if (args.artifacts && Array.isArray(args.artifacts)) {
+                for (const artifact of args.artifacts) {
+                    try {
+                        // Create sys_update_xml record to track the artifact in the update set
+                        const trackingResult = await this.client.createRecord('sys_update_xml', {
+                            name: `${artifact.type}_${artifact.sys_id}`,
+                            category: 'customer',
+                            update_set: updateSetId,
+                            target_name: artifact.name,
+                            type: artifact.type,
+                            target_sys_id: artifact.sys_id,
+                            action: 'INSERT_OR_UPDATE'
+                        });
+                        if (trackingResult.success) {
+                            trackingResults.push(`✅ ${artifact.type}: ${artifact.name}`);
+                        }
+                        else {
+                            trackingResults.push(`⚠️ ${artifact.type}: ${artifact.name} (tracking failed)`);
+                        }
+                    }
+                    catch (trackingError) {
+                        this.logger.warn('Failed to track artifact in Update Set', {
+                            artifact: artifact.sys_id,
+                            error: trackingError
+                        });
+                        trackingResults.push(`⚠️ ${artifact.type}: ${artifact.name} (tracking failed)`);
+                    }
+                }
+            }
             return {
                 content: [
                     {
@@ -1675,21 +1738,24 @@ ${this.getScopeBenefits(deploymentResult.scope).map(b => `- ${b}`).join('\n')}`,
 - Name: ${args.name}
 - ID: ${updateSetId}
 - Description: ${args.description || 'N/A'}
-- Artifacts: ${args.artifacts.length} items
+- Artifacts: ${args.artifacts?.length || 0} items
 
-📦 Included Artifacts:
-${args.artifacts.map((a) => `- ${a.type}: ${a.sys_id}`).join('\n')}
+📦 Tracked Artifacts:
+${trackingResults.length > 0 ? trackingResults.join('\n') : '- No artifacts specified'}
 
 📝 Next Steps:
-1. Review update set contents
-2. Mark as complete
-3. Export for migration
-4. Deploy to target instance`,
+1. Review update set contents in ServiceNow
+2. Mark as complete when ready: \`snow_update_set_complete\`
+3. Export for migration: \`snow_update_set_export\`
+4. Deploy to target instance
+
+💡 The Update Set is now active and will automatically track future changes.`,
                     },
                 ],
             };
         }
         catch (error) {
+            this.logger.error('Update set creation failed', error);
             throw new Error(`Update set creation failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
@@ -2760,6 +2826,17 @@ Use \`snow_preview_widget\` to see a detailed preview of the widget rendering.`,
                     ]
                 };
             }
+            // Check if definition is null or undefined
+            if (!definition) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ Flow validation failed: No definition provided.\n\n💡 Please provide a flow definition with activities.\n\nExample:\n\`\`\`json\n{\n  "activities": [\n    {\n      "id": "activity_1",\n      "name": "Send Notification",\n      "type": "notification"\n    }\n  ]\n}\n\`\`\``
+                        }
+                    ]
+                };
+            }
             const issues = [];
             const warnings = [];
             const info = [];
@@ -2768,13 +2845,13 @@ Use \`snow_preview_widget\` to see a detailed preview of the widget rendering.`,
             // Handle multiple JSON structure variations: top-level, nested in "flow", nested in "flow_definition"
             let workingDefinition = definition;
             // Check if we have a nested structure like { "flow": { "steps": [...] } }
-            if (definition.flow && typeof definition.flow === 'object') {
+            if (definition && definition.flow && typeof definition.flow === 'object') {
                 workingDefinition = definition.flow;
                 corrections.push('✅ Processing nested flow structure (definition.flow)');
                 info.push('💡 Detected nested flow definition format - extracting flow content');
             }
             // Check if we have nested flow_definition
-            if (definition.flow_definition && typeof definition.flow_definition === 'object') {
+            if (definition && definition.flow_definition && typeof definition.flow_definition === 'object') {
                 workingDefinition = definition.flow_definition;
                 corrections.push('✅ Processing nested flow_definition structure');
             }
@@ -3559,8 +3636,22 @@ Use \`snow_preview_widget\` to see a detailed preview of the widget rendering.`,
                     script += this.generateConditionScript(activity);
                     break;
                 default:
-                    script += `\n        // TODO: Implement ${activity.type} logic
-        gs.log('Activity ${activity.name || activity.type} executed', 'INFO');`;
+                    // Handle unknown activity types with a comprehensive fallback
+                    script += `\n        // Unknown activity type: ${activity.type}
+        // Available activity data: ${JSON.stringify(activity, null, 2).replace(/"/g, '\\"')}
+        gs.warn('Unsupported activity type in flow: ${activity.type}', 'SNOW_FLOW');
+        
+        // Attempt to execute any custom script if provided
+        ${activity.script ? `
+        // Custom script from activity definition
+        try {
+          ${activity.script}
+        } catch (error) {
+          gs.error('Custom script execution failed for activity ${activity.name || activity.type}: ' + error.message);
+        }` : ''}
+        
+        // Log completion
+        gs.log('Activity ${activity.name || activity.type} processed (unsupported type: ${activity.type})', 'INFO');`;
             }
             script += '\n';
         });
@@ -3784,13 +3875,127 @@ Use individual deployment tools like \`snow_deploy_${args.type}\` with manual co
      * Process natural language instruction into deployment configuration
      */
     async processNaturalLanguageInstruction(type, instruction) {
-        // For flows, delegate to flow composer
+        // For flows, create a proper flow structure
         if (type === 'flow') {
-            // This would call the flow composer MCP, but for now return a basic structure
+            // Extract flow name from instruction
+            const flowName = this.extractNameFromInstruction(instruction);
+            // Create a basic flow definition based on the instruction
+            // This is a simplified version - in production, this would call the flow composer
+            const lowerInstruction = instruction.toLowerCase();
+            // Determine trigger type
+            let triggerType = 'manual';
+            let triggerTable = '';
+            if (lowerInstruction.includes('new service catalog request') ||
+                lowerInstruction.includes('new catalog request')) {
+                triggerType = 'record_created';
+                triggerTable = 'sc_request';
+            }
+            else if (lowerInstruction.includes('new incident')) {
+                triggerType = 'record_created';
+                triggerTable = 'incident';
+            }
+            else if (lowerInstruction.includes('updated') || lowerInstruction.includes('changes')) {
+                triggerType = 'record_updated';
+            }
+            // Create activities based on instruction
+            const activities = [];
+            let activityId = 1;
+            // Check for approval requirement
+            if (lowerInstruction.includes('approval') || lowerInstruction.includes('approve')) {
+                // Check for condition
+                if (lowerInstruction.includes('if') &&
+                    (lowerInstruction.includes('monitor') || lowerInstruction.includes('display') ||
+                        lowerInstruction.includes('screen') || lowerInstruction.includes('lcd'))) {
+                    // Add condition activity
+                    activities.push({
+                        id: `activity_${activityId++}`,
+                        name: 'Check Item Type',
+                        type: 'condition',
+                        condition: 'current.cat_item.name.toLowerCase().includes("monitor") || current.cat_item.name.toLowerCase().includes("display") || current.cat_item.name.toLowerCase().includes("screen") || current.cat_item.name.toLowerCase().includes("lcd")',
+                        outputs: {
+                            condition_met: true
+                        }
+                    });
+                }
+                // Add approval activity
+                activities.push({
+                    id: `activity_${activityId++}`,
+                    name: 'Request Approval',
+                    type: 'approval',
+                    approval_type: 'user',
+                    approvers: lowerInstruction.includes('admin') ? 'admin' : 'assignment_group.manager',
+                    inputs: {
+                        record: '${trigger.current}',
+                        approvers: lowerInstruction.includes('admin') ? 'admin' : 'assignment_group.manager'
+                    },
+                    outputs: {
+                        approval_state: '${approval.state}',
+                        approval_comments: '${approval.comments}'
+                    }
+                });
+                // Add wait for approval if mentioned
+                if (lowerInstruction.includes('wait for approval')) {
+                    activities.push({
+                        id: `activity_${activityId++}`,
+                        name: 'Wait for Approval',
+                        type: 'wait',
+                        wait_type: 'approval',
+                        inputs: {
+                            approval_record: '${activity_' + (activityId - 2) + '.approval_id}'
+                        }
+                    });
+                }
+            }
+            // Add update status if mentioned
+            if (lowerInstruction.includes('update') && lowerInstruction.includes('status')) {
+                activities.push({
+                    id: `activity_${activityId++}`,
+                    name: 'Update Request Status',
+                    type: 'update_record',
+                    table: triggerTable || 'sc_request',
+                    inputs: {
+                        record: '${trigger.current}',
+                        fields: {
+                            state: '${activity_' + (activityId - 2) + '.approval_state === "approved" ? "approved" : "rejected"}'
+                        }
+                    }
+                });
+            }
+            // Create flow definition
+            const flowDefinition = {
+                name: flowName,
+                description: instruction,
+                table: triggerTable,
+                trigger: {
+                    type: triggerType,
+                    table: triggerTable,
+                    condition: ''
+                },
+                activities: activities.length > 0 ? activities : [{
+                        id: 'activity_1',
+                        name: 'Log Action',
+                        type: 'log',
+                        message: 'Flow executed for: ' + instruction,
+                        level: 'info'
+                    }],
+                connections: []
+            };
+            // Generate connections between activities
+            for (let i = 0; i < activities.length - 1; i++) {
+                flowDefinition.connections.push({
+                    from: activities[i].id,
+                    to: activities[i + 1].id,
+                    type: 'always'
+                });
+            }
             return {
-                name: this.extractNameFromInstruction(instruction),
+                name: flowName,
                 description: instruction,
-                instruction: instruction
+                flow_definition: flowDefinition,
+                table: triggerTable,
+                trigger_type: triggerType,
+                condition: '',
+                active: true
             };
         }
         // For widgets, delegate to widget composer  
@@ -3799,6 +4004,10 @@ Use individual deployment tools like \`snow_deploy_${args.type}\` with manual co
                 name: this.extractNameFromInstruction(instruction),
                 title: this.extractNameFromInstruction(instruction),
                 description: instruction,
+                template: '<div>Widget placeholder - implement with proper template</div>',
+                css: '',
+                server_script: '',
+                client_script: '',
                 instruction: instruction
             };
         }
@@ -4203,15 +4412,39 @@ ${updateSetSession ? `📋 **Update Set**: ${updateSetSession.name}
      * Ensure active Update Set session
      */
     async ensureActiveUpdateSet(context) {
-        // This would call the update set MCP to ensure active session
-        // For now, return a mock session
-        return {
-            session: {
-                update_set_id: 'mock_update_set_id',
-                name: `Auto-${context}`,
-                artifacts: []
+        try {
+            // Call the real Update Set MCP to ensure active session
+            const result = await this.client.ensureUpdateSet();
+            if (result.success && result.data) {
+                return {
+                    session: {
+                        update_set_id: result.data.sys_id,
+                        name: result.data.name,
+                        artifacts: []
+                    }
+                };
             }
-        };
+            // If no current update set, create a new one via the Update Set MCP
+            const createResult = await this.client.createUpdateSet({
+                name: `Auto-${context}-${Date.now()}`,
+                description: `Automatically created for ${context}`,
+                context: context
+            });
+            if (createResult.success && createResult.data) {
+                return {
+                    session: {
+                        update_set_id: createResult.data.sys_id,
+                        name: createResult.data.name,
+                        artifacts: []
+                    }
+                };
+            }
+            throw new Error('Failed to ensure Update Set session');
+        }
+        catch (error) {
+            this.logger.error('Failed to ensure Update Set session', error);
+            throw new Error(`Update Set session required for deployment. Error: ${error.message}`);
+        }
     }
     /**
      * DEPRECATION HANDLERS - Redirect old tools to new unified system