snow-flow 1.3.22 → 1.3.24

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

@@ -331,6 +331,7 @@ class ServiceNowFlowComposerMCP {
             console.log('🧠 Generated flow definition:', JSON.stringify(flowDefinition, null, 2));
             // 🧠 STEP 5: Deploy using XML-first approach for maximum reliability
             let deploymentResult = null;
+            let xmlResult = null; // 🔴 FIX: Declare outside try block to avoid scope issues
             if (args.deploy_immediately !== false) {
                 console.log('🚀 DEPLOYING flow using XML-first approach...');
                 try {
@@ -348,21 +349,30 @@ class ServiceNowFlowComposerMCP {
                         accessible_from: 'package_private'
                     };
                     // Generate production-ready XML
-                    const xmlResult = generateProductionFlowXML(xmlFlowDef);
+                    xmlResult = generateProductionFlowXML(xmlFlowDef);
                     console.log('✅ XML generated:', xmlResult.filePath);
-                    // Auto-deploy with fallback strategies
+                    // 🔴 CRITICAL FIX: Auto-deploy with INTEGRATED verification
+                    // SNOW-001: Verification is now MANDATORY within each deployment strategy
                     const deployResult = await this.deployWithFallback(xmlResult.filePath, flowDefinition);
-                    // Verify deployment was successful
-                    const flowExists = await this.verifyFlowInServiceNow(parsedIntent.flowName);
-                    if (!flowExists) {
-                        throw new Error('Flow deployment claimed success but flow not found in ServiceNow');
-                    }
+                    // 🔴 FIXED: No duplicate verification needed - it's integrated into deployment strategies
+                    // deployResult.verification contains the comprehensive verification results
+                    // Success with integrated verification
                     deploymentResult = {
                         success: true,
                         method: deployResult.strategy,
                         xml_file: xmlResult.filePath,
                         message: `✅ Flow deployed via ${deployResult.strategy} and verified in ServiceNow!`,
-                        flow_sys_id: flowExists.sys_id
+                        flow_sys_id: deployResult.verification.sys_id,
+                        flow_url: deployResult.verification.url,
+                        verification_score: deployResult.verification.completeness_score,
+                        verification_details: {
+                            has_flow: true,
+                            has_snapshot: deployResult.verification.has_snapshot,
+                            has_trigger: deployResult.verification.has_trigger,
+                            attempts_needed: deployResult.verification.verification_attempt,
+                            deployment_verified: deployResult.deployment_verified
+                        },
+                        snow_001_fix: 'Deployment includes mandatory verification - no false positives possible'
                     };
                 }
                 catch (xmlError) {
@@ -382,7 +392,7 @@ class ServiceNowFlowComposerMCP {
                     deploymentResult = {
                         success: false,
                         error: errorDetails,
-                        xml_generated: true,
+                        xml_generated: xmlResult !== null, // 🔴 FIX: Check if XML was actually generated
                         xml_path: xmlResult?.filePath,
                         deployment_failed: true,
                         manual_steps: this.generateManualImportGuide(xmlResult?.filePath || ''),
@@ -1987,31 +1997,137 @@ ${categoryFilteredResults.length === 0 ? `🔍 **No templates found matching you
         return mapping[activityType.toLowerCase()] || 'script';
     }
     /**
-     * Verify flow exists in ServiceNow after deployment
+     * Comprehensive flow verification with retry logic
      */
     async verifyFlowInServiceNow(flowName) {
-        try {
-            const ServiceNowClient = (await Promise.resolve().then(() => __importStar(require('../utils/servicenow-client.js')))).ServiceNowClient;
-            const client = new ServiceNowClient();
-            // Check if flow exists in sys_hub_flow
-            const flowCheck = await client.makeRequest({
-                method: 'GET',
-                url: '/api/now/table/sys_hub_flow',
-                params: {
-                    sysparm_query: `name=${flowName}`,
-                    sysparm_limit: 1
+        const maxRetries = 5;
+        const baseDelay = 2000; // Start with 2 seconds
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // Progressive delay - ServiceNow needs time to process
+                if (attempt > 1) {
+                    const delay = baseDelay * attempt; // 2s, 4s, 6s, 8s, 10s
+                    this.logger.info(`Waiting ${delay}ms before verification attempt ${attempt}/${maxRetries}`);
+                    await this.sleep(delay);
+                }
+                const ServiceNowClient = (await Promise.resolve().then(() => __importStar(require('../utils/servicenow-client.js')))).ServiceNowClient;
+                const client = new ServiceNowClient();
+                // Multi-table verification for comprehensive check
+                const verificationPromises = [
+                    // Check main flow table
+                    client.makeRequest({
+                        method: 'GET',
+                        url: '/api/now/table/sys_hub_flow',
+                        params: {
+                            sysparm_query: `name=${flowName}^ORsys_name=${flowName}`,
+                            sysparm_fields: 'sys_id,name,sys_name,active,table,description',
+                            sysparm_limit: 5
+                        }
+                    }),
+                    // Check flow snapshots
+                    client.makeRequest({
+                        method: 'GET',
+                        url: '/api/now/table/sys_hub_flow_snapshot',
+                        params: {
+                            sysparm_query: `flow.name=${flowName}^ORflow.sys_name=${flowName}`,
+                            sysparm_fields: 'sys_id,flow,name,active',
+                            sysparm_limit: 5
+                        }
+                    }),
+                    // Check trigger instances
+                    client.makeRequest({
+                        method: 'GET',
+                        url: '/api/now/table/sys_hub_trigger_instance',
+                        params: {
+                            sysparm_query: `flow.name=${flowName}^ORflow.sys_name=${flowName}`,
+                            sysparm_fields: 'sys_id,flow,trigger_type',
+                            sysparm_limit: 5
+                        }
+                    })
+                ];
+                const [flowCheck, snapshotCheck, triggerCheck] = await Promise.allSettled(verificationPromises);
+                // Analyze results
+                const flowExists = flowCheck.status === 'fulfilled' &&
+                    flowCheck.value.result &&
+                    flowCheck.value.result.length > 0;
+                const snapshotExists = snapshotCheck.status === 'fulfilled' &&
+                    snapshotCheck.value.result &&
+                    snapshotCheck.value.result.length > 0;
+                const triggerExists = triggerCheck.status === 'fulfilled' &&
+                    triggerCheck.value.result &&
+                    triggerCheck.value.result.length > 0;
+                // Comprehensive verification result
+                if (flowExists) {
+                    const flowData = flowCheck.value.result[0];
+                    return {
+                        verified: true,
+                        sys_id: flowData.sys_id,
+                        name: flowData.name || flowData.sys_name,
+                        active: flowData.active,
+                        table: flowData.table,
+                        has_snapshot: snapshotExists,
+                        has_trigger: triggerExists,
+                        verification_attempt: attempt,
+                        verification_method: 'multi_table_comprehensive',
+                        completeness_score: (flowExists ? 1 : 0) + (snapshotExists ? 1 : 0) + (triggerExists ? 1 : 0),
+                        url: `https://${await this.getInstanceUrl()}/flow-designer/flow/${flowData.sys_id}`
+                    };
+                }
+                // Log partial results for debugging
+                this.logger.warn(`Verification attempt ${attempt}: Flow=${flowExists}, Snapshot=${snapshotExists}, Trigger=${triggerExists}`);
+                // If this is the last attempt, return detailed failure info
+                if (attempt === maxRetries) {
+                    return {
+                        verified: false,
+                        reason: 'Flow not found after comprehensive verification',
+                        attempts: maxRetries,
+                        partial_results: {
+                            flow_found: flowExists,
+                            snapshot_found: snapshotExists,
+                            trigger_found: triggerExists
+                        },
+                        search_query: `name=${flowName}`,
+                        recommendation: 'Check ServiceNow Flow Designer manually or verify deployment was successful'
+                    };
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Verification attempt ${attempt} failed:`, error);
+                // If this is the last attempt, include error details
+                if (attempt === maxRetries) {
+                    return {
+                        verified: false,
+                        reason: 'Verification failed due to error',
+                        error: error instanceof Error ? error.message : String(error),
+                        attempts: maxRetries
+                    };
                 }
-            });
-            if (flowCheck.result && flowCheck.result.length > 0) {
-                return flowCheck.result[0];
             }
-            return null;
         }
-        catch (error) {
-            this.logger.error('Failed to verify flow:', error);
-            return null;
+        return {
+            verified: false,
+            reason: 'Max verification attempts exceeded',
+            attempts: maxRetries
+        };
+    }
+    /**
+     * Helper to get instance URL for flow links
+     */
+    async getInstanceUrl() {
+        try {
+            const credentials = await this.oauth.loadCredentials();
+            return credentials?.instance || 'your-instance.service-now.com';
+        }
+        catch {
+            return 'your-instance.service-now.com';
         }
     }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
     /**
      * Generate manual import guide for failed deployments
      */
@@ -2039,17 +2155,19 @@ ${categoryFilteredResults.length === 0 ? `🔍 **No templates found matching you
    - Check "My Flows" for your new flow`;
     }
     /**
-     * Deploy with fallback strategies
+     * Deploy with fallback strategies + MANDATORY VERIFICATION
+     * 🔴 CRITICAL FIX: SNOW-001 Silent Deployment Failures
+     * Each strategy now MUST verify that the flow actually exists before claiming success
      */
     async deployWithFallback(xmlFilePath, flowDefinition) {
         const strategies = [
             {
                 name: 'XML Remote Update Set',
-                fn: async () => await this.deployXMLToServiceNow(xmlFilePath)
+                fn: async () => await this.deployXMLToServiceNowWithVerification(xmlFilePath, flowDefinition.name)
             },
             {
                 name: 'Direct Table API',
-                fn: async () => await this.deployViaTableAPI(flowDefinition)
+                fn: async () => await this.deployViaTableAPIWithVerification(flowDefinition)
             }
         ];
         let lastError;
@@ -2057,7 +2175,17 @@ ${categoryFilteredResults.length === 0 ? `🔍 **No templates found matching you
             try {
                 this.logger.info(`Trying deployment strategy: ${strategy.name}`);
                 const result = await strategy.fn();
-                return { success: true, strategy: strategy.name, result };
+                // 🔴 CRITICAL: Strategy can only return if it includes verification proof
+                if (!result.verification || !result.verification.verified) {
+                    throw new Error(`${strategy.name} completed but verification failed: ${result.verification?.reason || 'Unknown verification failure'}`);
+                }
+                return {
+                    success: true,
+                    strategy: strategy.name,
+                    result,
+                    verification: result.verification,
+                    deployment_verified: true
+                };
             }
             catch (error) {
                 this.logger.warn(`Strategy ${strategy.name} failed:`, error);
@@ -2067,7 +2195,65 @@ ${categoryFilteredResults.length === 0 ? `🔍 **No templates found matching you
         throw lastError || new Error('All deployment strategies failed');
     }
     /**
-     * Deploy via direct table API
+     * 🔴 CRITICAL FIX: Deploy XML with MANDATORY verification
+     * SNOW-001: Prevents false positive where XML import succeeds but flow doesn't exist
+     */
+    async deployXMLToServiceNowWithVerification(xmlFilePath, flowName) {
+        this.logger.info(`🔴 CRITICAL FIX: XML deployment with mandatory verification for: ${flowName}`);
+        // Step 1: Deploy the XML (existing logic)
+        await this.deployXMLToServiceNow(xmlFilePath);
+        // Step 2: MANDATORY verification - wait for ServiceNow to process
+        this.logger.info('🔍 Starting mandatory post-deployment verification...');
+        const verification = await this.verifyFlowInServiceNow(flowName);
+        if (!verification.verified) {
+            // 🔴 CRITICAL: XML deployment succeeded but flow doesn't exist
+            const errorMsg = `🔴 CRITICAL: XML deployment appeared to succeed but flow verification failed: ${verification.reason}`;
+            this.logger.error('SNOW-001 detected: Silent deployment failure', {
+                xmlFilePath,
+                flowName,
+                verificationResult: verification,
+                issue: 'XML import/commit succeeded but no flow created'
+            });
+            throw new Error(errorMsg);
+        }
+        this.logger.info(`✅ XML deployment verified successfully: ${flowName} found with sys_id ${verification.sys_id}`);
+        return {
+            deployment_method: 'XML Remote Update Set',
+            xml_file: xmlFilePath,
+            verification: verification,
+            success_message: `XML deployment completed and verified: Flow ${flowName} is live in ServiceNow`
+        };
+    }
+    /**
+     * 🔴 CRITICAL FIX: Deploy via Table API with MANDATORY verification
+     * SNOW-001: Prevents false positive where API call succeeds but flow doesn't exist
+     */
+    async deployViaTableAPIWithVerification(flowDefinition) {
+        this.logger.info(`🔴 CRITICAL FIX: Table API deployment with mandatory verification for: ${flowDefinition.name}`);
+        // Step 1: Deploy via Table API (existing logic)
+        await this.deployViaTableAPI(flowDefinition);
+        // Step 2: MANDATORY verification
+        this.logger.info('🔍 Starting mandatory post-deployment verification...');
+        const verification = await this.verifyFlowInServiceNow(flowDefinition.name);
+        if (!verification.verified) {
+            // 🔴 CRITICAL: Table API deployment succeeded but flow doesn't exist
+            const errorMsg = `🔴 CRITICAL: Table API deployment appeared to succeed but flow verification failed: ${verification.reason}`;
+            this.logger.error('SNOW-001 detected: Silent deployment failure', {
+                flowName: flowDefinition.name,
+                verificationResult: verification,
+                issue: 'Table API call succeeded but no flow created'
+            });
+            throw new Error(errorMsg);
+        }
+        this.logger.info(`✅ Table API deployment verified successfully: ${flowDefinition.name} found with sys_id ${verification.sys_id}`);
+        return {
+            deployment_method: 'Direct Table API',
+            verification: verification,
+            success_message: `Table API deployment completed and verified: Flow ${flowDefinition.name} is live in ServiceNow`
+        };
+    }
+    /**
+     * Deploy via direct table API (LEGACY METHOD - used by new verified method)
      */
     async deployViaTableAPI(flowDefinition) {
         const ServiceNowClient = (await Promise.resolve().then(() => __importStar(require('../utils/servicenow-client.js')))).ServiceNowClient;