snow-flow 1.1.43 → 1.1.47

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

@@ -482,6 +482,218 @@ class ServiceNowOperationsMCP {
                             },
                             required: ['action']
                         }
+                    },
+                    {
+                        name: 'snow_catalog_item_search',
+                        description: 'Search for catalog items with intelligent matching and discovery',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: {
+                                    type: 'string',
+                                    description: 'Search query (e.g., "iPhone", "laptop", "mobile device")'
+                                },
+                                include_inactive: {
+                                    type: 'boolean',
+                                    description: 'Include inactive catalog items',
+                                    default: false
+                                },
+                                fuzzy_match: {
+                                    type: 'boolean',
+                                    description: 'Enable fuzzy matching for similar items',
+                                    default: true
+                                },
+                                category_filter: {
+                                    type: 'string',
+                                    description: 'Filter by category name or sys_id'
+                                },
+                                limit: {
+                                    type: 'number',
+                                    description: 'Maximum results to return',
+                                    default: 50
+                                },
+                                include_variables: {
+                                    type: 'boolean',
+                                    description: 'Include catalog item variables in results',
+                                    default: false
+                                }
+                            },
+                            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',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                artifact_types: {
+                                    type: 'array',
+                                    description: 'Types of artifacts to clean up',
+                                    items: {
+                                        type: 'string',
+                                        enum: ['catalog_items', 'flows', 'users', 'requests', 'all']
+                                    },
+                                    default: ['catalog_items', 'flows', 'users']
+                                },
+                                test_patterns: {
+                                    type: 'array',
+                                    description: 'Name patterns that identify test artifacts',
+                                    items: { type: 'string' },
+                                    default: ['Test%', 'Mock%', 'Demo%', '%_test_%', '%test', '%mock']
+                                },
+                                max_age_hours: {
+                                    type: 'number',
+                                    description: 'Only clean artifacts older than this (hours)',
+                                    default: 1
+                                },
+                                dry_run: {
+                                    type: 'boolean',
+                                    description: 'Preview what would be deleted without actually deleting',
+                                    default: false
+                                },
+                                preserve_update_set_entries: {
+                                    type: 'boolean',
+                                    description: 'Keep Update Set entries as audit trail',
+                                    default: true
+                                },
+                                update_set_filter: {
+                                    type: 'string',
+                                    description: 'Only clean from specific Update Set (optional)'
+                                }
+                            }
+                        }
                     }
                 ],
             };
@@ -515,6 +727,14 @@ class ServiceNowOperationsMCP {
                         return await this.handlePredictiveAnalysis(args);
                     case 'snow_catalog_item_manager':
                         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);
                     default:
                         throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Tool ${name} not found`);
                 }
@@ -1382,6 +1602,34 @@ class ServiceNowOperationsMCP {
         try {
             switch (action) {
                 case 'create': {
+                    // Get default catalog if none provided
+                    let catalogId = params.sc_catalogs || params.catalog_id;
+                    let categoryId = params.sc_categories || params.category_id;
+                    if (!catalogId) {
+                        // Find default Service Catalog
+                        const defaultCatalogResult = await this.client.searchRecords('sc_catalog', 'active=true^ORDERBYsys_created_on', 1);
+                        if (defaultCatalogResult.success && defaultCatalogResult.data?.result?.length > 0) {
+                            catalogId = defaultCatalogResult.data.result[0].sys_id;
+                            logger_js_1.logger.info('Using default catalog:', {
+                                catalogId,
+                                catalogName: defaultCatalogResult.data.result[0].title
+                            });
+                        }
+                        else {
+                            logger_js_1.logger.warn('No catalogs found, catalog item may not be visible');
+                        }
+                    }
+                    if (!categoryId) {
+                        // Find a default category like "Hardware" or "General"
+                        const defaultCategoryResult = await this.client.searchRecords('sc_category', 'active=true^titleLIKEHardware^ORtitleLIKEGeneral^ORtitleLIKEIT^ORDERBYsys_created_on', 1);
+                        if (defaultCategoryResult.success && defaultCategoryResult.data?.result?.length > 0) {
+                            categoryId = defaultCategoryResult.data.result[0].sys_id;
+                            logger_js_1.logger.info('Using default category:', {
+                                categoryId,
+                                categoryName: defaultCategoryResult.data.result[0].title
+                            });
+                        }
+                    }
                     const catalogItem = {
                         name: params.name,
                         short_description: params.short_description,
@@ -1392,8 +1640,8 @@ class ServiceNowOperationsMCP {
                         active: params.active !== false,
                         workflow: params.workflow,
                         picture: params.picture,
-                        sc_catalogs: params.sc_catalogs || params.catalog_id,
-                        sc_categories: params.sc_categories || params.category_id,
+                        sc_catalogs: catalogId,
+                        sc_categories: categoryId,
                         sys_class_name: 'sc_cat_item'
                     };
                     const result = await this.client.createRecord('sc_cat_item', catalogItem);
@@ -1597,6 +1845,998 @@ class ServiceNowOperationsMCP {
         };
         return typeMap[type] || '6'; // Default to single line text
     }
+    async handleCatalogItemSearch(args) {
+        const { query, include_inactive = false, fuzzy_match = true, category_filter, limit = 50, include_variables = false } = args;
+        logger_js_1.logger.info(`Searching catalog items for: ${query}`, { fuzzy_match, category_filter, limit });
+        try {
+            // Build search queries
+            const searchQueries = [];
+            // Exact match
+            searchQueries.push(`name=${query}`);
+            // Contains match
+            searchQueries.push(`nameLIKE${query}`);
+            searchQueries.push(`short_descriptionLIKE${query}`);
+            // Fuzzy matching for similar items
+            if (fuzzy_match) {
+                // Handle common variations
+                const variations = this.generateSearchVariations(query);
+                variations.forEach(variation => {
+                    searchQueries.push(`nameLIKE${variation}`);
+                    searchQueries.push(`short_descriptionLIKE${variation}`);
+                });
+            }
+            // Add active filter
+            const activeFilter = include_inactive ? '' : '^active=true';
+            // Add category filter if provided
+            let categoryFilter = '';
+            if (category_filter) {
+                // First try to find the category
+                const categoryResult = await this.client.searchRecords('sc_category', `name=${category_filter}^ORsys_id=${category_filter}`, 1);
+                if (categoryResult.success && categoryResult.data?.result?.length > 0) {
+                    categoryFilter = `^sc_categories=${categoryResult.data.result[0].sys_id}`;
+                }
+            }
+            // Execute searches
+            const allResults = new Map();
+            for (const searchQuery of searchQueries) {
+                const fullQuery = searchQuery + activeFilter + categoryFilter;
+                const result = await this.client.searchRecords('sc_cat_item', fullQuery, limit);
+                if (result.success && result.data?.result) {
+                    result.data.result.forEach((item) => {
+                        if (!allResults.has(item.sys_id)) {
+                            allResults.set(item.sys_id, {
+                                sys_id: item.sys_id,
+                                name: item.name,
+                                short_description: item.short_description,
+                                price: item.price,
+                                recurring_price: item.recurring_price,
+                                active: item.active,
+                                category: item.sc_categories?.display_value,
+                                catalog: item.sc_catalogs?.display_value,
+                                model_number: item.model,
+                                manufacturer: item.vendor,
+                                variables: []
+                            });
+                        }
+                    });
+                }
+            }
+            // Get variables if requested
+            if (include_variables && allResults.size > 0) {
+                for (const [sys_id, item] of allResults) {
+                    const variablesResult = await this.client.searchRecords('item_option_new', `cat_item=${sys_id}`, 50);
+                    if (variablesResult.success && variablesResult.data?.result) {
+                        item.variables = variablesResult.data.result.map((v) => ({
+                            name: v.name,
+                            label: v.question_text,
+                            type: v.type,
+                            mandatory: v.mandatory,
+                            default_value: v.default_value
+                        }));
+                    }
+                }
+            }
+            const resultsArray = Array.from(allResults.values());
+            // Sort by relevance (exact matches first)
+            resultsArray.sort((a, b) => {
+                const aExact = a.name.toLowerCase() === query.toLowerCase();
+                const bExact = b.name.toLowerCase() === query.toLowerCase();
+                if (aExact && !bExact)
+                    return -1;
+                if (!aExact && bExact)
+                    return 1;
+                return 0;
+            });
+            if (resultsArray.length === 0) {
+                // Provide suggestions if no results found
+                const suggestions = this.generateSearchSuggestions(query);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ No catalog items found for "${query}"\n\n` +
+                                `💡 Suggestions:\n` +
+                                suggestions.map(s => `- Try searching for "${s}"`).join('\n') +
+                                `\n\n💡 Tips:\n` +
+                                `- Check if the item name is spelled correctly\n` +
+                                `- Try searching with partial names (e.g., "iPhone" instead of "iPhone 6S")\n` +
+                                `- Use category filter to narrow down results\n` +
+                                `- Enable include_inactive if looking for retired items`
+                        }]
+                };
+            }
+            // Format results
+            let resultText = `🔍 Found ${resultsArray.length} catalog items matching "${query}":\n\n`;
+            resultsArray.forEach((item, index) => {
+                resultText += `${index + 1}. **${item.name}** (${item.sys_id})\n`;
+                resultText += `   📝 ${item.short_description || 'No description'}\n`;
+                resultText += `   💰 Price: $${item.price || '0'} ${item.recurring_price ? `(+ $${item.recurring_price}/month)` : ''}\n`;
+                resultText += `   📁 Category: ${item.category || 'Uncategorized'}\n`;
+                resultText += `   📚 Catalog: ${item.catalog || 'Default'}\n`;
+                if (item.model_number) {
+                    resultText += `   🔢 Model: ${item.model_number}\n`;
+                }
+                if (item.manufacturer) {
+                    resultText += `   🏭 Manufacturer: ${item.manufacturer}\n`;
+                }
+                resultText += `   ✅ Status: ${item.active ? 'Active' : 'Inactive'}\n`;
+                if (item.variables && item.variables.length > 0) {
+                    resultText += `   📋 Variables (${item.variables.length}):\n`;
+                    item.variables.forEach((v) => {
+                        resultText += `      - ${v.label} (${v.name}) - ${v.type}${v.mandatory ? ' *Required' : ''}\n`;
+                    });
+                }
+                resultText += '\n';
+            });
+            resultText += `\n💡 Use snow_catalog_item_manager to create or update catalog items`;
+            return {
+                content: [{
+                        type: 'text',
+                        text: resultText
+                    }]
+            };
+        }
+        catch (error) {
+            logger_js_1.logger.error('Error searching catalog items:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Catalog search error: ${error}`);
+        }
+    }
+    generateSearchVariations(query) {
+        const variations = [];
+        // Handle common product variations
+        if (query.toLowerCase().includes('iphone')) {
+            // Add variations without spaces, with different numbers
+            const baseModel = query.replace(/iphone\s*/i, 'iPhone ');
+            variations.push(baseModel);
+            variations.push(baseModel.replace(' ', ''));
+            // Try different model numbers
+            const modelMatch = query.match(/\d+/);
+            if (modelMatch) {
+                const modelNum = parseInt(modelMatch[0]);
+                variations.push(query.replace(modelNum.toString(), (modelNum + 1).toString()));
+                variations.push(query.replace(modelNum.toString(), (modelNum - 1).toString()));
+            }
+        }
+        // Handle laptop/computer variations
+        if (query.toLowerCase().includes('laptop') || query.toLowerCase().includes('computer')) {
+            variations.push('notebook', 'macbook', 'thinkpad', 'dell', 'hp');
+        }
+        // Handle phone variations
+        if (query.toLowerCase().includes('phone') || query.toLowerCase().includes('mobile')) {
+            variations.push('smartphone', 'android', 'samsung', 'pixel');
+        }
+        return variations;
+    }
+    generateSearchSuggestions(query) {
+        const suggestions = [];
+        if (query.toLowerCase().includes('iphone')) {
+            suggestions.push('iPhone', 'Apple iPhone', 'iOS device', 'Apple mobile');
+        }
+        else if (query.toLowerCase().includes('laptop')) {
+            suggestions.push('notebook', 'computer', 'workstation', 'MacBook', 'ThinkPad');
+        }
+        else if (query.toLowerCase().includes('software')) {
+            suggestions.push('license', 'application', 'subscription', 'SaaS');
+        }
+        else {
+            // Generic suggestions
+            suggestions.push(query.split(' ')[0], // First word only
+            query.substring(0, Math.floor(query.length / 2)), // First half
+            'hardware', 'software', 'equipment', 'device');
+        }
+        return [...new Set(suggestions)].filter(s => s && s !== query);
+    }
+    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
+            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}`);
+            }
+            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\n\nError: ${error.message}\n\nTest Results:\n${JSON.stringify(testResults, null, 2)}`
+                    }]
+            };
+        }
+    }
+    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 || 'system',
+                        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 || 'system'}\n`;
+                }
+            }
+            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', {
+            artifact_types,
+            test_patterns,
+            max_age_hours,
+            dry_run
+        });
+        const cleanupResults = {
+            start_time: new Date().toISOString(),
+            dry_run,
+            artifacts_found: {
+                catalog_items: [],
+                flows: [],
+                users: [],
+                requests: []
+            },
+            artifacts_deleted: {
+                catalog_items: 0,
+                flows: 0,
+                users: 0,
+                requests: 0
+            },
+            update_set_entries_preserved: 0,
+            errors: [],
+            summary: ''
+        };
+        try {
+            // Calculate cutoff time
+            const cutoffTime = new Date();
+            cutoffTime.setHours(cutoffTime.getHours() - max_age_hours);
+            const cutoffISO = cutoffTime.toISOString();
+            // Process each artifact type
+            for (const artifactType of artifact_types) {
+                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);
+                }
+                if (artifactType === 'all' || artifact_types.includes('users')) {
+                    await this.cleanupTestUsers(test_patterns, cutoffISO, dry_run, cleanupResults, update_set_filter);
+                }
+                if (artifactType === 'all' || artifact_types.includes('requests')) {
+                    await this.cleanupTestRequests(test_patterns, cutoffISO, dry_run, cleanupResults, update_set_filter);
+                }
+            }
+            // Generate summary
+            const totalFound = Object.values(cleanupResults.artifacts_found)
+                .reduce((sum, items) => sum + (Array.isArray(items) ? items.length : 0), 0);
+            const totalDeleted = Object.values(cleanupResults.artifacts_deleted)
+                .reduce((sum, count) => sum + count, 0);
+            cleanupResults.summary = dry_run
+                ? `🔍 Dry Run: Found ${totalFound} test artifacts that would be cleaned up`
+                : `🧹 Cleaned up ${totalDeleted} test artifacts successfully`;
+            // Format results
+            let resultText = `🧹 Test Artifact Cleanup Results\n${'='.repeat(50)}\n\n`;
+            if (dry_run) {
+                resultText += `🔍 **DRY RUN MODE** - No actual deletion performed\n\n`;
+            }
+            resultText += `⏰ **Cleanup Configuration:**\n`;
+            resultText += `- Artifact Types: ${artifact_types.join(', ')}\n`;
+            resultText += `- Test Patterns: ${test_patterns.join(', ')}\n`;
+            resultText += `- Max Age: ${max_age_hours} hours\n`;
+            resultText += `- Cutoff Time: ${cutoffISO}\n`;
+            resultText += `- Preserve Update Set Entries: ${preserve_update_set_entries ? '✅' : '❌'}\n\n`;
+            // Report findings by type
+            ['catalog_items', 'flows', 'users', 'requests'].forEach(type => {
+                const found = cleanupResults.artifacts_found[type] || [];
+                const deleted = cleanupResults.artifacts_deleted[type] || 0;
+                if (found.length > 0) {
+                    resultText += `📦 **${type.replace('_', ' ').toUpperCase()}:**\n`;
+                    resultText += `   ${dry_run ? 'Found' : 'Deleted'}: ${dry_run ? found.length : deleted}\n`;
+                    if (dry_run && found.length > 0) {
+                        found.slice(0, 10).forEach((item) => {
+                            resultText += `   - ${item.name} (${item.sys_id}) - Created: ${item.sys_created_on}\n`;
+                        });
+                        if (found.length > 10) {
+                            resultText += `   ... and ${found.length - 10} more\n`;
+                        }
+                    }
+                    resultText += '\n';
+                }
+            });
+            if (cleanupResults.update_set_entries_preserved > 0) {
+                resultText += `📋 **Update Set Audit Trail Preserved:** ${cleanupResults.update_set_entries_preserved} entries\n\n`;
+            }
+            if (cleanupResults.errors.length > 0) {
+                resultText += `❌ **Errors:**\n`;
+                cleanupResults.errors.forEach(error => {
+                    resultText += `   - ${error}\n`;
+                });
+                resultText += '\n';
+            }
+            resultText += `✅ **${cleanupResults.summary}**\n\n`;
+            if (!dry_run && totalDeleted > 0) {
+                resultText += `💡 **Note:** Update Set entries have been preserved as audit trail.\n`;
+                resultText += `This shows that testing was performed and cleanup was completed.\n\n`;
+            }
+            if (dry_run) {
+                resultText += `▶️ **Next Steps:**\n`;
+                resultText += `1. Review the artifacts that would be deleted\n`;
+                resultText += `2. Run again with dry_run: false to perform actual cleanup\n`;
+                resultText += `3. Verify Update Set entries are preserved as intended\n`;
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: resultText
+                    }]
+            };
+        }
+        catch (error) {
+            logger_js_1.logger.error('Error during test artifact cleanup:', error);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Test artifact cleanup failed\n\nError: ${error.message}\n\n` +
+                            `🔧 Troubleshooting:\n` +
+                            `1. Check ServiceNow connection and permissions\n` +
+                            `2. Verify test patterns are correct\n` +
+                            `3. Ensure artifacts exist and are accessible\n\n` +
+                            `Debug Info: ${JSON.stringify(cleanupResults, null, 2)}`
+                    }]
+            };
+        }
+    }
+    async cleanupTestCatalogItems(patterns, cutoffTime, dryRun, results, updateSetFilter) {
+        try {
+            // Build query for test catalog items
+            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('sc_cat_item', query, 100);
+            if (searchResult.success && searchResult.data?.result) {
+                results.artifacts_found.catalog_items = searchResult.data.result.map((item) => ({
+                    sys_id: item.sys_id,
+                    name: item.name,
+                    sys_created_on: item.sys_created_on
+                }));
+                if (!dryRun) {
+                    // Delete each catalog item
+                    for (const item of searchResult.data.result) {
+                        const deleteResult = await this.client.deleteRecord('sc_cat_item', item.sys_id);
+                        if (deleteResult.success) {
+                            results.artifacts_deleted.catalog_items++;
+                        }
+                        else {
+                            results.errors.push(`Failed to delete catalog item ${item.name}: ${deleteResult.error}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            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 => {
+                if (pattern.includes('%')) {
+                    return `user_nameLIKE${pattern.replace(/%/g, '')}^ORfirst_nameLIKE${pattern.replace(/%/g, '')}`;
+                }
+                else {
+                    return `user_name=${pattern}^ORfirst_name=${pattern}`;
+                }
+            });
+            const query = `(${patternQueries.join('^OR')})^sys_created_on<${cutoffTime}^active=false`;
+            const searchResult = await this.client.searchRecords('sys_user', query, 100);
+            if (searchResult.success && searchResult.data?.result) {
+                results.artifacts_found.users = searchResult.data.result.map((user) => ({
+                    sys_id: user.sys_id,
+                    name: user.user_name || user.name,
+                    sys_created_on: user.sys_created_on
+                }));
+                if (!dryRun) {
+                    for (const user of searchResult.data.result) {
+                        const deleteResult = await this.client.deleteRecord('sys_user', user.sys_id);
+                        if (deleteResult.success) {
+                            results.artifacts_deleted.users++;
+                        }
+                        else {
+                            results.errors.push(`Failed to delete user ${user.user_name}: ${deleteResult.error}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            results.errors.push(`Error cleaning users: ${error.message}`);
+        }
+    }
+    async cleanupTestRequests(patterns, cutoffTime, dryRun, results, updateSetFilter) {
+        try {
+            const patternQueries = patterns.map(pattern => {
+                if (pattern.includes('%')) {
+                    return `short_descriptionLIKE${pattern.replace(/%/g, '')}`;
+                }
+                else {
+                    return `short_description=${pattern}`;
+                }
+            });
+            const query = `(${patternQueries.join('^OR')})^sys_created_on<${cutoffTime}`;
+            const searchResult = await this.client.searchRecords('sc_request', query, 100);
+            if (searchResult.success && searchResult.data?.result) {
+                results.artifacts_found.requests = searchResult.data.result.map((req) => ({
+                    sys_id: req.sys_id,
+                    name: req.number || req.short_description,
+                    sys_created_on: req.sys_created_on
+                }));
+                if (!dryRun) {
+                    for (const request of searchResult.data.result) {
+                        // Cancel request instead of deleting (safer)
+                        const updateResult = await this.client.updateRecord('sc_request', request.sys_id, {
+                            state: '4', // Cancelled
+                            comments: 'Cancelled by test cleanup automation'
+                        });
+                        if (updateResult.success) {
+                            results.artifacts_deleted.requests++;
+                        }
+                        else {
+                            results.errors.push(`Failed to cancel request ${request.number}: ${updateResult.error}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            results.errors.push(`Error cleaning requests: ${error.message}`);
+        }
+    }
     getServiceNowUrl() {
         // This would need to get the instance URL from credentials
         return 'https://instance.service-now.com';