snow-flow 3.6.15 → 3.6.16

package/dist/mcp/servicenow-knowledge-catalog-mcp.js

@@ -807,23 +807,102 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
     async createCatalogUIPolicy(args) {
         try {
             this.logger.info('Creating comprehensive catalog UI policy...');
-            // Helper function to resolve variable names to sys_ids
+            // First, let's fetch ALL variables for this catalog item for debugging
+            this.logger.info(`📋 Fetching all variables for catalog item ${args.cat_item} for debugging...`);
+            try {
+                const allVarsResponse = await this.client.searchRecords('sc_cat_item_option', `cat_item=${args.cat_item}`, 100);
+                if (allVarsResponse.success && allVarsResponse.data.result.length > 0) {
+                    this.logger.info(`📊 Found ${allVarsResponse.data.result.length} variables for this catalog item:`);
+                    allVarsResponse.data.result.forEach((v) => {
+                        this.logger.info(`  - Variable: name='${v.name}', sys_id='${v.sys_id}', question='${v.question_text}'`);
+                    });
+                }
+                else {
+                    this.logger.warn(`⚠️ No variables found for catalog item ${args.cat_item} - this might be a problem!`);
+                }
+            }
+            catch (error) {
+                this.logger.error(`❌ Failed to fetch variables for debugging:`, error);
+            }
+            // Helper function to resolve variable names to sys_ids with MULTIPLE FALLBACKS
             const resolveVariableId = async (variableName, catalogItem) => {
                 // If already a sys_id, return as-is
                 if (variableName && variableName.match(/^[a-f0-9]{32}$/)) {
                     this.logger.info(`✅ Using sys_id directly: ${variableName}`);
                     return variableName;
                 }
-                // Search for variable by name in this catalog item
-                this.logger.info(`🔍 Resolving variable name '${variableName}' to sys_id...`);
-                const varResponse = await this.client.searchRecords('sc_cat_item_option', `cat_item=${catalogItem}^name=${variableName}`, 1);
-                if (varResponse.success && varResponse.data.result.length > 0) {
-                    const sysId = varResponse.data.result[0].sys_id;
-                    this.logger.info(`✅ Resolved '${variableName}' to sys_id: ${sysId}`);
-                    return sysId;
+                this.logger.info(`🔍 Resolving variable name '${variableName}' to sys_id for catalog item ${catalogItem}...`);
+                // Try multiple search strategies for maximum compatibility
+                const searchStrategies = [
+                    // Strategy 1: Search by name field
+                    {
+                        query: `cat_item=${catalogItem}^name=${variableName}`,
+                        description: 'by name field'
+                    },
+                    // Strategy 2: Search by name with LIKE operator
+                    {
+                        query: `cat_item=${catalogItem}^nameLIKE${variableName}`,
+                        description: 'by name with LIKE'
+                    },
+                    // Strategy 3: Search by question_text
+                    {
+                        query: `cat_item=${catalogItem}^question_text=${variableName}`,
+                        description: 'by question_text field'
+                    },
+                    // Strategy 4: Search all variables for this item and match manually
+                    {
+                        query: `cat_item=${catalogItem}`,
+                        description: 'all variables for manual matching'
+                    }
+                ];
+                for (const strategy of searchStrategies) {
+                    this.logger.info(`🔍 Trying strategy: ${strategy.description}`);
+                    try {
+                        const varResponse = await this.client.searchRecords('sc_cat_item_option', strategy.query, 50 // Get more results for manual matching
+                        );
+                        if (varResponse.success && varResponse.data.result.length > 0) {
+                            // For the "all variables" strategy, try to match manually
+                            if (strategy.description === 'all variables for manual matching') {
+                                const match = varResponse.data.result.find((v) => v.name === variableName ||
+                                    v.question_text === variableName ||
+                                    v.name?.toLowerCase() === variableName.toLowerCase());
+                                if (match) {
+                                    this.logger.info(`✅ Found variable through manual matching: ${match.sys_id}`);
+                                    return match.sys_id;
+                                }
+                            }
+                            else {
+                                // Direct match found
+                                const sysId = varResponse.data.result[0].sys_id;
+                                this.logger.info(`✅ Resolved '${variableName}' to sys_id: ${sysId} (${strategy.description})`);
+                                return sysId;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.logger.warn(`⚠️ Strategy failed: ${strategy.description}`, error);
+                    }
+                }
+                // If all strategies fail, try alternate table names (just in case)
+                const alternateTables = ['item_option_new', 'io_set_item_option'];
+                for (const table of alternateTables) {
+                    this.logger.info(`🔍 Trying alternate table: ${table}`);
+                    try {
+                        const varResponse = await this.client.searchRecords(table, `cat_item=${catalogItem}^name=${variableName}`, 1);
+                        if (varResponse.success && varResponse.data.result.length > 0) {
+                            const sysId = varResponse.data.result[0].sys_id;
+                            this.logger.info(`✅ Found in alternate table ${table}: ${sysId}`);
+                            return sysId;
+                        }
+                    }
+                    catch (error) {
+                        this.logger.warn(`⚠️ Alternate table ${table} failed:`, error);
+                    }
                 }
-                this.logger.warn(`⚠️ Variable '${variableName}' not found for catalog item ${catalogItem}, using name as fallback`);
-                return variableName; // Return original if not found
+                this.logger.error(`❌ CRITICAL: Variable '${variableName}' not found in any table for catalog item ${catalogItem}`);
+                this.logger.error(`❌ This will cause the action to fail! Please use the sys_id directly instead of the name.`);
+                // Return the name but log a warning that this will fail
+                return variableName;
             };
             // Helper function to map operations to correct ServiceNow format
             const mapOperatorToServiceNow = (operator) => {
@@ -926,16 +1005,25 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                     // Resolve variable name to sys_id
                     this.logger.info(`🔍 Resolving variable: ${action.catalog_variable} for catalog item: ${args.cat_item}`);
                     const variableId = await resolveVariableId(action.catalog_variable, args.cat_item);
-                    this.logger.info(`✅ Resolved to variable ID: ${variableId}`);
+                    // Check if resolution actually worked (should be a sys_id now)
+                    const isValidSysId = variableId && variableId.match(/^[a-f0-9]{32}$/);
+                    if (!isValidSysId) {
+                        this.logger.error(`❌ CRITICAL: Failed to resolve variable '${action.catalog_variable}' to sys_id!`);
+                        this.logger.error(`❌ Got: ${variableId} (this is not a valid sys_id)`);
+                        // Continue anyway but it will likely fail
+                    }
+                    else {
+                        this.logger.info(`✅ Resolved to variable sys_id: ${variableId}`);
+                    }
                     // ✅ CRITICAL FIX: Add "IO:" prefix as required by ServiceNow
-                    const catalogVariableWithPrefix = `IO:${variableId}`;
-                    this.logger.info(`🎯 Using catalog_variable with IO: prefix: ${catalogVariableWithPrefix}`);
+                    // BUT ONLY if we have a valid sys_id!
+                    const catalogVariableWithPrefix = isValidSysId ? `IO:${variableId}` : variableId;
+                    this.logger.info(`🎯 Using catalog_variable value: ${catalogVariableWithPrefix}`);
                     // Actions structure in ServiceNow:
                     // - catalog_ui_policy_action.catalog_variable -> "IO:" + variable_sys_id (required format)
-                    // - item_option_new.cat_item -> sc_cat_item (catalog item)
-                    // - catalog_ui_policy.catalog_item -> sc_cat_item (catalog item)
+                    // - catalog_ui_policy_action.ui_policy -> catalog_ui_policy.sys_id
                     const actionData = {
-                        // ✅ Main connection: to the variable with required IO: prefix
+                        // ✅ Main connection: to the variable with required IO: prefix (if valid sys_id)
                         catalog_variable: catalogVariableWithPrefix
                     };
                     // NIET: catalog_ui_policy - deze veld bestaat NIET (volgens error log)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.6.15",
-  "description": "CRITICAL CATALOG UI POLICY FIXES - v3.6.15 fixes ALL catalog UI policy issues based on detailed user feedback. Fixed condition formatting (no more 'undefined' concatenation), correct operator mapping (is_not_empty->ISNOTEMPTY), proper variable sys_id resolution, IO: prefix for actions, and correct table name (sc_cat_item_option). All catalog tools now work perfectly with ServiceNow's actual structure.",
+  "version": "3.6.16",
+  "description": "ENHANCED VARIABLE RESOLUTION - v3.6.16 adds comprehensive multi-strategy variable resolution with 4 different search methods, automatic debugging that shows all available variables, better error handling when resolution fails, and support for alternate table names. Now properly handles cases where variable names can't be resolved to sys_ids and provides clear warnings.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {