snow-flow 3.6.15 → 3.6.17

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,23 +1005,37 @@ ${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)
-                    // Probeer alleen ui_policy en policy als alternatief
-                    if (policyId) {
-                        // Probeer ui_policy (dit is waarschijnlijk correct)
-                        actionData.ui_policy = policyId;
+                    // ✅ CRITICAL FIX: ui_policy field expects the NAME (short_description), NOT the sys_id!
+                    // ServiceNow uses the policy name as the reference value
+                    if (args.short_description) {
+                        actionData.ui_policy = args.short_description; // ✅ Use the policy NAME, not sys_id!
+                        this.logger.info(`🔗 Linking action to policy by NAME: "${args.short_description}"`);
+                    }
+                    else {
+                        // Fallback if somehow we don't have the name
+                        this.logger.error(`❌ CRITICAL: No policy name (short_description) available for linking!`);
+                        actionData.ui_policy = policyId; // Use sys_id as last resort
                     }
                     // Voeg alleen GEDEFINIEERDE action properties toe 
                     if (action.mandatory !== undefined) {

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.17",
+  "description": "UI POLICY NAME FIX - v3.6.17 fixes critical issue where ui_policy field in catalog_ui_policy_action table expects the policy NAME (short_description) instead of sys_id. Actions will now properly link to policies using the policy name as the reference value, which is what ServiceNow actually expects.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {