snow-flow 1.4.37 → 1.4.39

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

@@ -521,137 +521,6 @@ class ServiceNowOperationsMCP {
                             required: ['query']
                         }
                     },
-                    {
-                        name: 'snow_test_flow_with_mock',
-                        description: 'Test flows with mock data - create test users, mock catalog items, and simulate flow execution',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                flow_id: {
-                                    type: 'string',
-                                    description: 'Flow sys_id or name to test'
-                                },
-                                create_test_user: {
-                                    type: 'boolean',
-                                    description: 'Create a test user for the flow',
-                                    default: true
-                                },
-                                test_user_data: {
-                                    type: 'object',
-                                    description: 'Test user details',
-                                    properties: {
-                                        user_name: { type: 'string' },
-                                        first_name: { type: 'string' },
-                                        last_name: { type: 'string' },
-                                        email: { type: 'string' },
-                                        department: { type: 'string' },
-                                        manager: { type: 'string' }
-                                    }
-                                },
-                                mock_catalog_items: {
-                                    type: 'boolean',
-                                    description: 'Create mock catalog items for testing',
-                                    default: true
-                                },
-                                mock_catalog_data: {
-                                    type: 'array',
-                                    description: 'Mock catalog items to create',
-                                    items: {
-                                        type: 'object',
-                                        properties: {
-                                            name: { type: 'string' },
-                                            short_description: { type: 'string' },
-                                            price: { type: 'string' },
-                                            variables: { type: 'array' }
-                                        }
-                                    }
-                                },
-                                test_inputs: {
-                                    type: 'object',
-                                    description: 'Input values to test the flow with'
-                                },
-                                simulate_approvals: {
-                                    type: 'boolean',
-                                    description: 'Automatically approve any approval requests',
-                                    default: true
-                                },
-                                cleanup_after_test: {
-                                    type: 'boolean',
-                                    description: 'Remove test data after testing',
-                                    default: true
-                                }
-                            },
-                            required: ['flow_id']
-                        }
-                    },
-                    {
-                        name: 'snow_link_catalog_to_flow',
-                        description: 'Link catalog items directly to flows - configure flow as fulfillment process',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                catalog_item_id: {
-                                    type: 'string',
-                                    description: 'Catalog item sys_id or name'
-                                },
-                                flow_id: {
-                                    type: 'string',
-                                    description: 'Flow sys_id or name to use for fulfillment'
-                                },
-                                link_type: {
-                                    type: 'string',
-                                    description: 'Type of link to create',
-                                    enum: ['workflow', 'flow_catalog_process', 'process_engine'],
-                                    default: 'flow_catalog_process'
-                                },
-                                variable_mapping: {
-                                    type: 'array',
-                                    description: 'Map catalog variables to flow inputs',
-                                    items: {
-                                        type: 'object',
-                                        properties: {
-                                            catalog_variable: { type: 'string', description: 'Catalog variable name' },
-                                            flow_input: { type: 'string', description: 'Flow input name' },
-                                            transform: { type: 'string', description: 'Optional transformation script' }
-                                        }
-                                    }
-                                },
-                                trigger_condition: {
-                                    type: 'string',
-                                    description: 'Condition for when to trigger the flow',
-                                    default: 'current.stage == "request_approved"'
-                                },
-                                execution_options: {
-                                    type: 'object',
-                                    description: 'Flow execution options',
-                                    properties: {
-                                        run_as: {
-                                            type: 'string',
-                                            description: 'User context for flow execution',
-                                            enum: ['requester', 'system', 'fulfiller'],
-                                            default: 'system'
-                                        },
-                                        wait_for_completion: {
-                                            type: 'boolean',
-                                            description: 'Wait for flow to complete before closing request',
-                                            default: true
-                                        },
-                                        update_request_on_progress: {
-                                            type: 'boolean',
-                                            description: 'Update request item with flow progress',
-                                            default: true
-                                        }
-                                    }
-                                },
-                                test_link: {
-                                    type: 'boolean',
-                                    description: 'Test the link by creating a sample request',
-                                    default: false
-                                }
-                            },
-                            required: ['catalog_item_id', 'flow_id']
-                        }
-                    },
                     {
                         name: 'snow_cleanup_test_artifacts',
                         description: 'Clean up test artifacts while preserving Update Set audit trail',
@@ -880,10 +749,6 @@ class ServiceNowOperationsMCP {
                         return await this.handleCatalogItemManager(args);
                     case 'snow_catalog_item_search':
                         return await this.handleCatalogItemSearch(args);
-                    case 'snow_test_flow_with_mock':
-                        return await this.handleTestFlowWithMock(args);
-                    case 'snow_link_catalog_to_flow':
-                        return await this.handleLinkCatalogToFlow(args);
                     case 'snow_cleanup_test_artifacts':
                         return await this.handleCleanupTestArtifacts(args);
                     case 'snow_create_user_group':
@@ -2414,602 +2279,6 @@ class ServiceNowOperationsMCP {
         }
         return false;
     }
-    async handleTestFlowWithMock(args) {
-        const { flow_id, create_test_user = true, test_user_data, mock_catalog_items = true, mock_catalog_data, test_inputs = {}, simulate_approvals = true, cleanup_after_test = true } = args;
-        logger_js_1.logger.info(`Testing flow ${flow_id} with mock data`, {
-            create_test_user,
-            mock_catalog_items,
-            simulate_approvals,
-            cleanup_after_test
-        });
-        const testResults = {
-            flow_id,
-            test_run_id: `test_${Date.now()}`,
-            created_data: {
-                test_user: null,
-                catalog_items: [],
-                test_requests: []
-            },
-            execution_results: {
-                status: 'pending',
-                start_time: new Date().toISOString(),
-                end_time: null,
-                duration_ms: 0,
-                execution_id: null,
-                steps_executed: [],
-                errors: [],
-                approvals_simulated: []
-            },
-            cleanup_status: null
-        };
-        try {
-            // Step 1: Find the flow with intelligent fallback search
-            let flowResult = await this.client.searchRecords('sys_hub_flow', `sys_id=${flow_id}^ORname=${flow_id}`, 1);
-            // If not found, try different search strategies
-            if (!flowResult.success || !flowResult.data?.result?.length) {
-                logger_js_1.logger.info('Flow not found with exact match, trying fuzzy search...');
-                // Try partial name matching
-                flowResult = await this.client.searchRecords('sys_hub_flow', `nameCONTAINS${flow_id}`, 5);
-                if (!flowResult.success || !flowResult.data?.result?.length) {
-                    // Try searching in Business Rules as fallback
-                    logger_js_1.logger.info('No flows found, searching for Business Rules as fallback...');
-                    const businessRuleResult = await this.client.searchRecords('sys_script', `nameCONTAINS${flow_id}^ORshort_descriptionCONTAINS${flow_id}`, 5);
-                    if (businessRuleResult.success && businessRuleResult.data?.result?.length) {
-                        testResults.execution_results.status = 'fallback_business_rule';
-                        testResults.execution_results.errors.push(`Flow '${flow_id}' not found, but found ${businessRuleResult.data.result.length} related Business Rules. Consider testing the Business Rule directly.`);
-                        const businessRules = businessRuleResult.data.result.map((br) => ({
-                            name: br.name,
-                            sys_id: br.sys_id,
-                            table: br.collection,
-                            when: br.when
-                        }));
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: `⚠️ **Flow Test - Intelligent Fallback**\n\nFlow '${flow_id}' not found, but discovered related Business Rules:\n\n${businessRules.map((br, i) => `${i + 1}. **${br.name}**\n   - Sys ID: ${br.sys_id}\n   - Table: ${br.table}\n   - Trigger: ${br.when}\n`).join('\n')}\n\n💡 **Recommendation:** Test the Business Rule directly as it may provide the same functionality as the intended flow.\n\n🔧 **Next Steps:**\n1. Verify the Business Rule logic matches your flow requirements\n2. Test by creating a record on the ${businessRules[0]?.table || 'target'} table\n3. Monitor System Logs for Business Rule execution`
-                                }]
-                        };
-                    }
-                    throw new Error(`Flow not found: ${flow_id}. Tried exact match, partial name match, and Business Rule fallback.`);
-                }
-                else {
-                    // Found partial matches, ask user to clarify
-                    const matches = flowResult.data.result.map((f) => ({
-                        name: f.name,
-                        sys_id: f.sys_id,
-                        active: f.active
-                    }));
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `🔍 **Multiple Flow Matches Found**\n\nThe flow identifier '${flow_id}' matched multiple flows:\n\n${matches.map((f, i) => `${i + 1}. **${f.name}** (${f.active ? 'Active' : 'Inactive'})\n   - Sys ID: ${f.sys_id}\n`).join('\n')}\n\n💡 **Please specify the exact flow sys_id or unique name to continue testing.**`
-                            }]
-                    };
-                }
-            }
-            const flow = flowResult.data.result[0];
-            testResults.flow_id = flow.sys_id;
-            // Step 2: Create test user if requested
-            if (create_test_user) {
-                const userData = test_user_data || {
-                    user_name: `test_user_${Date.now()}`,
-                    first_name: 'Test',
-                    last_name: 'User',
-                    email: `test_${Date.now()}@example.com`,
-                    department: 'IT',
-                    active: true
-                };
-                const userResult = await this.client.createRecord('sys_user', userData);
-                if (userResult.success && userResult.data?.result) {
-                    testResults.created_data.test_user = {
-                        sys_id: userResult.data.result.sys_id,
-                        user_name: userData.user_name,
-                        email: userData.email
-                    };
-                    logger_js_1.logger.info('Created test user:', testResults.created_data.test_user);
-                }
-            }
-            // Step 3: Create mock catalog items if requested
-            if (mock_catalog_items) {
-                const catalogData = mock_catalog_data || [
-                    {
-                        name: 'Test iPhone 6S',
-                        short_description: 'Test mobile device for flow testing',
-                        price: '699.00',
-                        active: true,
-                        billable: true
-                    },
-                    {
-                        name: 'Test Laptop',
-                        short_description: 'Test laptop for equipment provisioning',
-                        price: '1299.00',
-                        active: true,
-                        billable: true
-                    }
-                ];
-                for (const item of catalogData) {
-                    const catalogResult = await this.client.createRecord('sc_cat_item', item);
-                    if (catalogResult.success && catalogResult.data?.result) {
-                        testResults.created_data.catalog_items.push({
-                            sys_id: catalogResult.data.result.sys_id,
-                            name: item.name,
-                            price: item.price
-                        });
-                        logger_js_1.logger.info('Created mock catalog item:', item.name);
-                    }
-                }
-            }
-            // Step 4: Execute the flow with test data
-            try {
-                // Prepare test inputs
-                const flowInputs = {
-                    ...test_inputs,
-                    test_mode: true,
-                    test_run_id: testResults.test_run_id
-                };
-                // If we created a test user, use them as the requested_for
-                if (testResults.created_data.test_user) {
-                    flowInputs.requested_for = testResults.created_data.test_user.sys_id;
-                    flowInputs.opened_by = testResults.created_data.test_user.sys_id;
-                }
-                // If we created catalog items, use the first one
-                if (testResults.created_data.catalog_items.length > 0) {
-                    flowInputs.cat_item = testResults.created_data.catalog_items[0].sys_id;
-                }
-                // Execute flow via REST API
-                const executeResult = await this.executeFlowViaAPI(flow.sys_id, flowInputs);
-                if (executeResult.success) {
-                    testResults.execution_results.status = 'running';
-                    testResults.execution_results.execution_id = executeResult.execution_id;
-                    // Monitor flow execution
-                    const executionStatus = await this.monitorFlowExecution(executeResult.execution_id, simulate_approvals);
-                    testResults.execution_results = {
-                        ...testResults.execution_results,
-                        ...executionStatus
-                    };
-                }
-                else {
-                    testResults.execution_results.status = 'failed';
-                    testResults.execution_results.errors.push(executeResult.error || 'Unknown execution error');
-                }
-            }
-            catch (execError) {
-                testResults.execution_results.status = 'error';
-                testResults.execution_results.errors.push(execError.message);
-                logger_js_1.logger.error('Flow execution error:', execError);
-            }
-            // Step 5: Cleanup if requested
-            if (cleanup_after_test) {
-                const cleanupResults = {
-                    user_deleted: false,
-                    catalog_items_deleted: 0,
-                    requests_cancelled: 0
-                };
-                // Delete test user
-                if (testResults.created_data.test_user) {
-                    const deleteUserResult = await this.client.deleteRecord('sys_user', testResults.created_data.test_user.sys_id);
-                    cleanupResults.user_deleted = deleteUserResult.success;
-                }
-                // Delete catalog items
-                for (const item of testResults.created_data.catalog_items) {
-                    const deleteItemResult = await this.client.deleteRecord('sc_cat_item', item.sys_id);
-                    if (deleteItemResult.success) {
-                        cleanupResults.catalog_items_deleted++;
-                    }
-                }
-                testResults.cleanup_status = cleanupResults;
-            }
-            // Format results
-            const resultText = this.formatTestResults(testResults);
-            return {
-                content: [{
-                        type: 'text',
-                        text: resultText
-                    }]
-            };
-        }
-        catch (error) {
-            logger_js_1.logger.error('Error testing flow with mock data:', error);
-            testResults.execution_results.status = 'error';
-            testResults.execution_results.errors.push(error.message);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `❌ Flow test failed
-
-🚨 Error: ${error.message}
-
-🔧 Troubleshooting Steps:
-1. Check authentication: snow_auth_diagnostics()
-2. Verify flow exists: snow_get_by_sysid("${flow_id}")
-3. Check Update Set: snow_update_set_current()
-4. Try alternative: snow_test_flow_with_mock() (always works)
-
-💡 Alternative Tools:
-• For reliable testing: snow_test_flow_with_mock()
-• For verification: snow_get_by_sysid()
-• For comprehensive testing: snow_comprehensive_flow_test()
-
-📋 Test Results:
-${JSON.stringify(testResults, null, 2)}
-
-📚 Documentation: See CLAUDE.md for Flow Testing Guidelines`
-                    }]
-            };
-        }
-    }
-    async executeFlowViaAPI(flowId, inputs) {
-        try {
-            // Use the ServiceNow Flow API to execute the flow
-            const result = await this.client.createRecord('sys_flow_context', {
-                flow: flowId,
-                inputs: JSON.stringify(inputs),
-                state: 'executing'
-            });
-            if (result.success && result.data?.result) {
-                return {
-                    success: true,
-                    execution_id: result.data.result.sys_id
-                };
-            }
-            return {
-                success: false,
-                error: 'Failed to start flow execution'
-            };
-        }
-        catch (error) {
-            logger_js_1.logger.error('Error executing flow via API:', error);
-            return {
-                success: false,
-                error: error.message
-            };
-        }
-    }
-    async monitorFlowExecution(executionId, simulateApprovals) {
-        const maxWaitTime = 60000; // 60 seconds
-        const pollInterval = 2000; // 2 seconds
-        const startTime = Date.now();
-        const executionResults = {
-            status: 'running',
-            steps_executed: [],
-            approvals_simulated: [],
-            errors: [],
-            end_time: null,
-            duration_ms: 0
-        };
-        while (Date.now() - startTime < maxWaitTime) {
-            try {
-                // Check flow context status
-                const contextResult = await this.client.getRecord('sys_flow_context', executionId);
-                if (!contextResult.success || !contextResult.data?.result) {
-                    executionResults.errors.push('Failed to get flow context');
-                    break;
-                }
-                const context = contextResult.data.result;
-                executionResults.status = context.state;
-                // Check for completed state
-                if (context.state === 'complete' || context.state === 'cancelled' || context.state === 'error') {
-                    executionResults.end_time = context.sys_updated_on;
-                    executionResults.duration_ms = Date.now() - startTime;
-                    break;
-                }
-                // Check for approvals if simulating
-                if (simulateApprovals) {
-                    const approvalResult = await this.client.searchRecords('sysapproval_approver', `source_table=sys_flow_context^document_id=${executionId}^state=requested`, 10);
-                    if (approvalResult.success && approvalResult.data?.result?.length > 0) {
-                        for (const approval of approvalResult.data.result) {
-                            // Auto-approve
-                            const approveResult = await this.client.updateRecord('sysapproval_approver', approval.sys_id, {
-                                state: 'approved',
-                                comments: 'Auto-approved by test framework'
-                            });
-                            if (approveResult.success) {
-                                executionResults.approvals_simulated.push({
-                                    sys_id: approval.sys_id,
-                                    approver: approval.approver.display_value,
-                                    approved_at: new Date().toISOString()
-                                });
-                            }
-                        }
-                    }
-                }
-                // Wait before next poll
-                await new Promise(resolve => setTimeout(resolve, pollInterval));
-            }
-            catch (error) {
-                executionResults.errors.push(error.message);
-                executionResults.status = 'error';
-                break;
-            }
-        }
-        if (executionResults.status === 'running') {
-            executionResults.status = 'timeout';
-            executionResults.errors.push('Flow execution timed out after 60 seconds');
-        }
-        return executionResults;
-    }
-    formatTestResults(testResults) {
-        let text = `🧪 Flow Test Results\n${'='.repeat(50)}\n\n`;
-        text += `**Flow ID:** ${testResults.flow_id}\n`;
-        text += `**Test Run ID:** ${testResults.test_run_id}\n\n`;
-        // Test Data Created
-        text += `📋 **Test Data Created:**\n`;
-        if (testResults.created_data.test_user) {
-            text += `  ✅ Test User: ${testResults.created_data.test_user.user_name} (${testResults.created_data.test_user.sys_id})\n`;
-        }
-        if (testResults.created_data.catalog_items.length > 0) {
-            text += `  ✅ Catalog Items: ${testResults.created_data.catalog_items.length} created\n`;
-            testResults.created_data.catalog_items.forEach((item) => {
-                text += `     - ${item.name} ($${item.price})\n`;
-            });
-        }
-        // Execution Results
-        text += `\n🚀 **Execution Results:**\n`;
-        text += `  Status: ${testResults.execution_results.status === 'complete' ? '✅' : '❌'} ${testResults.execution_results.status}\n`;
-        if (testResults.execution_results.start_time) {
-            text += `  Start Time: ${testResults.execution_results.start_time}\n`;
-        }
-        if (testResults.execution_results.end_time) {
-            text += `  End Time: ${testResults.execution_results.end_time}\n`;
-        }
-        if (testResults.execution_results.duration_ms) {
-            text += `  Duration: ${(testResults.execution_results.duration_ms / 1000).toFixed(2)}s\n`;
-        }
-        if (testResults.execution_results.approvals_simulated.length > 0) {
-            text += `\n  ✅ Approvals Simulated: ${testResults.execution_results.approvals_simulated.length}\n`;
-            testResults.execution_results.approvals_simulated.forEach((approval) => {
-                text += `     - ${approval.approver} at ${approval.approved_at}\n`;
-            });
-        }
-        if (testResults.execution_results.errors.length > 0) {
-            text += `\n  ❌ Errors:\n`;
-            testResults.execution_results.errors.forEach((error) => {
-                text += `     - ${error}\n`;
-            });
-        }
-        // Cleanup Status
-        if (testResults.cleanup_status) {
-            text += `\n🧹 **Cleanup Status:**\n`;
-            text += `  User Deleted: ${testResults.cleanup_status.user_deleted ? '✅' : '❌'}\n`;
-            text += `  Catalog Items Deleted: ${testResults.cleanup_status.catalog_items_deleted}\n`;
-            text += `  Requests Cancelled: ${testResults.cleanup_status.requests_cancelled}\n`;
-        }
-        // Recommendations
-        text += `\n💡 **Recommendations:**\n`;
-        if (testResults.execution_results.status === 'complete') {
-            text += `  ✅ Flow executed successfully! Ready for production use.\n`;
-        }
-        else if (testResults.execution_results.status === 'timeout') {
-            text += `  ⚠️ Flow execution timed out. Consider:\n`;
-            text += `     - Checking for infinite loops\n`;
-            text += `     - Reviewing wait conditions\n`;
-            text += `     - Optimizing flow performance\n`;
-        }
-        else {
-            text += `  ❌ Flow execution failed. Please:\n`;
-            text += `     - Review error messages above\n`;
-            text += `     - Check flow configuration\n`;
-            text += `     - Verify all dependencies exist\n`;
-        }
-        return text;
-    }
-    async handleLinkCatalogToFlow(args) {
-        const { catalog_item_id, flow_id, link_type = 'flow_catalog_process', variable_mapping = [], trigger_condition = 'current.stage == "request_approved"', execution_options = {}, test_link = false } = args;
-        logger_js_1.logger.info(`Linking catalog item ${catalog_item_id} to flow ${flow_id}`, {
-            link_type,
-            variable_mapping_count: variable_mapping.length
-        });
-        const linkResults = {
-            catalog_item: null,
-            flow: null,
-            link_created: false,
-            link_details: null,
-            variable_mappings: [],
-            test_results: null,
-            errors: []
-        };
-        try {
-            // Step 1: Find the catalog item
-            const catalogResult = await this.client.searchRecords('sc_cat_item', `sys_id=${catalog_item_id}^ORname=${catalog_item_id}`, 1);
-            if (!catalogResult.success || !catalogResult.data?.result?.length) {
-                throw new Error(`Catalog item not found: ${catalog_item_id}`);
-            }
-            linkResults.catalog_item = {
-                sys_id: catalogResult.data.result[0].sys_id,
-                name: catalogResult.data.result[0].name,
-                category: catalogResult.data.result[0].sc_categories?.display_value
-            };
-            // Step 2: Find the flow
-            const flowResult = await this.client.searchRecords('sys_hub_flow', `sys_id=${flow_id}^ORname=${flow_id}`, 1);
-            if (!flowResult.success || !flowResult.data?.result?.length) {
-                throw new Error(`Flow not found: ${flow_id}`);
-            }
-            linkResults.flow = {
-                sys_id: flowResult.data.result[0].sys_id,
-                name: flowResult.data.result[0].name,
-                type: flowResult.data.result[0].type
-            };
-            // Step 3: Create the link based on link_type
-            switch (link_type) {
-                case 'flow_catalog_process': {
-                    // Modern approach: Use Flow Designer catalog process
-                    const processData = {
-                        catalog_item: linkResults.catalog_item.sys_id,
-                        flow: linkResults.flow.sys_id,
-                        active: true,
-                        condition: trigger_condition,
-                        run_as: execution_options.run_as || 'user', // 🔒 SEC-001 FIX: Default to 'user' to prevent privilege escalation
-                        wait_for_completion: execution_options.wait_for_completion !== false
-                    };
-                    const processResult = await this.client.createRecord('sc_cat_item_producer', processData);
-                    if (processResult.success && processResult.data?.result) {
-                        linkResults.link_created = true;
-                        linkResults.link_details = {
-                            type: 'flow_catalog_process',
-                            sys_id: processResult.data.result.sys_id,
-                            table: 'sc_cat_item_producer'
-                        };
-                        // Create variable mappings
-                        for (const mapping of variable_mapping) {
-                            const mappingData = {
-                                producer: processResult.data.result.sys_id,
-                                catalog_variable: mapping.catalog_variable,
-                                flow_input: mapping.flow_input,
-                                transform_script: mapping.transform || ''
-                            };
-                            const mappingResult = await this.client.createRecord('sc_cat_item_producer_mapping', mappingData);
-                            if (mappingResult.success) {
-                                linkResults.variable_mappings.push({
-                                    catalog_variable: mapping.catalog_variable,
-                                    flow_input: mapping.flow_input,
-                                    mapping_sys_id: mappingResult.data?.result?.sys_id
-                                });
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'workflow': {
-                    // Legacy approach: Direct workflow assignment
-                    const updateData = {
-                        workflow: linkResults.flow.sys_id,
-                        no_order: false,
-                        no_proceed_checkout: false,
-                        no_quantity: false,
-                        no_delivery_time: false
-                    };
-                    const updateResult = await this.client.updateRecord('sc_cat_item', linkResults.catalog_item.sys_id, updateData);
-                    if (updateResult.success) {
-                        linkResults.link_created = true;
-                        linkResults.link_details = {
-                            type: 'workflow',
-                            field: 'workflow',
-                            value: linkResults.flow.sys_id
-                        };
-                    }
-                    break;
-                }
-                case 'process_engine': {
-                    // Process Engine approach
-                    const engineData = {
-                        catalog_item: linkResults.catalog_item.sys_id,
-                        engine_type: 'flow',
-                        engine_id: linkResults.flow.sys_id,
-                        active: true,
-                        order: 100,
-                        condition: trigger_condition
-                    };
-                    const engineResult = await this.client.createRecord('sc_process_flow', engineData);
-                    if (engineResult.success && engineResult.data?.result) {
-                        linkResults.link_created = true;
-                        linkResults.link_details = {
-                            type: 'process_engine',
-                            sys_id: engineResult.data.result.sys_id,
-                            table: 'sc_process_flow'
-                        };
-                    }
-                    break;
-                }
-            }
-            // Step 4: Test the link if requested
-            if (test_link && linkResults.link_created) {
-                logger_js_1.logger.info('Testing catalog-flow link with sample request');
-                const testRequestData = {
-                    cat_item: linkResults.catalog_item.sys_id,
-                    requested_for: 'admin', // Default to admin user
-                    quantity: 1,
-                    comments: `Test request for catalog-flow link verification [${new Date().toISOString()}]`
-                };
-                // Add any mapped variables with test values
-                for (const mapping of linkResults.variable_mappings) {
-                    testRequestData[`variables.${mapping.catalog_variable}`] = 'Test Value';
-                }
-                const testResult = await this.client.createRecord('sc_request', testRequestData);
-                if (testResult.success && testResult.data?.result) {
-                    linkResults.test_results = {
-                        request_created: true,
-                        request_number: testResult.data.result.number,
-                        request_sys_id: testResult.data.result.sys_id,
-                        status: 'Check the request in ServiceNow to verify flow execution'
-                    };
-                }
-                else {
-                    linkResults.test_results = {
-                        request_created: false,
-                        error: 'Failed to create test request'
-                    };
-                }
-            }
-            // Format results
-            let resultText = `🔗 Catalog-Flow Link Results\n${'='.repeat(50)}\n\n`;
-            resultText += `**Catalog Item:** ${linkResults.catalog_item.name} (${linkResults.catalog_item.sys_id})\n`;
-            resultText += `**Flow:** ${linkResults.flow.name} (${linkResults.flow.sys_id})\n`;
-            resultText += `**Link Type:** ${link_type}\n\n`;
-            if (linkResults.link_created) {
-                resultText += `✅ **Link Created Successfully!**\n`;
-                resultText += `   Type: ${linkResults.link_details.type}\n`;
-                if (linkResults.link_details.sys_id) {
-                    resultText += `   Record: ${linkResults.link_details.table} (${linkResults.link_details.sys_id})\n`;
-                }
-                if (linkResults.variable_mappings.length > 0) {
-                    resultText += `\n📋 **Variable Mappings Created:**\n`;
-                    linkResults.variable_mappings.forEach(mapping => {
-                        resultText += `   - ${mapping.catalog_variable} → ${mapping.flow_input}\n`;
-                    });
-                }
-                if (linkResults.test_results) {
-                    resultText += `\n🧪 **Test Results:**\n`;
-                    if (linkResults.test_results.request_created) {
-                        resultText += `   ✅ Test request created: ${linkResults.test_results.request_number}\n`;
-                        resultText += `   📍 ${linkResults.test_results.status}\n`;
-                    }
-                    else {
-                        resultText += `   ❌ ${linkResults.test_results.error}\n`;
-                    }
-                }
-                resultText += `\n💡 **Next Steps:**\n`;
-                resultText += `1. Test the catalog item by creating a request\n`;
-                resultText += `2. Verify the flow executes with correct inputs\n`;
-                resultText += `3. Monitor the request fulfillment process\n`;
-                if (link_type === 'flow_catalog_process') {
-                    resultText += `\n📝 **Note:** Using modern Flow Designer catalog process\n`;
-                    resultText += `   - Flow will trigger on: ${trigger_condition}\n`;
-                    resultText += `   - Execution context: ${execution_options.run_as || 'user'}\n`; // 🔒 SEC-001 FIX: Default to 'user' to prevent privilege escalation
-                }
-            }
-            else {
-                resultText += `❌ **Failed to create link**\n`;
-                if (linkResults.errors.length > 0) {
-                    resultText += `\nErrors:\n`;
-                    linkResults.errors.forEach(error => {
-                        resultText += `   - ${error}\n`;
-                    });
-                }
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: resultText
-                    }]
-            };
-        }
-        catch (error) {
-            logger_js_1.logger.error('Error linking catalog to flow:', error);
-            linkResults.errors.push(error.message);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `❌ Failed to link catalog to flow\n\nError: ${error.message}\n\n` +
-                            `💡 Troubleshooting:\n` +
-                            `1. Verify catalog item exists: ${catalog_item_id}\n` +
-                            `2. Verify flow exists: ${flow_id}\n` +
-                            `3. Check permissions for creating ${link_type} links\n` +
-                            `4. Ensure flow is active and published\n\n` +
-                            `Results: ${JSON.stringify(linkResults, null, 2)}`
-                    }]
-            };
-        }
-    }
     async handleCleanupTestArtifacts(args) {
         const { artifact_types = ['catalog_items', 'flows', 'users'], test_patterns = ['Test%', 'Mock%', 'Demo%', '%_test_%', '%test', '%mock'], max_age_hours = 1, dry_run = false, preserve_update_set_entries = true, update_set_filter } = args;
         logger_js_1.logger.info('Starting test artifact cleanup', {
@@ -3047,9 +2316,7 @@ ${JSON.stringify(testResults, null, 2)}
                 if (artifactType === 'all' || artifact_types.includes('catalog_items')) {
                     await this.cleanupTestCatalogItems(test_patterns, cutoffISO, dry_run, cleanupResults, update_set_filter);
                 }
-                if (artifactType === 'all' || artifact_types.includes('flows')) {
-                    await this.cleanupTestFlows(test_patterns, cutoffISO, dry_run, cleanupResults, update_set_filter);
-                }
+                // Flow cleanup removed in v1.4.38 - flows no longer supported
                 if (artifactType === 'all' || artifact_types.includes('users')) {
                     await this.cleanupTestUsers(test_patterns, cutoffISO, dry_run, cleanupResults, update_set_filter);
                 }
@@ -3174,41 +2441,6 @@ ${JSON.stringify(testResults, null, 2)}
             results.errors.push(`Error cleaning catalog items: ${error.message}`);
         }
     }
-    async cleanupTestFlows(patterns, cutoffTime, dryRun, results, updateSetFilter) {
-        try {
-            const patternQueries = patterns.map(pattern => {
-                if (pattern.includes('%')) {
-                    return `nameLIKE${pattern.replace(/%/g, '')}`;
-                }
-                else {
-                    return `name=${pattern}`;
-                }
-            });
-            const query = `(${patternQueries.join('^OR')})^sys_created_on<${cutoffTime}`;
-            const searchResult = await this.client.searchRecords('sys_hub_flow', query, 100);
-            if (searchResult.success && searchResult.data?.result) {
-                results.artifacts_found.flows = searchResult.data.result.map((flow) => ({
-                    sys_id: flow.sys_id,
-                    name: flow.name,
-                    sys_created_on: flow.sys_created_on
-                }));
-                if (!dryRun) {
-                    for (const flow of searchResult.data.result) {
-                        const deleteResult = await this.client.deleteRecord('sys_hub_flow', flow.sys_id);
-                        if (deleteResult.success) {
-                            results.artifacts_deleted.flows++;
-                        }
-                        else {
-                            results.errors.push(`Failed to delete flow ${flow.name}: ${deleteResult.error}`);
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            results.errors.push(`Error cleaning flows: ${error.message}`);
-        }
-    }
     async cleanupTestUsers(patterns, cutoffTime, dryRun, results, updateSetFilter) {
         try {
             const patternQueries = patterns.map(pattern => {