snow-flow 3.6.20 → 3.6.23

package/dist/dynamic-version.js

@@ -36,7 +36,7 @@ function getDynamicVersion() {
         console.warn('Warning: Could not read version from package.json:', error);
     }
     // Fallback to hardcoded version
-    return '3.4.4';
+    return '3.6.23';
 }
 // Export a constant that uses the dynamic version
 exports.VERSION = getDynamicVersion();

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

@@ -752,8 +752,8 @@ ${args.recurring_price && args.recurring_price !== '0' ? `🔄 Recurring: $${arg
                 tooltip: args.tooltip || ''
             };
             this.logger.info('🎯 Creating variable with payload:', variableData);
-            // ✅ CORRECT TABLE NAME: Use sc_cat_item_option instead of item_option_new
-            const response = await this.client.createRecord('sc_cat_item_option', variableData);
+            // ✅ FIXED TABLE NAME: Use item_option_new (the correct table for catalog variables)
+            const response = await this.client.createRecord('item_option_new', variableData);
             if (!response.success) {
                 this.logger.error('❌ Variable creation failed:', {
                     error: response.error,
@@ -766,7 +766,7 @@ ${args.recurring_price && args.recurring_price !== '0' ? `🔄 Recurring: $${arg
             this.logger.info(`✅ Variable created with sys_id: ${createdSysId}`);
             // 🔍 VERIFICATION: Check if variable was actually created
             this.logger.info('🔍 Verifying variable creation...');
-            const verification = await this.client.searchRecords('sc_cat_item_option', `sys_id=${createdSysId}`, 1);
+            const verification = await this.client.searchRecords('item_option_new', `sys_id=${createdSysId}`, 1);
             if (!verification.success || verification.data.result.length === 0) {
                 this.logger.error('❌ VERIFICATION FAILED: Variable not found after creation!');
                 throw new Error(`Variable creation verification failed - not found in database`);
@@ -797,16 +797,16 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
     }
     /**
      * Create Catalog UI Policy with Actions
-     * Creates records in 2 tables: sys_ui_policy and catalog_ui_policy_action
+     * Creates records in 2 tables: catalog_ui_policy and catalog_ui_policy_action
      *
-     * ✅ FINAL CORRECT STRUCTURE (v3.6.20):
-     * - Main policy goes in sys_ui_policy table (NOT catalog_ui_policy!)
+     * ✅ CORRECTED STRUCTURE (v3.6.21):
+     * - Main policy goes in catalog_ui_policy table (NOT sys_ui_policy!)
      * - Actions go in catalog_ui_policy_action table (inherits from sys_ui_policy_action)
-     * - Actions reference sys_ui_policy via ui_policy field (using policy sys_id directly)
+     * - Actions reference catalog_ui_policy via ui_policy field (using policy sys_id directly)
      * - Conditions use IO:sys_id format for catalog variables
      * - catalog_ui_policy_action.catalog_variable uses IO:sys_id format
      * - visible/mandatory/disabled use "ignore" as default, not false or empty
-     * - Reference fields are set directly, not via setValue() for reliability
+     * - Reference fields are set directly for reliability
      * - Enhanced verification ensures all critical fields are populated
      */
     async createCatalogUIPolicy(args) {
@@ -981,24 +981,23 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                 conditionString = conditionParts.join('^');
                 this.logger.info(`✅ Built conditions string: "${conditionString}"`);
             }
-            // ✅ CRITICAL FIX: Create in sys_ui_policy table, NOT catalog_ui_policy!
-            // The actions reference sys_ui_policy, not catalog_ui_policy
+            // ✅ CRITICAL FIX: Create in catalog_ui_policy table!
+            // The actions reference catalog_ui_policy, NOT sys_ui_policy!
             const policyData = {
-                // sys_ui_policy fields are different from catalog_ui_policy!
-                name: args.short_description, // sys_ui_policy uses 'name' not 'short_description'
-                table: 'sc_cat_item', // The table this policy applies to
-                conditions: conditionString || args.condition || '', // Condition string
+                // catalog_ui_policy fields
+                short_description: args.short_description,
+                catalog_item: args.cat_item, // Reference to the catalog item
+                catalog_conditions: conditionString || args.condition || '', // Conditions as string
+                applies_catalog: true, // This is a catalog policy
                 active: args.active !== false,
-                on_load: args.on_load !== false, // Different field name in sys_ui_policy
+                applies_on: args.applies_on || 'true', // When to apply: 'true', 'false', or 'both'
                 reverse_if_false: args.reverse_if_false !== false,
-                // Link to the catalog item via a different field
-                catalog_item: args.cat_item,
                 // Optional script fields
                 script_true: args.script_true || '',
                 script_false: args.script_false || ''
             };
-            this.logger.info('🎯 Creating main policy in sys_ui_policy table with data:', policyData);
-            const policyResponse = await this.client.createRecord('sys_ui_policy', policyData);
+            this.logger.info('🎯 Creating main policy in catalog_ui_policy table with data:', policyData);
+            const policyResponse = await this.client.createRecord('catalog_ui_policy', policyData);
             if (!policyResponse.success) {
                 this.logger.error('❌ Policy creation failed:', policyResponse.error);
                 throw new Error(`Failed to create catalog UI policy: ${policyResponse.error}`);
@@ -1041,14 +1040,39 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                     // catalog_ui_policy_action inherits from sys_ui_policy_action
                     // We must set fields in the correct way for ServiceNow to accept them
                     const actionData = {};
-                    // STEP 1: Set reference fields (MUST be set first for ServiceNow)
-                    // ✅ ui_policy is a reference to sys_ui_policy - use sys_id directly
+                    // STEP 1: ENHANCED VERIFICATION - Verify policy exists before creating actions
+                    this.logger.info(`🔍 ENHANCED DEBUG: Verifying policy ${policyId} exists before creating action...`);
+                    if (!policyId) {
+                        this.logger.error(`❌ CRITICAL: No policyId available for action ${i + 1}!`);
+                        throw new Error(`Cannot create action without valid policy ID`);
+                    }
+                    // ✅ NEW: Test policy existence before action creation
+                    const policyExists = await this.client.searchRecords('catalog_ui_policy', `sys_id=${policyId}`, 1);
+                    if (!policyExists.success || policyExists.data.result.length === 0) {
+                        this.logger.error(`❌ CRITICAL: Policy ${policyId} does not exist in catalog_ui_policy table!`);
+                        throw new Error(`Policy verification failed - cannot create action without valid policy`);
+                    }
+                    const existingPolicy = policyExists.data.result[0];
+                    this.logger.info(`✅ Policy verification successful:`);
+                    this.logger.info(`   - Policy sys_id: ${existingPolicy.sys_id}`);
+                    this.logger.info(`   - Policy name: ${existingPolicy.short_description || 'N/A'}`);
+                    this.logger.info(`   - Policy active: ${existingPolicy.active}`);
+                    // STEP 2: Set reference fields with enhanced validation
+                    // ✅ ui_policy is a reference to catalog_ui_policy - test multiple formats
+                    this.logger.info(`📝 Setting ui_policy reference to: ${policyId}`);
+                    // Try setting the reference in the most explicit way possible
                     actionData.ui_policy = policyId;
                     // ✅ catalog_item is a reference to sc_cat_item - use sys_id directly  
+                    if (!args.cat_item) {
+                        this.logger.error(`❌ CRITICAL: No catalog item ID provided!`);
+                        throw new Error(`Cannot create action without catalog item ID`);
+                    }
+                    this.logger.info(`📝 Setting catalog_item reference to: ${args.cat_item}`);
                     actionData.catalog_item = args.cat_item;
-                    // STEP 2: Set the catalog_variable with IO: prefix (STRING field, not reference)
+                    // STEP 3: Set the catalog_variable with IO: prefix (STRING field, not reference)
+                    this.logger.info(`📝 Setting catalog_variable to: ${catalogVariableWithPrefix}`);
                     actionData.catalog_variable = catalogVariableWithPrefix;
-                    // STEP 3: Set action properties with correct values
+                    // STEP 4: Set action properties with correct values
                     // ✅ CRITICAL: Use "ignore" instead of not setting or using false
                     // This is how ServiceNow differentiates between "don't change" and "set to false"
                     if (action.visible !== undefined) {
@@ -1072,20 +1096,22 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                     else {
                         actionData.disabled = 'ignore'; // Default to ignore if not specified
                     }
-                    // STEP 4: Set optional value field
+                    // STEP 5: Set optional value field
                     if (action.value !== undefined && action.value !== null && action.value !== '') {
                         actionData.value = String(action.value);
                     }
-                    // STEP 5: Set other metadata
+                    // STEP 6: Set other metadata
                     actionData.order = (i + 1) * 100;
                     actionData.active = true;
-                    this.logger.info(`🔗 Creating action with proper structure:`);
-                    this.logger.info(`  - ui_policy (ref): ${policyId}`);
+                    this.logger.info(`🔗 Creating action with VALIDATED structure:`);
+                    this.logger.info(`  - ui_policy (ref): ${policyId} [VERIFIED EXISTS]`);
                     this.logger.info(`  - catalog_item (ref): ${args.cat_item}`);
                     this.logger.info(`  - catalog_variable: ${catalogVariableWithPrefix}`);
                     this.logger.info(`  - visible: ${actionData.visible}`);
                     this.logger.info(`  - mandatory: ${actionData.mandatory}`);
                     this.logger.info(`  - disabled: ${actionData.disabled}`);
+                    // ✅ ENHANCED DEBUG: Log complete action data being sent
+                    this.logger.info(`📋 Complete action data being sent to ServiceNow:`, JSON.stringify(actionData, null, 2));
                     this.logger.info(`🎯 Attempting to create action ${i + 1} in catalog_ui_policy_action table...`);
                     const actionResponse = await this.client.createRecord('catalog_ui_policy_action', actionData);
                     if (actionResponse.success) {
@@ -1113,18 +1139,55 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                         const uiPolicyValue = createdAction.ui_policy;
                         const catalogVariableValue = createdAction.catalog_variable;
                         const catalogItemValue = createdAction.catalog_item;
-                        // Check ui_policy reference
-                        if (!uiPolicyValue || uiPolicyValue === '' || uiPolicyValue === '{}') {
+                        // Log the raw response to understand what ServiceNow returns
+                        this.logger.info(`📋 Raw action verification response:`, JSON.stringify(createdAction, null, 2));
+                        // Check ui_policy reference - ServiceNow might return it as an object
+                        let actualUiPolicyId = uiPolicyValue;
+                        if (typeof uiPolicyValue === 'object' && uiPolicyValue !== null) {
+                            actualUiPolicyId = uiPolicyValue.value || uiPolicyValue.sys_id || '';
+                            this.logger.info(`📝 ui_policy returned as object: ${JSON.stringify(uiPolicyValue)}`);
+                        }
+                        if (!actualUiPolicyId || actualUiPolicyId === '' || actualUiPolicyId === '{}') {
                             this.logger.error(`❌ CRITICAL: ui_policy field is EMPTY for action ${i + 1}!`);
-                            this.logger.error(`❌ Expected: ${policyId}, Got: ${uiPolicyValue}`);
-                            throw new Error(`Action ${i + 1} created but ui_policy field is empty - action will not work!`);
+                            this.logger.error(`❌ Expected policy ID: ${policyId}`);
+                            this.logger.error(`❌ Raw ui_policy value: ${JSON.stringify(uiPolicyValue)}`);
+                            this.logger.error(`❌ Parsed ui_policy value: ${actualUiPolicyId}`);
+                            this.logger.error(`❌ Action data sent:`, JSON.stringify(actionData, null, 2));
+                            this.logger.error(`❌ Full action verification response:`, JSON.stringify(createdAction, null, 2));
+                            // ✅ ENHANCED ERROR: Try to understand ServiceNow's response pattern
+                            this.logger.error(`ℹ️ DIAGNOSTIC INFO:`);
+                            this.logger.error(`   - Policy verified to exist: YES (${policyId})`);
+                            this.logger.error(`   - Action created successfully: YES (${createdActionId})`);
+                            this.logger.error(`   - ui_policy field type: ${typeof uiPolicyValue}`);
+                            this.logger.error(`   - ui_policy field value length: ${String(uiPolicyValue || '').length}`);
+                            this.logger.error(`   - All action fields:`, Object.keys(createdAction));
+                            // Check if it's a ServiceNow API timing issue
+                            this.logger.warn(`🔄 ATTEMPTING SECONDARY VERIFICATION (possible timing issue)...`);
+                            // Wait a moment and try again
+                            await new Promise(resolve => setTimeout(resolve, 1000));
+                            const secondVerification = await this.client.searchRecords('catalog_ui_policy_action', `sys_id=${createdActionId}`, 1);
+                            if (secondVerification.success && secondVerification.data.result.length > 0) {
+                                const reCheckedAction = secondVerification.data.result[0];
+                                const reCheckedUiPolicy = reCheckedAction.ui_policy;
+                                this.logger.error(`🔄 Secondary verification ui_policy: ${JSON.stringify(reCheckedUiPolicy)}`);
+                                if (reCheckedUiPolicy && reCheckedUiPolicy !== '' && reCheckedUiPolicy !== '{}') {
+                                    this.logger.warn(`⚠️ This was a timing issue - ui_policy populated after delay`);
+                                    // Continue with the re-checked value
+                                    return; // Skip the error throwing
+                                }
+                            }
+                            throw new Error(`Action ${i + 1} created but ui_policy field is empty - action will not work! This may be a ServiceNow API or table structure issue.`);
                         }
                         // For reference fields, ServiceNow might return an object - extract the value
                         const uiPolicySysId = typeof uiPolicyValue === 'object' && uiPolicyValue.value ?
                             uiPolicyValue.value : uiPolicyValue;
+                        this.logger.info(`✅ ui_policy field populated successfully: ${actualUiPolicyId}`);
                         if (uiPolicySysId !== policyId) {
                             this.logger.warn(`⚠️ ui_policy mismatch - Expected: ${policyId}, Got: ${uiPolicySysId}`);
                         }
+                        else {
+                            this.logger.info(`✅ ui_policy reference matches expected value`);
+                        }
                         // Check catalog_variable (should have IO: prefix)
                         if (!catalogVariableValue || catalogVariableValue === '') {
                             this.logger.error(`❌ CRITICAL: catalog_variable field is EMPTY for action ${i + 1}!`);
@@ -1166,27 +1229,27 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                     }
                 }
             }
-            // 🔍 FINAL VERIFICATION: Policy creation in sys_ui_policy table
-            this.logger.info('🔍 Final verification: Checking policy in sys_ui_policy table...');
-            const policyVerification = await this.client.searchRecords('sys_ui_policy', `sys_id=${policyId}`, 1);
+            // 🔍 FINAL VERIFICATION: Policy creation in catalog_ui_policy table
+            this.logger.info('🔍 Final verification: Checking policy in catalog_ui_policy table...');
+            const policyVerification = await this.client.searchRecords('catalog_ui_policy', `sys_id=${policyId}`, 1);
             if (!policyVerification.success || policyVerification.data.result.length === 0) {
-                this.logger.error('❌ POLICY VERIFICATION FAILED: Policy not found in sys_ui_policy table!');
-                throw new Error(`Policy creation verification failed - policy not found in sys_ui_policy table`);
+                this.logger.error('❌ POLICY VERIFICATION FAILED: Policy not found in catalog_ui_policy table!');
+                throw new Error(`Policy creation verification failed - policy not found in catalog_ui_policy table`);
             }
-            this.logger.info('✅ Policy verified in sys_ui_policy table');
+            this.logger.info('✅ Policy verified in catalog_ui_policy table');
             // Build comprehensive response
-            let responseText = `✅ UI Policy created successfully in sys_ui_policy table!
+            let responseText = `✅ Catalog UI Policy created successfully!
 
 📋 **${args.short_description}**
 🆔 Policy sys_id: ${policyId}
-📊 Table: sys_ui_policy (correct table for catalog UI policy actions)
-🎯 Target Table: sc_cat_item
+📊 Table: catalog_ui_policy (correct table for catalog actions)
+🎯 Catalog Item: ${args.cat_item}
 🔄 Active: ${args.active !== false ? 'Yes' : 'No'}
-⚡ On Load: ${args.on_load !== false ? 'Yes' : 'No'}
+⚡ Applies On: ${args.applies_on || 'true'}
 🔁 Reverse if False: ${args.reverse_if_false !== false ? 'Yes' : 'No'}
 
 🔍 **Verification Results:**
-✅ Policy record created in sys_ui_policy table
+✅ Policy record created in catalog_ui_policy table
 ✅ ${createdActions.length} actions created in catalog_ui_policy_action table`;
             if (conditionString) {
                 responseText += `\n\n📝 **Conditions:**\n${conditionString}`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.6.20",
-  "description": "COMPLETE CATALOG UI POLICY FIX - v3.6.20 implements Snow-Flow's complete analysis: proper parent-child table inheritance (sys_ui_policy_action → catalog_ui_policy_action), direct assignment for references, 'ignore' values for visible/mandatory/disabled, enhanced verification, IO: prefix validation. Based on extensive ServiceNow structure analysis.",
+  "version": "3.6.23",
+  "description": "CATALOG VARIABLE TABLE FIX - v3.6.23 fixes critical issue: catalog variables now created in correct table 'item_option_new' instead of wrong table 'sc_cat_item_option'. This ensures variables are actually visible and functional in catalog items.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {