snow-flow 3.6.21 → 3.6.24

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.24';
 }
 // Export a constant that uses the dynamic version
 exports.VERSION = getDynamicVersion();

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

@@ -319,7 +319,7 @@ class ServiceNowDeploymentMCP {
                                 enum: [
                                     'widget', 'portal_page', 'application', 'script', 'business_rule', 'table',
                                     'script_include', 'ui_page', 'client_script', 'ui_action', 'ui_policy',
-                                    'acl', 'field', 'workflow', 'flow', 'notification', 'scheduled_job'
+                                    'catalog_ui_policy', 'acl', 'field', 'workflow', 'flow', 'notification', 'scheduled_job'
                                 ],
                                 description: 'Type of artifact to deploy'
                             },
@@ -7448,6 +7448,8 @@ Use individual deployment tools like \`snow_deploy_${args.type}\` with manual co
                 return await this.deployApplication(scopedConfig);
             case 'xml_update_set':
                 return await this.deployXMLUpdateSet(scopedConfig);
+            case 'catalog_ui_policy':
+                return await this.deployCatalogUIPolicy(scopedConfig);
             default:
                 throw new Error(`Unsupported artifact type for unified deployment: ${type}`);
         }
@@ -7585,6 +7587,176 @@ Use individual deployment tools like \`snow_deploy_${args.type}\` with manual co
             throw new Error(`XML deployment failed: ${errorMsg}`);
         }
     }
+    /**
+     * Deploy Catalog UI Policy to ServiceNow
+     */
+    async deployCatalogUIPolicy(config) {
+        const { catalog_item, cat_item, catalog_conditions, short_description, applies_to = 'all', active = true, on_load = true, reverse_if_false = true, conditions = [], actions = [] } = config;
+        const catalogItemId = catalog_item || cat_item;
+        if (!catalogItemId) {
+            throw new Error('catalog_item or cat_item is required for catalog UI policy deployment');
+        }
+        if (!short_description) {
+            throw new Error('short_description is required for catalog UI policy deployment');
+        }
+        this.logger.info('🚀 Deploying Catalog UI Policy', {
+            catalogItem: catalogItemId,
+            description: short_description,
+            conditions: conditions.length,
+            actions: actions.length
+        });
+        try {
+            // If catalog_conditions is provided, convert it to conditions array
+            let policyConditions = conditions;
+            if (catalog_conditions && policyConditions.length === 0) {
+                // Parse catalog_conditions string like "employee_type=contractor"
+                const conditionParts = catalog_conditions.split('=');
+                if (conditionParts.length === 2) {
+                    policyConditions = [{
+                            catalog_variable: conditionParts[0].trim(),
+                            operation: 'is',
+                            value: conditionParts[1].trim(),
+                            and_or: 'AND'
+                        }];
+                    this.logger.info('📝 Converted catalog_conditions to conditions array:', policyConditions);
+                }
+            }
+            // Build policy data for catalog_ui_policy table
+            const policyData = {
+                cat_item: catalogItemId,
+                short_description: short_description,
+                applies_to: applies_to,
+                active: active,
+                on_load: on_load,
+                reverse_if_false: reverse_if_false,
+                order: 100
+            };
+            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) {
+                throw new Error(`Failed to create catalog UI policy: ${policyResponse.error}`);
+            }
+            const policyId = policyResponse.data.sys_id;
+            this.logger.info(`✅ Created policy with sys_id: ${policyId}`);
+            // Create conditions if provided
+            const createdConditions = [];
+            for (let i = 0; i < policyConditions.length; i++) {
+                const condition = policyConditions[i];
+                // Resolve variable name to sys_id if needed
+                let variableSysId = condition.catalog_variable;
+                if (condition.catalog_variable && !condition.catalog_variable.match(/^[a-f0-9]{32}$/)) {
+                    // Search for variable by name
+                    const variableSearch = await this.client.searchRecords('item_option_new', `cat_item=${catalogItemId}^name=${condition.catalog_variable}`, 1);
+                    if (variableSearch.success && variableSearch.data.result.length > 0) {
+                        variableSysId = variableSearch.data.result[0].sys_id;
+                        this.logger.info(`✅ Resolved variable '${condition.catalog_variable}' to sys_id: ${variableSysId}`);
+                    }
+                    else {
+                        this.logger.warn(`⚠️ Could not resolve variable '${condition.catalog_variable}', using as-is`);
+                    }
+                }
+                const conditionData = {
+                    ui_policy: policyId,
+                    catalog_variable: `IO:${variableSysId}`, // IO: prefix required
+                    operation: condition.operation || 'is',
+                    value: condition.value || '',
+                    and_or: condition.and_or || 'AND',
+                    order: (i + 1) * 100,
+                    active: true
+                };
+                this.logger.info(`🔗 Creating condition ${i + 1}:`, conditionData);
+                const conditionResponse = await this.client.createRecord('catalog_ui_policy_condition', conditionData);
+                if (conditionResponse.success) {
+                    createdConditions.push(conditionResponse.data.sys_id);
+                    this.logger.info(`✅ Created condition ${i + 1} with sys_id: ${conditionResponse.data.sys_id}`);
+                }
+                else {
+                    this.logger.error(`❌ Failed to create condition ${i + 1}:`, conditionResponse.error);
+                }
+            }
+            // Create actions if provided
+            const createdActions = [];
+            for (let i = 0; i < actions.length; i++) {
+                const action = actions[i];
+                // Resolve variable name to sys_id if needed
+                let actionVariableSysId = action.catalog_variable;
+                if (action.catalog_variable && !action.catalog_variable.match(/^[a-f0-9]{32}$/)) {
+                    const actionVariableSearch = await this.client.searchRecords('item_option_new', `cat_item=${catalogItemId}^name=${action.catalog_variable}`, 1);
+                    if (actionVariableSearch.success && actionVariableSearch.data.result.length > 0) {
+                        actionVariableSysId = actionVariableSearch.data.result[0].sys_id;
+                        this.logger.info(`✅ Resolved action variable '${action.catalog_variable}' to sys_id: ${actionVariableSysId}`);
+                    }
+                    else {
+                        this.logger.warn(`⚠️ Could not resolve action variable '${action.catalog_variable}', using as-is`);
+                    }
+                }
+                const actionData = {
+                    ui_policy: policyId,
+                    catalog_item: catalogItemId,
+                    catalog_variable: `IO:${actionVariableSysId}`, // IO: prefix required
+                    order: (i + 1) * 100,
+                    active: true
+                };
+                // Set action type fields based on action.type or individual properties
+                if (action.type === 'set_mandatory' || action.mandatory !== undefined) {
+                    actionData.mandatory = action.mandatory === true ? 'true' :
+                        action.mandatory === false ? 'false' : 'ignore';
+                }
+                else {
+                    actionData.mandatory = 'ignore';
+                }
+                if (action.type === 'set_visible' || action.visible !== undefined) {
+                    actionData.visible = action.visible === true ? 'true' :
+                        action.visible === false ? 'false' : 'ignore';
+                }
+                else {
+                    actionData.visible = 'ignore';
+                }
+                if (action.type === 'set_readonly' || action.readonly !== undefined) {
+                    actionData.disabled = action.readonly === true ? 'true' :
+                        action.readonly === false ? 'false' : 'ignore';
+                }
+                else {
+                    actionData.disabled = 'ignore';
+                }
+                if (action.value !== undefined && action.value !== null && action.value !== '') {
+                    actionData.value = String(action.value);
+                }
+                this.logger.info(`🎬 Creating action ${i + 1}:`, actionData);
+                const actionResponse = await this.client.createRecord('catalog_ui_policy_action', actionData);
+                if (actionResponse.success) {
+                    createdActions.push(actionResponse.data.sys_id);
+                    this.logger.info(`✅ Created action ${i + 1} with sys_id: ${actionResponse.data.sys_id}`);
+                }
+                else {
+                    this.logger.error(`❌ Failed to create action ${i + 1}:`, actionResponse.error);
+                }
+            }
+            return {
+                success: true,
+                policy_id: policyId,
+                conditions_created: createdConditions.length,
+                actions_created: createdActions.length,
+                message: `✅ Catalog UI Policy '${short_description}' deployed successfully`,
+                details: {
+                    policy_sys_id: policyId,
+                    catalog_item: catalogItemId,
+                    conditions: createdConditions,
+                    actions: createdActions,
+                    next_steps: [
+                        '1. Test the catalog item form to verify policy behavior',
+                        '2. Check that conditions trigger actions correctly',
+                        '3. Verify variable visibility/mandatory/readonly changes'
+                    ]
+                }
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logger.error('Catalog UI Policy deployment failed', { error: errorMsg, config });
+            throw new Error(`Catalog UI Policy deployment failed: ${errorMsg}`);
+        }
+    }
     /**
      * Check if error is permission-related
      */

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`);
@@ -1040,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) {
@@ -1071,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) {
@@ -1112,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}!`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.6.21",
-  "description": "CRITICAL TABLE FIX - v3.6.21 fixes fundamental issue: policies now created in catalog_ui_policy table (NOT sys_ui_policy!). Actions correctly reference catalog_ui_policy records. This matches ServiceNow's actual structure where catalog_ui_policy_action.ui_policy references catalog_ui_policy table, not sys_ui_policy.",
+  "version": "3.6.24",
+  "description": "CATALOG UI POLICY DEPLOYMENT SUPPORT - v3.6.24 adds catalog_ui_policy support to snow_deploy tool. You can now deploy catalog UI policies via unified deployment with automatic variable resolution, condition/action creation, and comprehensive error handling.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {