snow-flow 1.3.16 → 1.3.18

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;

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

@@ -41,6 +41,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceNowXMLFlowMCP = void 0;
 const base_mcp_server_1 = require("./base-mcp-server");
 const improved_flow_xml_generator_1 = __importStar(require("../utils/improved-flow-xml-generator"));
+const xml_first_flow_generator_1 = require("../utils/xml-first-flow-generator"); // Keep for backward compatibility
 const natural_language_mapper_1 = require("../api/natural-language-mapper");
 const servicenow_id_generator_js_1 = require("../utils/servicenow-id-generator.js");
 const fs = __importStar(require("fs"));
@@ -118,7 +119,7 @@ class ServiceNowXMLFlowMCP extends base_mcp_server_1.BaseMCPServer {
         // Generate flow XML from natural language
         this.registerTool({
             name: 'snow_xml_flow_from_instruction',
-            description: 'Generate flow Update Set XML from natural language instruction',
+            description: '⚠️ DEPRECATED - Use snow_create_flow instead. This tool is kept for backwards compatibility only.',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -130,6 +131,11 @@ class ServiceNowXMLFlowMCP extends base_mcp_server_1.BaseMCPServer {
                         type: 'boolean',
                         default: true,
                         description: 'Save XML to file'
+                    },
+                    auto_deploy: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'Automatically deploy XML to ServiceNow after generation (RECOMMENDED)'
                     }
                 },
                 required: ['instruction']
@@ -219,7 +225,7 @@ class ServiceNowXMLFlowMCP extends base_mcp_server_1.BaseMCPServer {
      */
     async generateFlowFromInstruction(args) {
         try {
-            const { instruction } = args;
+            const { instruction, auto_deploy = true } = args;
             // Parse natural language to flow components
             const flowRequirements = await this.nlMapper.parseFlowRequirements(instruction);
             // Convert to IMPROVED flow definition
@@ -235,21 +241,128 @@ class ServiceNowXMLFlowMCP extends base_mcp_server_1.BaseMCPServer {
                 tags: ['auto-generated'],
                 activities: this.convertToImprovedActivities(flowRequirements)
             };
-            // Use IMPROVED generator
-            const result = (0, improved_flow_xml_generator_1.generateImprovedFlowXML)(flowDef);
+            // Use PRODUCTION-READY generator with proper Update Set structure
+            const result = (0, xml_first_flow_generator_1.generateProductionFlowXML)(flowDef);
+            let deploymentResult = null;
+            // 🚀 AUTO-DEPLOYMENT: Deploy immediately if requested
+            if (auto_deploy) {
+                try {
+                    this.logger.info('🚀 AUTO-DEPLOYING XML to ServiceNow...');
+                    // 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 client = new ServiceNowClient();
+                    // Read the XML file
+                    const fs = require('fs').promises;
+                    const xmlContent = await fs.readFile(result.filePath, '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`
+                    });
+                    deploymentResult = {
+                        success: true,
+                        message: '✅ XML automatically deployed to ServiceNow!',
+                        update_set_id: updateSetId,
+                        update_set_name: updateSetName,
+                        steps_completed: [
+                            '✅ XML imported as remote update set',
+                            '✅ Update set loaded successfully',
+                            '✅ Preview completed with no problems',
+                            '✅ Update set committed successfully'
+                        ]
+                    };
+                    this.logger.info('✅ Auto-deployment successful', deploymentResult);
+                }
+                catch (deployError) {
+                    this.logger.warn('⚠️ Auto-deployment failed, providing manual instructions', deployError);
+                    deploymentResult = {
+                        success: false,
+                        error: deployError instanceof Error ? deployError.message : String(deployError),
+                        manual_command: `snow-flow deploy-xml ${result.filePath}`,
+                        troubleshooting: [
+                            '1. Check ServiceNow authentication: snow-flow auth status',
+                            '2. Verify admin permissions in ServiceNow',
+                            '3. Review XML file for format issues',
+                            '4. Try manual deployment command above'
+                        ]
+                    };
+                }
+            }
             return {
                 success: true,
                 xml: args.save_to_file === false ? result.xml : undefined,
                 file_path: result.filePath,
                 flow_definition: flowDef,
-                message: `✅ Generated IMPROVED flow XML from instruction: ${instruction}`,
+                deployment: deploymentResult,
+                message: `✅ Generated IMPROVED flow XML from instruction: ${instruction}${deploymentResult?.success ? ' + DEPLOYED!' : ''}`,
                 improvements: [
                     '✅ Production-ready Flow Designer format',
                     '✅ Complete XML structure with all required fields',
                     '✅ Base64+gzip encoded action values',
-                    '✅ Proper v2 table usage'
+                    '✅ Proper v2 table usage',
+                    ...(deploymentResult?.success ? ['✅ Automatically deployed to ServiceNow!'] : [])
                 ],
-                import_instructions: result.instructions
+                import_instructions: deploymentResult?.success ? 'Flow is already deployed and ready to use!' : result.instructions,
+                auto_deploy_command: deploymentResult?.manual_command || `snow-flow deploy-xml ${result.filePath}`
             };
         }
         catch (error) {

package/dist/types/index.js

@@ -17,4 +17,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // Re-export coordination framework types
 __exportStar(require("./snow-flow.types"), exports);
-__exportStar(require("../coordination/types"), exports);