snow-flow 3.6.12 → 3.6.14

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

@@ -724,23 +724,53 @@ ${args.recurring_price && args.recurring_price !== '0' ? `🔄 Recurring: $${arg
      */
     async createCatalogVariable(args) {
         try {
-            this.logger.info('Creating catalog variable...');
+            this.logger.info('Creating catalog variable...', { name: args.name, cat_item: args.cat_item });
+            // Add ESSENTIAL missing fields that might be required
             const variableData = {
+                // Required fields
                 cat_item: args.cat_item,
                 name: args.name,
                 question_text: args.question_text,
-                type: args.type,
+                type: args.type || '1', // Default to string type
+                // Essential fields that were missing
+                active: true, // ✅ CRITICAL: Must be active
                 order: args.order || 100,
                 mandatory: args.mandatory || false,
+                // Display settings
+                display_type: args.display_type || 'normal',
+                // Values
                 default_value: args.default_value || '',
                 help_text: args.help_text || '',
+                // References and choices  
                 reference: args.reference || '',
-                choice_table: args.choice_table || ''
+                choice_table: args.choice_table || '',
+                // Security fields (might be required)
+                write_roles: args.write_roles || '',
+                read_roles: args.read_roles || '',
+                // Additional fields
+                example_text: args.example_text || '',
+                tooltip: args.tooltip || ''
             };
+            this.logger.info('🎯 Creating variable with payload:', variableData);
             const response = await this.client.createRecord('item_option_new', variableData);
             if (!response.success) {
+                this.logger.error('❌ Variable creation failed:', {
+                    error: response.error,
+                    payload: variableData,
+                    status: response.status
+                });
                 throw new Error(`Failed to create catalog variable: ${response.error}`);
             }
+            const createdSysId = response.data.sys_id;
+            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('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`);
+            }
+            this.logger.info('✅ Variable verified in database');
             return {
                 content: [{
                         type: 'text',
@@ -792,7 +822,14 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
             };
             // Build condition string from conditions array
             let conditionString = '';
+            this.logger.info('Checking conditions parameter:', {
+                hasConditions: !!args.conditions,
+                isArray: Array.isArray(args.conditions),
+                length: args.conditions ? args.conditions.length : 0,
+                conditionsData: args.conditions
+            });
             if (args.conditions && Array.isArray(args.conditions)) {
+                this.logger.info(`🎯 Building conditions string from ${args.conditions.length} conditions...`);
                 const conditionParts = [];
                 for (const condition of args.conditions) {
                     // Resolve variable name to sys_id
@@ -840,8 +877,9 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                     }
                     conditionParts.push(conditionPart);
                 }
-                // Join all conditions
-                conditionString = conditionParts.join('');
+                // Join all conditions with ^ separator (ServiceNow query format)
+                conditionString = conditionParts.join('^');
+                this.logger.info(`✅ Built conditions string: "${conditionString}"`);
             }
             // Step 1: Create main catalog UI policy record with embedded conditions
             const policyData = {
@@ -856,59 +894,103 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                 script_true: args.script_true || '',
                 script_false: args.script_false || ''
             };
+            this.logger.info('🎯 Creating main policy 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}`);
             }
             const policyId = policyResponse.data.sys_id;
-            this.logger.info(`Created main policy with sys_id: ${policyId}`);
+            this.logger.info(`✅ Created main policy with sys_id: ${policyId}`);
             const createdActions = [];
             // Step 2: Create action records (dit werkt wel met aparte tabel)
+            this.logger.info('Checking actions parameter:', {
+                hasActions: !!args.actions,
+                isArray: Array.isArray(args.actions),
+                length: args.actions ? args.actions.length : 0,
+                actionsData: args.actions
+            });
             if (args.actions && Array.isArray(args.actions)) {
-                this.logger.info(`Creating ${args.actions.length} action records...`);
+                this.logger.info(`🎯 Starting to create ${args.actions.length} action records...`);
                 for (let i = 0; i < args.actions.length; i++) {
                     const action = args.actions[i];
                     // 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}`);
                     // Actions structuur in ServiceNow:
                     // - catalog_ui_policy_action.catalog_variable -> item_option_new (variable)
                     // - item_option_new.cat_item -> sc_cat_item (catalog item)
                     // - catalog_ui_policy.catalog_item -> sc_cat_item (catalog item)
                     // Mogelijk is er toch een ui_policy veld, maar het lijkt niet verplicht
+                    // MINIMAAL: Probeer eerst alleen de essentiële velden
                     const actionData = {
-                        // Primaire koppeling: naar de variable
-                        catalog_variable: variableId, // Verplicht: koppeling naar variable
-                        // Mogelijk ook een policy koppeling (als het veld bestaat)
-                        ui_policy: policyId, // Probeer dit ook, kan optioneel zijn
-                        // Action settings - gebruik strings zoals ServiceNow verwacht
-                        mandatory: action.mandatory === true ? 'true' : action.mandatory === false ? 'false' : 'ignore',
-                        visible: action.visible === false ? 'false' : action.visible === true ? 'true' : 'ignore',
-                        disabled: action.readonly === true ? 'true' : action.readonly === false ? 'false' : 'ignore',
-                        // Waarde velden (voor set_value acties)
-                        value: action.value || '',
-                        // Metadata
-                        order: (i + 1) * 100,
-                        active: true
+                        // Hoofdkoppeling: naar de variable (dit MOET kloppen)
+                        catalog_variable: variableId
                     };
-                    this.logger.info(`Attempting to create action ${i + 1}:`, actionData);
+                    // 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;
+                    }
+                    // Voeg alleen GEDEFINIEERDE action properties toe 
+                    if (action.mandatory !== undefined) {
+                        actionData.mandatory = action.mandatory === true ? 'true' : action.mandatory === false ? 'false' : 'ignore';
+                    }
+                    if (action.visible !== undefined) {
+                        actionData.visible = action.visible === false ? 'false' : action.visible === true ? 'true' : 'ignore';
+                    }
+                    if (action.readonly !== undefined) {
+                        actionData.disabled = action.readonly === true ? 'true' : action.readonly === false ? 'false' : 'ignore';
+                    }
+                    if (action.value) {
+                        actionData.value = action.value;
+                    }
+                    // Basis metadata
+                    actionData.order = (i + 1) * 100;
+                    actionData.active = true;
+                    this.logger.info(`🎯 Attempting to create action ${i + 1}:`, actionData);
                     const actionResponse = await this.client.createRecord('catalog_ui_policy_action', actionData);
                     if (actionResponse.success) {
+                        const createdActionId = actionResponse.data.sys_id;
+                        this.logger.info(`✅ Created action with sys_id: ${createdActionId}`);
+                        // 🔍 VERIFICATION: Check if action was actually created
+                        this.logger.info(`🔍 Verifying action ${i + 1} creation...`);
+                        const actionVerification = await this.client.searchRecords('catalog_ui_policy_action', `sys_id=${createdActionId}`, 1);
+                        if (!actionVerification.success || actionVerification.data.result.length === 0) {
+                            this.logger.error('❌ ACTION VERIFICATION FAILED: Action not found after creation!');
+                            throw new Error(`Action creation verification failed - action ${i + 1} not found in database`);
+                        }
+                        this.logger.info(`✅ Action ${i + 1} verified in database`);
                         createdActions.push({
-                            sys_id: actionResponse.data.sys_id,
+                            sys_id: createdActionId,
                             variable: action.catalog_variable,
                             details: this.formatActionDetails(action)
                         });
-                        this.logger.info(`✅ Created action: ${action.type || 'default'} for ${action.catalog_variable}`);
                     }
                     else {
                         const errorMsg = `❌ Failed to create action ${i + 1}: ${actionResponse.error || 'Unknown error'}`;
                         this.logger.error(errorMsg);
-                        this.logger.error('Action data was:', actionData);
+                        this.logger.error('❌ Action data was:', actionData);
+                        this.logger.error('❌ Response details:', {
+                            status: actionResponse.status,
+                            headers: actionResponse.headers,
+                            data: actionResponse.data
+                        });
                         // BELANGRIJK: Gooi een error zodat de gebruiker weet dat het faalt!
                         throw new Error(errorMsg);
                     }
                 }
             }
+            // 🔍 FINAL VERIFICATION: Policy creation
+            this.logger.info('🔍 Final verification: Checking policy in database...');
+            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 after creation!');
+                throw new Error(`Policy creation verification failed - policy not found in database`);
+            }
+            this.logger.info('✅ Policy verified in database');
             // Build comprehensive response
             let responseText = `✅ Catalog UI Policy created successfully!
 
@@ -917,7 +999,11 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
 🎯 Applies to: ${args.applies_to || 'item'}
 🔄 Active: ${args.active !== false ? 'Yes' : 'No'}
 ⚡ On Load: ${args.on_load !== false ? 'Yes' : 'No'}
-🔁 Reverse if False: ${args.reverse_if_false !== false ? 'Yes' : 'No'}`;
+🔁 Reverse if False: ${args.reverse_if_false !== false ? 'Yes' : 'No'}
+
+🔍 **Verification Results:**
+✅ Policy record created and verified
+✅ ${createdActions.length} actions created and verified`;
             if (conditionString) {
                 responseText += `\n\n📝 **Conditions:**\n${conditionString}`;
             }
@@ -940,27 +1026,6 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
             throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create catalog UI policy: ${error}`);
         }
     }
-    /**
-     * Helper function to determine action type based on provided fields
-     * Note: ServiceNow might not use 'type' field, actions are determined by field values
-     */
-    determineActionType(action) {
-        // ServiceNow bepaalt het type waarschijnlijk op basis van de velden zelf
-        // Dit is alleen voor logging/display
-        if (action.value !== undefined && action.value !== '') {
-            return 'set_value';
-        }
-        if (action.mandatory === true) {
-            return 'set_mandatory';
-        }
-        if (action.visible === false) {
-            return 'set_hidden';
-        }
-        if (action.readonly === true) {
-            return 'set_readonly';
-        }
-        return 'default';
-    }
     /**
      * Helper function to format action details for display
      */
@@ -1148,10 +1213,36 @@ ${args.special_instructions ? `📝 Instructions: ${args.special_instructions}`
      */
     async getCatalogItemDetails(args) {
         try {
-            this.logger.info('Getting catalog item details...');
-            const itemResponse = await this.client.getRecord('sc_cat_item', args.sys_id);
+            this.logger.info('Getting catalog item details...', { sys_id: args.sys_id });
+            // 🔍 DEBUGGING: Try different methods to find the item
+            this.logger.info('🔍 Step 1: Trying getRecord method...');
+            let itemResponse = await this.client.getRecord('sc_cat_item', args.sys_id);
             if (!itemResponse.success) {
-                throw new Error('Catalog item not found');
+                this.logger.warn('❌ getRecord failed, trying searchRecords as fallback...');
+                this.logger.warn('getRecord error:', itemResponse.error);
+                // Fallback: try searchRecords method
+                itemResponse = await this.client.searchRecords('sc_cat_item', `sys_id=${args.sys_id}`, 1);
+                if (!itemResponse.success || itemResponse.data.result.length === 0) {
+                    this.logger.error('❌ Both getRecord and searchRecords failed');
+                    this.logger.error('searchRecords error:', itemResponse.error);
+                    // Final fallback: try to query with different parameters
+                    const queryResponse = await this.client.queryTable('sc_cat_item', `sys_id=${args.sys_id}`, 1);
+                    if (queryResponse.success && queryResponse.data.result.length > 0) {
+                        this.logger.info('✅ Found item using queryTable fallback');
+                        itemResponse = { success: true, data: queryResponse.data.result[0] };
+                    }
+                    else {
+                        this.logger.error('❌ All methods failed to find catalog item');
+                        throw new Error(`Catalog item not found with sys_id: ${args.sys_id}. Tried getRecord, searchRecords, and queryTable.`);
+                    }
+                }
+                else {
+                    this.logger.info('✅ Found item using searchRecords fallback');
+                    itemResponse = { success: true, data: itemResponse.data.result[0] };
+                }
+            }
+            else {
+                this.logger.info('✅ Found item using getRecord');
             }
             const item = itemResponse.data;
             let details = `🛍️ **${item.name}**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.6.12",
-  "description": "COMPLETE UI POLICY FIX - v3.6.12 fixes both policy and actions. Policy uses catalog_item + applies_to fields. Actions link to catalog_variable. Conditions stored as query string. Based on actual ServiceNow table structure.",
+  "version": "3.6.14",
+  "description": "COMPREHENSIVE CATALOG FIXES - v3.6.14 fixes ALL catalog tools based on user feedback. snow_create_catalog_variable: added missing essential fields (active, display_type, security). snow_get_catalog_item_details: 3-method fallback system. snow_create_catalog_ui_policy: verification after creation. All tools now have extensive debugging and verification.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {