snow-flow 1.2.3 → 1.3.0

package/dist/mcp/base-mcp-server.js

@@ -66,10 +66,12 @@ class BaseMCPServer {
             let metrics = this.toolMetrics.get(name) || { calls: 0, totalTime: 0, errors: 0 };
             metrics.calls++;
             try {
-                // Validate authentication first
-                const authResult = await this.validateAuth();
-                if (!authResult.success) {
-                    throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Authentication failed: ${authResult.error}`);
+                // Validate authentication first (skip if not required)
+                if (this.config.requiresAuth !== false) {
+                    const authResult = await this.validateAuth();
+                    if (!authResult.success) {
+                        throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Authentication failed: ${authResult.error}`);
+                    }
                 }
                 // Execute tool with retry logic
                 const result = await this.executeWithRetry(name, args);
@@ -91,6 +93,10 @@ class BaseMCPServer {
      * Setup authentication with automatic token refresh
      */
     setupAuthentication() {
+        // Skip authentication setup if not required
+        if (this.config.requiresAuth === false) {
+            return;
+        }
         // Check auth every 5 minutes
         this.authCheckInterval = setInterval(async () => {
             try {
@@ -305,10 +311,12 @@ class BaseMCPServer {
      */
     async start() {
         this.logger.info(`Starting ${this.config.name} v${this.config.version}`);
-        // Validate initial connection
-        const authResult = await this.validateAuth();
-        if (!authResult.success) {
-            this.logger.warn('Starting without authentication - some features may be limited');
+        // Validate initial connection (skip if not required)
+        if (this.config.requiresAuth !== false) {
+            const authResult = await this.validateAuth();
+            if (!authResult.success) {
+                this.logger.warn('Starting without authentication - some features may be limited');
+            }
         }
         await this.server.connect(this.transport);
         this.logger.info('MCP server started successfully');

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

@@ -2258,6 +2258,384 @@ Run snow_deployment_debug for basic session info or check the logs for more deta
         }
         return result;
     }
+    /**
+     * Generate Update Set XML based on artifact type
+     */
+    async generateUpdateSetXML(type, config, updateSetSession) {
+        switch (type) {
+            case 'widget':
+                return this.generateWidgetUpdateSetXML(config);
+            case 'flow':
+                return this.generateFlowUpdateSetXML(config);
+            case 'application':
+                return this.generateApplicationUpdateSetXML(config);
+            default:
+                throw new Error(`Update Set XML generation not implemented for type: ${type}`);
+        }
+    }
+    /**
+     * Generate Update Set XML for Flow Designer flows
+     */
+    generateFlowUpdateSetXML(args) {
+        const timestamp = new Date().toISOString();
+        const updateSetName = `Flow_${args.name}_${Date.now()}`;
+        // Generate unique identifiers
+        const updateSetId = this.generateGUID();
+        const flowId = this.generateGUID();
+        const triggerId = this.generateGUID();
+        const updateXmlId = this.generateGUID();
+        // Parse flow definition if it's a string
+        let flowDefinition = args.flow_definition;
+        if (typeof flowDefinition === 'string') {
+            try {
+                flowDefinition = JSON.parse(flowDefinition);
+            }
+            catch (e) {
+                flowDefinition = { activities: [] };
+            }
+        }
+        // Ensure flow definition has proper structure
+        if (!flowDefinition || typeof flowDefinition !== 'object') {
+            flowDefinition = { activities: [] };
+        }
+        // Generate action instances and flow logic
+        const { actionInstances, flowLogics, completeFlowDefinition } = this.generateFlowComponents(flowDefinition, flowId, triggerId, timestamp);
+        // Calculate total update count
+        const totalUpdates = 1 + actionInstances.length + flowLogics.length + 1; // flow + actions + logics + trigger
+        const xmlContent = `<?xml version="1.0" encoding="UTF-8"?>
+<unload unload_date="${timestamp}">
+  <sys_update_set action="INSERT_OR_UPDATE">
+    <application display_value="Global">global</application>
+    <category>customer</category>
+    <description>Auto-generated Update Set for Flow Designer: ${args.name}</description>
+    <is_default>false</is_default>
+    <name>${updateSetName}</name>  
+    <origin_sys_id/>
+    <release_date/>
+    <state>complete</state>
+    <sys_created_by>snow-flow</sys_created_by>
+    <sys_created_on>${timestamp}</sys_created_on>
+    <sys_id>${updateSetId}</sys_id>
+    <sys_mod_count>0</sys_mod_count>
+    <sys_updated_by>snow-flow</sys_updated_by>
+    <sys_updated_on>${timestamp}</sys_updated_on>
+    <update_count>${totalUpdates}</update_count>
+  </sys_update_set>
+  
+  <!-- Main Flow Record -->
+  <sys_update_xml action="INSERT_OR_UPDATE">
+    <action>INSERT_OR_UPDATE</action>
+    <application display_value="Global">global</application>
+    <category>customer</category>
+    <comments/>
+    <name>sys_hub_flow_${flowId}</name>
+    <payload><![CDATA[<?xml version="1.0" encoding="UTF-8"?>
+<record_update table="sys_hub_flow">
+  <sys_hub_flow action="INSERT_OR_UPDATE">
+    <access>public</access>
+    <acls/>
+    <active>${args.active !== false ? 'true' : 'false'}</active>
+    <annotation/>
+    <callable_by_client_api>false</callable_by_client_api>
+    <category>${args.category || 'automation'}</category>
+    <checked_out_by/>
+    <compiler_build/>
+    <copied_from/>
+    <copied_from_name/>
+    <description>${args.description || ''}</description>  
+    <internal_name>global.${args.name}</internal_name>
+    <label_cache>[{"name":"${args.name}","internal_name":"${args.name}","label":"${args.name}","description":"${args.description || ''}","language":"en","source":""}]</label_cache>
+    <latest_snapshot/>
+    <master_snapshot><![CDATA[${JSON.stringify(completeFlowDefinition)}]]></master_snapshot>
+    <name>${args.name}</name>
+    <natlang/>
+    <outputs_cache>[]</outputs_cache>
+    <remote_trigger_id/>
+    <run_as>user</run_as>
+    <run_as_tz/>
+    <sc_callable>false</sc_callable>
+    <show_draft_actions>false</show_draft_actions>
+    <show_triggered_flows>false</show_triggered_flows>
+    <status>published</status>
+    <sys_class_name>sys_hub_flow</sys_class_name>
+    <sys_created_by>snow-flow</sys_created_by>
+    <sys_created_on>${timestamp}</sys_created_on>
+    <sys_domain>global</sys_domain>
+    <sys_domain_path>/</sys_domain_path>
+    <sys_id>${flowId}</sys_id>
+    <sys_mod_count>0</sys_mod_count>
+    <sys_name>${args.name}</sys_name>
+    <sys_overrides/>
+    <sys_package display_value="Global" source="global">global</sys_package>
+    <sys_policy/>
+    <sys_scope display_value="Global">global</sys_scope>
+    <sys_update_name>sys_hub_flow_${flowId}</sys_update_name>
+    <sys_updated_by>snow-flow</sys_updated_by>
+    <sys_updated_on>${timestamp}</sys_updated_on>
+    <type>${args.flow_type || 'flow'}</type>
+  </sys_hub_flow>
+</record_update>]]></payload>
+    <payload_hash>-1</payload_hash>
+    <record_name>${args.name}</record_name>
+    <reverted_from/>
+    <source_table>sys_hub_flow</source_table>
+    <state>current</state>
+    <sys_created_by>snow-flow</sys_created_by>
+    <sys_created_on>${timestamp}</sys_created_on>
+    <sys_id>${updateXmlId}</sys_id>
+    <sys_mod_count>0</sys_mod_count>
+    <sys_updated_by>snow-flow</sys_updated_by>
+    <sys_updated_on>${timestamp}</sys_updated_on>
+    <table>sys_hub_flow</table>
+    <target_name>${args.name}</target_name>
+    <type>Flow Designer</type>
+    <update_domain>global</update_domain>
+    <update_set display_value="${updateSetName}">${updateSetId}</update_set>
+    <view/>
+  </sys_update_xml>
+
+  <!-- Trigger Instance -->
+  ${this.generateTriggerInstanceXML(args, flowId, triggerId, timestamp, updateSetId, updateSetName)}
+
+  <!-- Action Instances -->
+  ${actionInstances.map(instance => instance.xml).join('\n\n  ')}
+
+  <!-- Flow Logic (Connections) -->
+  ${flowLogics.map(logic => logic.xml).join('\n\n  ')}
+</unload>`;
+        return xmlContent;
+    }
+    /**
+     * Generate flow components (actions, logic, complete definition)
+     */
+    generateFlowComponents(flowDefinition, flowId, triggerId, timestamp) {
+        const actionInstances = [];
+        const flowLogics = [];
+        // Process activities/actions from flow definition
+        const activities = flowDefinition.activities || flowDefinition.steps || [];
+        const actionIds = [];
+        // Generate action instances
+        activities.forEach((activity, index) => {
+            const actionId = this.generateGUID();
+            actionIds.push(actionId);
+            const actionXml = this.generateActionInstanceXML(activity, actionId, flowId, index, timestamp);
+            actionInstances.push({ id: actionId, xml: actionXml });
+        });
+        // Generate flow logic (connections between actions)
+        for (let i = 0; i < actionIds.length; i++) {
+            const logicId = this.generateGUID();
+            let fromId = i === 0 ? triggerId : actionIds[i - 1];
+            let toId = actionIds[i];
+            const logicXml = this.generateFlowLogicXML(logicId, flowId, fromId, toId, i, timestamp);
+            flowLogics.push({ id: logicId, xml: logicXml });
+        }
+        // Create complete flow definition with all components
+        const completeFlowDefinition = {
+            trigger: {
+                type: flowDefinition.trigger_type || "manual",
+                table: flowDefinition.table || "incident",
+                condition: flowDefinition.condition || "",
+                sys_id: triggerId
+            },
+            actions: activities.map((activity, index) => ({
+                ...activity,
+                sys_id: actionIds[index],
+                sequence: index + 1
+            })),
+            logic: flowLogics.map(logic => ({
+                sys_id: logic.id,
+                from: logic.id === flowLogics[0]?.id ? triggerId : actionIds[flowLogics.indexOf(logic) - 1],
+                to: actionIds[flowLogics.indexOf(logic)]
+            })),
+            inputs: flowDefinition.inputs || [],
+            outputs: flowDefinition.outputs || [],
+            steps: activities
+        };
+        return { actionInstances, flowLogics, completeFlowDefinition };
+    }
+    /**
+     * Generate trigger instance XML
+     */
+    generateTriggerInstanceXML(args, flowId, triggerId, timestamp, updateSetId, updateSetName) {
+        const updateXmlId = this.generateGUID();
+        return `<sys_update_xml action="INSERT_OR_UPDATE">
+    <action>INSERT_OR_UPDATE</action>
+    <application display_value="Global">global</application>
+    <category>customer</category>
+    <comments/>
+    <name>sys_hub_trigger_instance_${triggerId}</name>
+    <payload><![CDATA[<?xml version="1.0" encoding="UTF-8"?>
+<record_update table="sys_hub_trigger_instance">
+  <sys_hub_trigger_instance action="INSERT_OR_UPDATE">
+    <active>true</active>
+    <condition>${args.condition || ''}</condition>
+    <dynamic_ref_qual>false</dynamic_ref_qual>
+    <flow display_value="${args.name}">${flowId}</flow>
+    <order>100</order>
+    <sys_class_name>sys_hub_trigger_instance</sys_class_name>
+    <sys_created_by>snow-flow</sys_created_by>
+    <sys_created_on>${timestamp}</sys_created_on>
+    <sys_domain>global</sys_domain>
+    <sys_domain_path>/</sys_domain_path>
+    <sys_id>${triggerId}</sys_id>
+    <sys_mod_count>0</sys_mod_count>
+    <sys_name>${args.name} Trigger</sys_name>
+    <sys_overrides/>
+    <sys_package display_value="Global" source="global">global</sys_package>
+    <sys_policy/>
+    <sys_scope display_value="Global">global</sys_scope>
+    <sys_update_name>sys_hub_trigger_instance_${triggerId}</sys_update_name>
+    <sys_updated_by>snow-flow</sys_updated_by>
+    <sys_updated_on>${timestamp}</sys_updated_on>
+    <table>${args.table || 'incident'}</table>
+    <trigger_type>${args.trigger_type || 'manual'}</trigger_type>
+  </sys_hub_trigger_instance>
+</record_update>]]></payload>
+    <payload_hash>-1</payload_hash>
+    <record_name>${args.name} Trigger</record_name>
+    <reverted_from/>
+    <source_table>sys_hub_trigger_instance</source_table>
+    <state>current</state>
+    <sys_created_by>snow-flow</sys_created_by>
+    <sys_created_on>${timestamp}</sys_created_on>
+    <sys_id>${updateXmlId}</sys_id>
+    <sys_mod_count>0</sys_mod_count>
+    <sys_updated_by>snow-flow</sys_updated_by>
+    <sys_updated_on>${timestamp}</sys_updated_on>
+    <table>sys_hub_trigger_instance</table>
+    <target_name>${args.name} Trigger</target_name>
+    <type>Flow Designer</type>
+    <update_domain>global</update_domain>
+    <update_set display_value="${updateSetName}">${updateSetId}</update_set>
+    <view/>
+  </sys_update_xml>`;
+    }
+    /**
+     * Generate action instance XML
+     */
+    generateActionInstanceXML(activity, actionId, flowId, sequence, timestamp) {
+        const updateXmlId = this.generateGUID();
+        return `<sys_update_xml action="INSERT_OR_UPDATE">
+    <action>INSERT_OR_UPDATE</action>
+    <application display_value="Global">global</application>
+    <category>customer</category>
+    <comments/>
+    <name>sys_hub_action_instance_${actionId}</name>
+    <payload><![CDATA[<?xml version="1.0" encoding="UTF-8"?>
+<record_update table="sys_hub_action_instance">
+  <sys_hub_action_instance action="INSERT_OR_UPDATE">
+    <action>${activity.action || activity.type || 'script'}</action>
+    <action_name>${activity.name || `Step ${sequence + 1}`}</action_name>
+    <active>true</active>
+    <anchor_x>${activity.x || (200 + sequence * 150)}</anchor_x>
+    <anchor_y>${activity.y || 200}</anchor_y>
+    <flow display_value="Flow">${flowId}</flow>
+    <inputs>${JSON.stringify(activity.inputs || {})}</inputs>
+    <order>${(sequence + 1) * 100}</order>
+    <outputs>${JSON.stringify(activity.outputs || {})}</outputs>
+    <script>${activity.script || activity.code || ''}</script>
+    <sys_class_name>sys_hub_action_instance</sys_class_name>
+    <sys_created_by>snow-flow</sys_created_by>
+    <sys_created_on>${timestamp}</sys_created_on>
+    <sys_domain>global</sys_domain>
+    <sys_domain_path>/</sys_domain_path>
+    <sys_id>${actionId}</sys_id>
+    <sys_mod_count>0</sys_mod_count>
+    <sys_name>${activity.name || `Step ${sequence + 1}`}</sys_name>
+    <sys_overrides/>
+    <sys_package display_value="Global" source="global">global</sys_package>
+    <sys_policy/>
+    <sys_scope display_value="Global">global</sys_scope>
+    <sys_update_name>sys_hub_action_instance_${actionId}</sys_update_name>
+    <sys_updated_by>snow-flow</sys_updated_by>
+    <sys_updated_on>${timestamp}</sys_updated_on>
+  </sys_hub_action_instance>
+</record_update>]]></payload>
+    <payload_hash>-1</payload_hash>
+    <record_name>${activity.name || `Step ${sequence + 1}`}</record_name>
+    <reverted_from/>
+    <source_table>sys_hub_action_instance</source_table>
+    <state>current</state>
+    <sys_created_by>snow-flow</sys_created_by>
+    <sys_created_on>${timestamp}</sys_created_on>
+    <sys_id>${updateXmlId}</sys_id>
+    <sys_mod_count>0</sys_mod_count>
+    <sys_updated_by>snow-flow</sys_updated_by>
+    <sys_updated_on>${timestamp}</sys_updated_on>
+    <table>sys_hub_action_instance</table>
+    <target_name>${activity.name || `Step ${sequence + 1}`}</target_name>
+    <type>Flow Designer</type>
+    <update_domain>global</update_domain>
+    <update_set display_value="Flow Update Set">${flowId.substring(0, 8)}</update_set>
+    <view/>
+  </sys_update_xml>`;
+    }
+    /**
+     * Generate flow logic XML (connections between actions)
+     */
+    generateFlowLogicXML(logicId, flowId, fromId, toId, sequence, timestamp) {
+        const updateXmlId = this.generateGUID();
+        return `<sys_update_xml action="INSERT_OR_UPDATE">
+    <action>INSERT_OR_UPDATE</action>
+    <application display_value="Global">global</application>
+    <category>customer</category>
+    <comments/>
+    <name>sys_hub_flow_logic_${logicId}</name>
+    <payload><![CDATA[<?xml version="1.0" encoding="UTF-8"?>
+<record_update table="sys_hub_flow_logic">
+  <sys_hub_flow_logic action="INSERT_OR_UPDATE">
+    <condition>true</condition>
+    <flow display_value="Flow">${flowId}</flow>
+    <from_step>${fromId}</from_step>
+    <order>${(sequence + 1) * 10}</order>
+    <relationship_type>success</relationship_type>
+    <sys_class_name>sys_hub_flow_logic</sys_class_name>
+    <sys_created_by>snow-flow</sys_created_by>
+    <sys_created_on>${timestamp}</sys_created_on>
+    <sys_domain>global</sys_domain>
+    <sys_domain_path>/</sys_domain_path>
+    <sys_id>${logicId}</sys_id>
+    <sys_mod_count>0</sys_mod_count>
+    <sys_name>Connection ${sequence + 1}</sys_name>
+    <sys_overrides/>
+    <sys_package display_value="Global" source="global">global</sys_package>
+    <sys_policy/>
+    <sys_scope display_value="Global">global</sys_scope>
+    <sys_update_name>sys_hub_flow_logic_${logicId}</sys_update_name>
+    <sys_updated_by>snow-flow</sys_updated_by>
+    <sys_updated_on>${timestamp}</sys_updated_on>
+    <to_step>${toId}</to_step>
+  </sys_hub_flow_logic>
+</record_update>]]></payload>
+    <payload_hash>-1</payload_hash>
+    <record_name>Connection ${sequence + 1}</record_name>
+    <reverted_from/>
+    <source_table>sys_hub_flow_logic</source_table>
+    <state>current</state>
+    <sys_created_by>snow-flow</sys_created_by>
+    <sys_created_on>${timestamp}</sys_created_on>
+    <sys_id>${updateXmlId}</sys_id>
+    <sys_mod_count>0</sys_mod_count>
+    <sys_updated_by>snow-flow</sys_updated_by>
+    <sys_updated_on>${timestamp}</sys_updated_on>
+    <table>sys_hub_flow_logic</table>
+    <target_name>Connection ${sequence + 1}</target_name>
+    <type>Flow Designer</type>
+    <update_domain>global</update_domain>
+    <update_set display_value="Flow Update Set">${flowId.substring(0, 8)}</update_set>
+    <view/>
+  </sys_update_xml>`;
+    }
+    /**
+     * Generate Update Set XML for applications (stub for now)
+     */
+    generateApplicationUpdateSetXML(args) {
+        // TODO: Implement application XML generation
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<unload>
+  <!-- Application Update Set XML not yet implemented -->
+</unload>`;
+    }
     /**
      * Preview widget with test data
      */

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

@@ -11,6 +11,7 @@ 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({
@@ -300,8 +301,27 @@ class ServiceNowFlowComposerMCP {
             let deploymentResult = null;
             if (args.deploy_immediately !== false) {
                 console.log('🚀 DEPLOYING intelligent flow to ServiceNow...');
-                deploymentResult = await this.client.createFlow(flowDefinition);
-                console.log('🚀 Deployment result:', deploymentResult);
+                // 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
+                try {
+                    deploymentResult = await this.client.createFlowWithStructureBuilder(enhancedFlowDefinition);
+                    console.log('🚀 Enhanced deployment result:', deploymentResult);
+                }
+                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);
+                }
             }
             const credentials = await this.oauth.loadCredentials();
             const flowUrl = `https://${credentials?.instance}/flow-designer/flow/${parsedIntent.flowName}`;

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

@@ -48,7 +48,8 @@ class ServiceNowMemoryMCP extends base_mcp_server_1.BaseMCPServer {
         const config = {
             name: 'servicenow-memory',
             version: '1.0.0',
-            description: 'Memory and todo management for ServiceNow multi-agent coordination'
+            description: 'Memory and todo management for ServiceNow multi-agent coordination',
+            requiresAuth: false // Memory server doesn't need ServiceNow authentication
         };
         super(config);
         this.config = config;

package/dist/test-iphone-flow.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Test script for iPhone Request Approval Flow
+ * Demonstrates the complete integrated solution with all fixes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testIPhoneRequestApprovalFlow = testIPhoneRequestApprovalFlow;
+const servicenow_client_1 = require("./utils/servicenow-client");
+const flow_structure_builder_1 = require("./utils/flow-structure-builder");
+async function testIPhoneRequestApprovalFlow() {
+    console.log('🧪 Testing iPhone Request Approval Flow Integration');
+    console.log('================================================');
+    try {
+        // Initialize ServiceNow client
+        const client = new servicenow_client_1.ServiceNowClient();
+        // Define the iPhone Request Approval flow
+        const iPhoneFlowDefinition = {
+            name: 'iPhone Request Approval',
+            description: 'Approval workflow for iPhone equipment requests with admin approval and requester notification',
+            table: 'sc_request',
+            trigger: {
+                type: 'record_created',
+                table: 'sc_request',
+                condition: 'request_itemCONTAINSiPhone^ORcatalogue_itemLIKEiPhone'
+            },
+            activities: [
+                {
+                    id: 'approval_admin',
+                    name: 'Admin Approval',
+                    type: 'approval',
+                    inputs: {
+                        approver: 'admin',
+                        approval_question: 'Approve iPhone request for ${trigger.requested_for.name}?',
+                        instructions: 'Please review the iPhone request and approve or reject based on company policy.',
+                        timeout: '7 days'
+                    },
+                    outputs: {
+                        approval_decision: 'string',
+                        approved_by: 'string',
+                        approval_comments: 'string'
+                    }
+                },
+                {
+                    id: 'notify_requester',
+                    name: 'Notify Requester',
+                    type: 'notification',
+                    inputs: {
+                        recipient: '${trigger.requested_for.email}',
+                        subject: 'iPhone Request ${approval_admin.approval_decision}',
+                        message: `Dear ${trigger.requested_for.name},
+
+Your iPhone request has been ${approval_admin.approval_decision}.
+
+Request Details:
+- Item: ${trigger.request_item.short_description}
+- Requested: ${trigger.sys_created_on}
+- Decision by: ${approval_admin.approved_by}
+- Comments: ${approval_admin.approval_comments}
+
+${approval_admin.approval_decision === 'approved' ?
+                            'Your iPhone will be processed and delivered according to standard procedures.' :
+                            'Please contact your manager if you have questions about this decision.'}
+
+Best regards,
+IT Support Team`
+                    },
+                    condition: 'approval_admin.approval_decision != null'
+                }
+            ],
+            variables: [
+                {
+                    name: 'approval_decision',
+                    label: 'Approval Decision',
+                    type: 'string',
+                    required: false,
+                    default: ''
+                },
+                {
+                    name: 'requester_email',
+                    label: 'Requester Email',
+                    type: 'string',
+                    required: true,
+                    default: '${trigger.requested_for.email}'
+                }
+            ],
+            connections: [
+                {
+                    from: 'trigger',
+                    to: 'approval_admin',
+                    condition: ''
+                },
+                {
+                    from: 'approval_admin',
+                    to: 'notify_requester',
+                    condition: 'approval_admin.approval_decision != null'
+                }
+            ],
+            error_handling: []
+        };
+        console.log('✅ Step 1: Flow definition created');
+        console.log(`   - Name: ${iPhoneFlowDefinition.name}`);
+        console.log(`   - Trigger: ${iPhoneFlowDefinition.trigger.type} on ${iPhoneFlowDefinition.trigger.table}`);
+        console.log(`   - Activities: ${iPhoneFlowDefinition.activities.length}`);
+        console.log(`   - Variables: ${iPhoneFlowDefinition.variables.length}`);
+        // Test 1: Create complete flow components using enhanced utilities
+        console.log('\n🔧 Step 2: Creating complete flow components...');
+        const flowComponents = (0, flow_structure_builder_1.createCompleteFlowComponents)(iPhoneFlowDefinition);
+        console.log('✅ Flow components generated:');
+        console.log(`   - Flow Record: ${flowComponents.flowRecord.sys_id}`);
+        console.log(`   - Trigger Instance: ${flowComponents.triggerInstance.sys_id}`);
+        console.log(`   - Action Instances: ${flowComponents.actionInstances.length}`);
+        console.log(`   - Logic Chain: ${flowComponents.logicChain.length}`);
+        console.log(`   - Variables: ${flowComponents.variables.length}`);
+        // Test 2: Generate enhanced XML
+        console.log('\n📄 Step 3: Generating enhanced XML...');
+        const flowXML = (0, flow_structure_builder_1.generateFlowXML)(flowComponents, {
+            includeMetadata: true,
+            validateBeforeExport: true,
+            compactFormat: false
+        });
+        console.log('✅ XML generated successfully');
+        console.log(`   - Size: ${flowXML.length} characters`);
+        console.log(`   - Contains flow record: ${flowXML.includes('<sys_hub_flow>')}`);
+        console.log(`   - Contains trigger: ${flowXML.includes('<sys_hub_trigger_instance>')}`);
+        console.log(`   - Contains actions: ${flowXML.includes('<sys_hub_action_instance>')}`);
+        // Test 3: Deploy to ServiceNow using integrated client
+        console.log('\n🚀 Step 4: Deploying to ServiceNow...');
+        const flowData = {
+            name: iPhoneFlowDefinition.name,
+            description: iPhoneFlowDefinition.description,
+            trigger_type: iPhoneFlowDefinition.trigger.type,
+            table: iPhoneFlowDefinition.trigger.table,
+            condition: iPhoneFlowDefinition.trigger.condition,
+            activities: iPhoneFlowDefinition.activities,
+            variables: iPhoneFlowDefinition.variables
+        };
+        const deploymentResult = await client.createFlow(flowData);
+        if (deploymentResult.success) {
+            console.log('✅ Flow deployed successfully!');
+            console.log(`   - Flow ID: ${deploymentResult.data.sys_id}`);
+            console.log(`   - Flow Name: ${deploymentResult.data.name}`);
+            console.log(`   - Status: ${deploymentResult.data.status || 'published'}`);
+            console.log(`   - Activities Created: ${deploymentResult.data.activities_created || 'N/A'}`);
+            console.log(`   - Flow Designer URL: ${deploymentResult.data.flow_designer_url || 'N/A'}`);
+            // Test 4: Verify deployment
+            console.log('\n🔍 Step 5: Verifying deployment...');
+            const flowContent = await client.checkFlowContent(deploymentResult.data.sys_id);
+            if (flowContent.hasContent) {
+                console.log('✅ Flow verification successful!');
+                console.log(`   - Has Content: ${flowContent.hasContent}`);
+                console.log(`   - Activities Count: ${flowContent.details.activities_count}`);
+                console.log(`   - Has Trigger: ${flowContent.details.has_trigger}`);
+                console.log(`   - Active: ${flowContent.details.active}`);
+            }
+            else {
+                console.log('⚠️  Flow deployed but verification shows no content');
+                console.log(`   - Details: ${flowContent.details}`);
+            }
+        }
+        else {
+            console.error('❌ Flow deployment failed:', deploymentResult.error);
+            return false;
+        }
+        console.log('\n🎉 Integration test completed successfully!');
+        console.log('All components are working together properly:');
+        console.log('✅ Flow structure builder - generates complete components');
+        console.log('✅ Enhanced XML generation - produces valid update sets');
+        console.log('✅ ServiceNow client - creates flow with activities');
+        console.log('✅ Activity creation integration - flow and action instances');
+        console.log('✅ Verification system - confirms deployment success');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Integration test failed:', error);
+        return false;
+    }
+}
+// Run the test if this file is executed directly
+if (require.main === module) {
+    testIPhoneRequestApprovalFlow()
+        .then(success => {
+        process.exit(success ? 0 : 1);
+    })
+        .catch(error => {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    });
+}