snow-flow 1.3.17 → 1.3.19

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

@@ -5231,10 +5231,145 @@ Use individual deployment tools like \`snow_deploy_${args.type}\` with manual co
                 return await this.deployFlow(scopedConfig);
             case 'application':
                 return await this.deployApplication(scopedConfig);
+            case 'xml_update_set':
+                return await this.deployXMLUpdateSet(scopedConfig);
             default:
                 throw new Error(`Unsupported artifact type for unified deployment: ${type}`);
         }
     }
+    /**
+     * Deploy XML Update Set to ServiceNow
+     */
+    async deployXMLUpdateSet(config) {
+        const { xml_file_path, auto_preview = true, auto_commit = true } = config;
+        if (!xml_file_path) {
+            throw new Error('XML file path is required for xml_update_set deployment');
+        }
+        this.logger.info('🚀 Deploying XML Update Set', {
+            file: xml_file_path,
+            auto_preview,
+            auto_commit
+        });
+        try {
+            // Read XML file
+            const fs = require('fs').promises;
+            const xmlContent = await fs.readFile(xml_file_path, 'utf-8');
+            // Import XML as remote update set
+            const importResponse = await this.client.makeRequest({
+                method: 'POST',
+                url: '/api/now/table/sys_remote_update_set',
+                headers: {
+                    'Content-Type': 'application/xml',
+                    'Accept': 'application/json'
+                },
+                data: xmlContent
+            });
+            if (!importResponse.result || !importResponse.result.sys_id) {
+                throw new Error('Failed to import XML update set');
+            }
+            const remoteUpdateSetId = importResponse.result.sys_id;
+            this.logger.info('✅ XML imported successfully', { sys_id: remoteUpdateSetId });
+            // Load the update set
+            await this.client.makeRequest({
+                method: 'PUT',
+                url: `/api/now/table/sys_remote_update_set/${remoteUpdateSetId}`,
+                data: {
+                    state: 'loaded'
+                }
+            });
+            // Find the loaded update set
+            const loadedResponse = await this.client.makeRequest({
+                method: 'GET',
+                url: '/api/now/table/sys_update_set',
+                params: {
+                    sysparm_query: `remote_sys_id=${remoteUpdateSetId}`,
+                    sysparm_limit: 1
+                }
+            });
+            if (!loadedResponse.result || loadedResponse.result.length === 0) {
+                throw new Error('Failed to find loaded update set');
+            }
+            const updateSetId = loadedResponse.result[0].sys_id;
+            const updateSetName = loadedResponse.result[0].name;
+            // Preview if requested
+            if (auto_preview) {
+                const previewResponse = await this.client.makeRequest({
+                    method: 'POST',
+                    url: `/api/now/table/sys_update_set/${updateSetId}/preview`
+                });
+                // Check preview results
+                const previewProblems = await this.client.makeRequest({
+                    method: 'GET',
+                    url: '/api/now/table/sys_update_preview_problem',
+                    params: {
+                        sysparm_query: `update_set=${updateSetId}`,
+                        sysparm_limit: 100
+                    }
+                });
+                if (previewProblems.result && previewProblems.result.length > 0) {
+                    const problems = previewProblems.result.map((p) => `- ${p.type}: ${p.description}`).join('\n');
+                    if (auto_commit) {
+                        this.logger.warn('Preview found problems, skipping auto-commit', { problems });
+                    }
+                    return {
+                        success: true,
+                        message: 'XML imported and previewed with problems',
+                        update_set_id: updateSetId,
+                        update_set_name: updateSetName,
+                        preview_status: 'problems_found',
+                        problems: previewProblems.result,
+                        next_steps: [
+                            '1. Review preview problems in ServiceNow',
+                            '2. Resolve any issues',
+                            '3. Commit manually when ready'
+                        ]
+                    };
+                }
+                // Commit if clean and requested
+                if (auto_commit) {
+                    await this.client.makeRequest({
+                        method: 'POST',
+                        url: `/api/now/table/sys_update_set/${updateSetId}/commit`
+                    });
+                    return {
+                        success: true,
+                        message: '✅ XML Update Set imported, previewed, and committed successfully!',
+                        update_set_id: updateSetId,
+                        update_set_name: updateSetName,
+                        status: 'committed',
+                        flow_location: 'Flow Designer > Designer',
+                        next_steps: [
+                            '1. Navigate to Flow Designer',
+                            '2. Your flow should be visible in the list',
+                            '3. Open the flow to verify all components'
+                        ]
+                    };
+                }
+            }
+            // Return success without preview/commit
+            return {
+                success: true,
+                message: 'XML Update Set imported successfully',
+                update_set_id: updateSetId,
+                update_set_name: updateSetName,
+                status: 'imported',
+                next_steps: [
+                    '1. Navigate to System Update Sets > Local Update Sets',
+                    '2. Find your update set: ' + updateSetName,
+                    '3. Click Preview Update Set',
+                    '4. Review and commit when ready'
+                ]
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logger.error('XML deployment failed', { error: errorMsg, file: xml_file_path });
+            if (errorMsg.includes('ENOENT') || errorMsg.includes('no such file')) {
+                throw new Error(`XML file not found: ${xml_file_path}`);
+            }
+            throw new Error(`XML deployment failed: ${errorMsg}`);
+        }
+    }
     /**
      * Check if error is permission-related
      */

package/dist/mcp/servicenow-flow-composer-mcp.js

@@ -4,6 +4,39 @@
  * ServiceNow Flow Composer MCP Server
  * Natural language flow creation with multi-artifact orchestration
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -11,7 +44,6 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const servicenow_client_js_1 = require("../utils/servicenow-client.js");
 const snow_oauth_js_1 = require("../utils/snow-oauth.js");
 const logger_js_1 = require("../utils/logger.js");
-const flow_structure_builder_js_1 = require("../utils/flow-structure-builder.js");
 class ServiceNowFlowComposerMCP {
     constructor() {
         this.server = new index_js_1.Server({
@@ -32,7 +64,7 @@ class ServiceNowFlowComposerMCP {
             tools: [
                 {
                     name: 'snow_create_flow',
-                    description: 'FULLY AUTONOMOUS flow creation - parses natural language, discovers artifacts, creates missing components, links everything, deploys automatically. ZERO MANUAL WORK!',
+                    description: '🚀 PRIMARY FLOW TOOL - Create production-ready Flow Designer flows with XML-first approach and automatic deployment to ServiceNow. ZERO MANUAL STEPS!',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -297,30 +329,43 @@ class ServiceNowFlowComposerMCP {
             // 🧠 STEP 4: Generate complete flow definition
             const flowDefinition = await this.generateFlowDefinition(parsedIntent, templateMatch, artifacts);
             console.log('🧠 Generated flow definition:', JSON.stringify(flowDefinition, null, 2));
-            // 🧠 STEP 5: Deploy if requested
+            // 🧠 STEP 5: Deploy using XML-first approach for maximum reliability
             let deploymentResult = null;
             if (args.deploy_immediately !== false) {
-                console.log('🚀 DEPLOYING intelligent flow to ServiceNow...');
-                // Use the conversion utility to ensure proper format
-                const enhancedFlowDefinition = (0, flow_structure_builder_js_1.convertToFlowDefinition)({
-                    name: parsedIntent.flowName,
-                    description: parsedIntent.description,
-                    table: parsedIntent.table,
-                    trigger: parsedIntent.trigger,
-                    activities: flowDefinition.activities || [],
-                    variables: flowDefinition.variables || [],
-                    connections: flowDefinition.connections || [],
-                    error_handling: flowDefinition.error_handling || []
-                });
-                // Try enhanced method first, fallback to original if needed
+                console.log('🚀 DEPLOYING flow using XML-first approach...');
                 try {
-                    deploymentResult = await this.client.createFlowWithStructureBuilder(enhancedFlowDefinition);
-                    console.log('🚀 Enhanced deployment result:', deploymentResult);
+                    // Import the XML flow generator
+                    const { generateProductionFlowXML } = await Promise.resolve().then(() => __importStar(require('../utils/xml-first-flow-generator.js')));
+                    // Convert to XML flow definition format
+                    const xmlFlowDef = {
+                        name: parsedIntent.flowName,
+                        description: parsedIntent.description,
+                        table: parsedIntent.table,
+                        trigger_type: this.mapTriggerTypeToXML(parsedIntent.trigger.type),
+                        trigger_condition: parsedIntent.trigger.condition || '',
+                        activities: this.convertActivitiesToXML(flowDefinition.activities || []),
+                        run_as: 'user',
+                        accessible_from: 'package_private'
+                    };
+                    // Generate production-ready XML
+                    const xmlResult = generateProductionFlowXML(xmlFlowDef);
+                    console.log('✅ XML generated:', xmlResult.filePath);
+                    // Auto-deploy XML to ServiceNow
+                    await this.deployXMLToServiceNow(xmlResult.filePath);
+                    deploymentResult = {
+                        success: true,
+                        method: 'xml_first',
+                        xml_file: xmlResult.filePath,
+                        message: '✅ Flow deployed using XML-first approach!'
+                    };
                 }
-                catch (enhancedError) {
-                    console.warn('⚠️ Enhanced deployment failed, falling back to original method:', enhancedError);
-                    deploymentResult = await this.client.createFlow(flowDefinition);
-                    console.log('🚀 Fallback deployment result:', deploymentResult);
+                catch (xmlError) {
+                    console.warn('⚠️ XML deployment failed, providing manual instructions:', xmlError);
+                    deploymentResult = {
+                        success: false,
+                        error: xmlError instanceof Error ? xmlError.message : String(xmlError),
+                        fallback_instructions: 'Use snow-flow deploy-xml command for manual deployment'
+                    };
                 }
             }
             const credentials = await this.oauth.loadCredentials();
@@ -329,9 +374,9 @@ class ServiceNowFlowComposerMCP {
                 content: [
                     {
                         type: 'text',
-                        text: `🎯 INTELLIGENT FLOW CREATED SUCCESSFULLY!
+                        text: `🎯 FLOW CREATED WITH XML-FIRST APPROACH!
 
-${args.deploy_immediately !== false ? `🚀 **LIVE DEPLOYMENT** - Real flow created in ServiceNow!` : `📋 **PLANNING MODE** - Flow structure generated`}
+${args.deploy_immediately !== false ? `🚀 **FULLY AUTOMATED DEPLOYMENT** - XML generated & deployed to ServiceNow!` : `📋 **PLANNING MODE** - Flow structure generated`}
 
 🧠 **Intelligent Analysis:**
 - **Flow Name**: ${parsedIntent.flowName}
@@ -347,26 +392,27 @@ ${args.deploy_immediately !== false ? `🚀 **LIVE DEPLOYMENT** - Real flow crea
 - **Error Handling**: ${flowDefinition.error_handling?.length || 0} safety measures
 - **Artifacts Used**: ${artifacts.existing.length} found, ${artifacts.created.length} created
 
-🚀 **Deployment Status:**
-${deploymentResult ? (deploymentResult.success ? '✅ Successfully deployed to ServiceNow!' : `❌ Deployment failed: ${deploymentResult.error}`) : '⏳ Ready for deployment'}
-
-${deploymentResult?.success ? `🎯 **Live Flow Details:**
-- **System ID**: ${deploymentResult.data?.sys_id || 'Unknown'}
-- **Status**: ${deploymentResult.data?.status || 'Active'}
-- **URL**: ${deploymentResult.data?.url || flowUrl}` : ''}
+🚀 **XML-First Deployment:**
+${deploymentResult ? (deploymentResult.success ?
+                            `✅ Successfully deployed using XML-first approach!
+- **Method**: Production-ready Update Set XML
+- **XML File**: ${deploymentResult.xml_file}
+- **Status**: Imported → Previewed → Committed ✅` :
+                            `❌ Auto-deployment failed: ${deploymentResult.error}
+- **Fallback**: ${deploymentResult.fallback_instructions}`) : '⏳ Ready for deployment'}
 
 🔗 **ServiceNow Access:**
 - Flow Designer: ${flowUrl}  
 - Flow Designer Home: https://${credentials?.instance}/flow-designer
 
-🧠 **Intelligence Features:**
-- Natural language processing ✅
-- Template matching and adaptation ✅  
-- Artifact discovery and reuse ✅
-- Complete flow definition generation ✅
-- Error handling and validation ✅
+🧠 **NEW Features (v1.3.17):**
+- XML-first approach for maximum reliability ✅
+- Automatic Update Set deployment ✅
+- Zero manual steps required ✅
+- Production-ready Flow Designer format ✅
+- Intelligent error handling & fallbacks ✅
 
-Your flow is now intelligently crafted and ready for use! 🎉`,
+Your flow is now live in ServiceNow Flow Designer! 🎉`,
                     },
                 ],
             };
@@ -1679,7 +1725,7 @@ ${flowInstruction.recommendations?.map((rec, index) => `${index + 1}. ${rec}`).j
 
 🚀 **Next Steps:**
 1. Use \`snow_template_matching\` to explore template options
-2. Run \`snow_create_flow\` to implement the recommended approach
+2. Run \`snow_create_flow\` with deploy_immediately: true to implement the recommended approach
 3. Consider \`snow_scope_optimization\` for deployment strategy
 
 ✅ **Analysis Complete!** The instruction has been comprehensively analyzed with intelligent insights.`,
@@ -1841,7 +1887,7 @@ ${categoryFilteredResults.length === 0 ? `🔍 **No templates found matching you
 - **Recommended**: ${categoryFilteredResults[0]?.confidence >= 0.8 ? 'Yes - High confidence match' : 'Consider manual review'}
 
 🚀 **Next Steps:**
-1. Use \`snow_create_flow\` to implement the best matching template
+1. Use \`snow_create_flow\` with deploy_immediately: true to implement the best matching template
 2. Review template customization options
 3. Consider \`snow_intelligent_flow_analysis\` for detailed analysis
 4. Modify instruction if no suitable templates found
@@ -1860,6 +1906,128 @@ ${categoryFilteredResults.length === 0 ? `🔍 **No templates found matching you
         await this.server.connect(transport);
         this.logger.info('ServiceNow Flow Composer MCP Server started');
     }
+    /**
+     * Map trigger type to XML format
+     */
+    mapTriggerTypeToXML(triggerType) {
+        const mapping = {
+            'record_created': 'record_created',
+            'record_updated': 'record_updated',
+            'manual': 'manual',
+            'scheduled': 'scheduled',
+            'create': 'record_created',
+            'update': 'record_updated',
+            'on_create': 'record_created',
+            'on_update': 'record_updated'
+        };
+        return mapping[triggerType.toLowerCase()] || 'manual';
+    }
+    /**
+     * Convert activities to XML format
+     */
+    convertActivitiesToXML(activities) {
+        return activities.map((activity, index) => ({
+            type: this.mapActivityTypeToXML(activity.type),
+            name: activity.name || `Activity ${index + 1}`,
+            inputs: activity.inputs || {},
+            order: (index + 1) * 100,
+            description: activity.description || activity.name
+        }));
+    }
+    /**
+     * Map activity type to XML format
+     */
+    mapActivityTypeToXML(activityType) {
+        const mapping = {
+            'approval': 'approval',
+            'notification': 'notification',
+            'email': 'notification',
+            'script': 'script',
+            'create_record': 'create_record',
+            'update_record': 'update_record',
+            'rest_call': 'rest_step',
+            'condition': 'condition',
+            'subflow': 'assign_subflow'
+        };
+        return mapping[activityType.toLowerCase()] || 'script';
+    }
+    /**
+     * Deploy XML file to ServiceNow automatically
+     */
+    async deployXMLToServiceNow(xmlFilePath) {
+        // Check authentication
+        const isAuth = await this.oauth.isAuthenticated();
+        if (!isAuth) {
+            throw new Error('Not authenticated with ServiceNow. Please run: snow-flow auth login');
+        }
+        // Initialize ServiceNow client
+        const ServiceNowClient = (await Promise.resolve().then(() => __importStar(require('../utils/servicenow-client.js')))).ServiceNowClient;
+        const client = new ServiceNowClient();
+        // Read the XML file
+        const fs = require('fs').promises;
+        const xmlContent = await fs.readFile(xmlFilePath, 'utf-8');
+        // Import XML as remote update set
+        const importResponse = await client.makeRequest({
+            method: 'POST',
+            url: '/api/now/table/sys_remote_update_set',
+            headers: {
+                'Content-Type': 'application/xml',
+                'Accept': 'application/json'
+            },
+            data: xmlContent
+        });
+        if (!importResponse.result || !importResponse.result.sys_id) {
+            throw new Error('Failed to import XML update set');
+        }
+        const remoteUpdateSetId = importResponse.result.sys_id;
+        this.logger.info(`✅ XML imported successfully (sys_id: ${remoteUpdateSetId})`);
+        // Load the update set
+        await client.makeRequest({
+            method: 'PUT',
+            url: `/api/now/table/sys_remote_update_set/${remoteUpdateSetId}`,
+            data: {
+                state: 'loaded'
+            }
+        });
+        // Find the loaded update set
+        const loadedResponse = await client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sys_update_set',
+            params: {
+                sysparm_query: `remote_sys_id=${remoteUpdateSetId}`,
+                sysparm_limit: 1
+            }
+        });
+        if (!loadedResponse.result || loadedResponse.result.length === 0) {
+            throw new Error('Failed to find loaded update set');
+        }
+        const updateSetId = loadedResponse.result[0].sys_id;
+        const updateSetName = loadedResponse.result[0].name;
+        // Preview the update set
+        await client.makeRequest({
+            method: 'POST',
+            url: `/api/now/table/sys_update_set/${updateSetId}/preview`
+        });
+        // Check for preview problems
+        const previewProblems = await client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sys_update_preview_problem',
+            params: {
+                sysparm_query: `update_set=${updateSetId}`,
+                sysparm_limit: 100
+            }
+        });
+        if (previewProblems.result && previewProblems.result.length > 0) {
+            const problemsList = previewProblems.result.map((p) => `- ${p.type}: ${p.description}`).join('\n');
+            throw new Error(`Preview found problems:\n${problemsList}\n\nPlease review and resolve in ServiceNow UI`);
+        }
+        // Commit the update set
+        await client.makeRequest({
+            method: 'POST',
+            url: `/api/now/table/sys_update_set/${updateSetId}/commit`
+        });
+        this.logger.info(`✅ Update set committed successfully: ${updateSetName}`);
+    }
 }
 // Start the server
 const server = new ServiceNowFlowComposerMCP();

package/dist/mcp/servicenow-platform-development-mcp.js

@@ -302,6 +302,24 @@ class ServiceNowPlatformDevelopmentMCP {
     async getTableInfo(tableName) {
         try {
             this.logger.debug(`Looking up table info for: ${tableName}`);
+            // First, check if this is a known standard table that may not appear in sys_db_object
+            const standardTables = {
+                'incident': { label: 'Incident' },
+                'problem': { label: 'Problem' },
+                'change_request': { label: 'Change Request' },
+                'sc_request': { label: 'Request' },
+                'sc_req_item': { label: 'Requested Item' },
+                'sc_task': { label: 'Catalog Task' },
+                'task': { label: 'Task' }
+            };
+            if (standardTables[tableName]) {
+                this.logger.debug(`Using known standard table: ${tableName}`);
+                return {
+                    name: tableName,
+                    label: standardTables[tableName].label,
+                    sys_id: `standard_table_${tableName}` // Placeholder sys_id for standard tables
+                };
+            }
             // Try direct lookup first
             const tableResponse = await this.client.searchRecords('sys_db_object', `name=${tableName}`, 1);
             if (tableResponse.success && tableResponse.data?.result?.length > 0) {
@@ -312,6 +330,8 @@ class ServiceNowPlatformDevelopmentMCP {
                     sys_id: table.sys_id
                 };
             }
+            // Log the actual response for debugging
+            this.logger.debug(`Table lookup response for ${tableName}: ${JSON.stringify(tableResponse)}`);
             // Try by sys_id
             const tableByIdResponse = await this.client.searchRecords('sys_db_object', `sys_id=${tableName}`, 1);
             if (tableByIdResponse.success && tableByIdResponse.data?.result?.length > 0) {
@@ -583,10 +603,15 @@ class ServiceNowPlatformDevelopmentMCP {
             this.logger.debug(`Found table info: ${JSON.stringify(tableInfo)}`);
             // Get detailed table metadata
             this.logger.debug(`Attempting to fetch table details for sys_id: ${tableInfo.sys_id}`);
-            const tableDetailsResponse = await this.client.getRecord('sys_db_object', tableInfo.sys_id);
+            // Check if this is a standard table with placeholder sys_id
+            const isStandardTable = tableInfo.sys_id.startsWith('standard_table_');
+            let tableDetailsResponse = { success: false };
+            if (!isStandardTable) {
+                tableDetailsResponse = await this.client.getRecord('sys_db_object', tableInfo.sys_id);
+            }
             // Declare the variable once with proper type
             let tableDetails;
-            if (!tableDetailsResponse.success) {
+            if (!tableDetailsResponse.success || isStandardTable) {
                 const errorMessage = tableDetailsResponse.error ||
                     JSON.stringify(tableDetailsResponse) ||
                     'Unknown error occurred while fetching table details';

package/dist/mcp/servicenow-update-set-mcp-refactored.js

@@ -187,6 +187,10 @@ class ServiceNowUpdateSetMCP extends base_mcp_server_js_1.BaseMCPServer {
                 url: '/api/now/table/sys_update_set',
                 data: updateSetData
             });
+            // Validate response structure
+            if (!response || !response.result) {
+                throw new Error(`Invalid API response: ${JSON.stringify(response)}`);
+            }
             const updateSet = response.result;
             // Create session
             const session = {

package/dist/mcp/servicenow-update-set-mcp.js

@@ -276,6 +276,10 @@ class ServiceNowUpdateSetMCP {
             if (!response.success) {
                 throw new Error(response.error || 'Failed to create Update Set');
             }
+            // Validate response structure
+            if (!response.data || !response.data.sys_id) {
+                throw new Error(`Invalid Update Set response: missing data or sys_id. Response: ${JSON.stringify(response)}`);
+            }
             // Auto-switch to Update Set if requested (default: true)
             const autoSwitch = args.auto_switch !== false;
             let switchedToUpdateSet = false;