snow-flow 3.5.9 → 3.5.10

package/dist/mcp/servicenow-local-development-mcp.d.ts

@@ -21,6 +21,7 @@ export declare class ServiceNowLocalDevelopmentMCP extends EnhancedBaseMCPServer
     private validateArtifactCoherence;
     private syncCleanup;
     private convertToES5;
+    private debugWidgetFetch;
     private pullWidget;
     private pushWidget;
 }

package/dist/mcp/servicenow-local-development-mcp.js

@@ -143,6 +143,20 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
                         required: ['code']
                     }
                 },
+                {
+                    name: 'snow_debug_widget_fetch',
+                    description: 'Debug widget fetching to diagnose API issues',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: {
+                                type: 'string',
+                                description: 'Widget sys_id to debug'
+                            }
+                        },
+                        required: ['sys_id']
+                    }
+                },
                 // Legacy compatibility tools
                 {
                     name: 'snow_pull_widget',
@@ -201,6 +215,9 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
                     case 'snow_convert_to_es5':
                         result = await this.convertToES5(args);
                         break;
+                    case 'snow_debug_widget_fetch':
+                        result = await this.debugWidgetFetch(args);
+                        break;
                     // Legacy compatibility
                     case 'snow_pull_widget':
                         result = await this.pullWidget(args);
@@ -412,6 +429,58 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
             ]
         };
     }
+    async debugWidgetFetch(args) {
+        const { sys_id } = args;
+        try {
+            const debugResults = await this.syncManager['smartFetcher'].debugFetchWidget(sys_id);
+            let summaryText = `🔍 Debug Results for Widget ${sys_id}\n\n`;
+            // Check which methods worked
+            const methods = ['searchRecords', 'getRecord', 'searchRecordsWithFields'];
+            for (const method of methods) {
+                if (debugResults[method]) {
+                    const widget = debugResults[method];
+                    summaryText += `✅ ${method}:\n`;
+                    summaryText += `  - Fields: ${Object.keys(widget).length}\n`;
+                    summaryText += `  - Has script: ${!!widget.script}\n`;
+                    summaryText += `  - Has client_script: ${!!widget.client_script}\n`;
+                    summaryText += `  - Has template: ${!!widget.template}\n`;
+                    summaryText += `  - Script size: ${widget.script?.length || 0} chars\n`;
+                    summaryText += `  - Client script size: ${widget.client_script?.length || 0} chars\n`;
+                    summaryText += `  - Template size: ${widget.template?.length || 0} chars\n\n`;
+                }
+                else {
+                    summaryText += `❌ ${method}: Failed\n\n`;
+                }
+            }
+            // Recommend best approach
+            const workingMethods = methods.filter(m => debugResults[m]);
+            if (workingMethods.length > 0) {
+                summaryText += `\n📊 Recommendation: Use ${workingMethods[0]} for fetching this widget.`;
+            }
+            else {
+                summaryText += `\n⚠️ All fetch methods failed. There may be an authentication or permission issue.`;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: summaryText
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Debug failed: ${errorMessage}`
+                    }
+                ]
+            };
+        }
+    }
     // Legacy compatibility methods
     async pullWidget(args) {
         return this.pullArtifact({ ...args, table: 'sp_widget' });

package/dist/utils/artifact-local-sync.js

@@ -52,24 +52,29 @@ class ArtifactLocalSync {
         this.artifacts = new Map();
         this.client = client;
         this.smartFetcher = new smart_field_fetcher_js_1.SmartFieldFetcher(client);
+        // Version check for debugging
+        console.log(`🔧 ArtifactLocalSync v3.5.10 initializing...`);
         // Use custom directory, environment variable, or default to current project's servicenow folder
         if (customBaseDir) {
             this.baseDir = customBaseDir;
+            console.log(`  📍 Using custom directory: ${customBaseDir}`);
         }
         else if (process.env.SNOW_FLOW_ARTIFACTS_DIR) {
             this.baseDir = process.env.SNOW_FLOW_ARTIFACTS_DIR;
+            console.log(`  📍 Using environment variable directory: ${this.baseDir}`);
         }
         else {
             // Default to 'servicenow' folder in current working directory
             this.baseDir = path.join(process.cwd(), 'servicenow');
+            console.log(`  📍 Using project directory: ${this.baseDir}`);
         }
         // Create base directory if it doesn't exist
         if (!fs.existsSync(this.baseDir)) {
             fs.mkdirSync(this.baseDir, { recursive: true });
-            console.log(`📁 Created ServiceNow artifacts directory: ${this.baseDir}`);
+            console.log(`  ✅ Created ServiceNow artifacts directory`);
         }
         else {
-            console.log(`📁 Using ServiceNow artifacts directory: ${this.baseDir}`);
+            console.log(`  ✅ Directory exists`);
         }
         // Create .gitignore if it doesn't exist to optionally exclude from version control
         const gitignorePath = path.join(this.baseDir, '.gitignore');

package/dist/utils/servicenow-client-with-tracking.js

@@ -46,7 +46,7 @@ class ServiceNowClientWithTracking extends servicenow_client_js_1.ServiceNowClie
             // Estimate tokens based on fields requested
             const fieldCount = fields.length;
             const estimatedTokens = Math.min(fieldCount * 100, 1000); // Rough estimate
-            this.mcpLogger.trackTokens(estimatedTokens, 0);
+            this.mcpLogger.addTokens(estimatedTokens, 0);
             if (result?.data?.result?.length > 0) {
                 this.mcpLogger.info(`Found ${result.data.result.length} records with ${fieldCount} fields`);
             }

package/dist/utils/smart-field-fetcher.d.ts

@@ -52,6 +52,10 @@ export declare class SmartFieldFetcher {
      * Search within fields using GlideRecord queries
      */
     searchInField(table: string, field: string, searchTerm: string, additionalQuery?: string): Promise<any[]>;
+    /**
+     * Debug method to directly test API calls
+     */
+    debugFetchWidget(sys_id: string): Promise<any>;
     /**
      * Get smart fetch strategy based on table - NOW USES ARTIFACT REGISTRY!
      */

package/dist/utils/smart-field-fetcher.js

@@ -163,8 +163,8 @@ class SmartFieldFetcher {
         try {
             // Try to get all fields at once
             const response = await this.client.searchRecords('sp_widget', `sys_id=${sys_id}`, 1);
-            if (response && response.result && response.result.length > 0) {
-                const widgetData = response.result[0];
+            if (response && response.success && response.data && response.data.result && response.data.result.length > 0) {
+                const widgetData = response.data.result[0];
                 console.log(`✅ Successfully fetched complete widget`);
                 // Organize into field groups for better context
                 for (const group of WIDGET_FIELD_GROUPS) {
@@ -184,68 +184,72 @@ class SmartFieldFetcher {
                 Object.assign(results, widgetData);
             }
             else {
-                throw new Error('Widget not found');
+                throw new Error('Widget not found or no data returned');
             }
         }
         catch (error) {
             console.log(`⚠️ Complete fetch failed: ${error.message}`);
-            console.log(`🔄 Switching to field-by-field fetching...`);
-            // Fall back to fetching fields per group or individually
-            for (const group of WIDGET_FIELD_GROUPS) {
-                console.log(`📦 Fetching ${group.groupName}: ${group.description}`);
-                try {
-                    // Try to fetch all fields in this group at once
-                    const groupResponse = await this.client.searchRecordsWithFields('sp_widget', `sys_id=${sys_id}`, group.fields, 1);
-                    if (groupResponse && groupResponse.success && groupResponse.data && groupResponse.data.result && groupResponse.data.result.length > 0) {
-                        const groupData = groupResponse.data.result[0];
-                        console.log(`  ✅ Successfully fetched ${group.groupName}`);
+            console.log(`🔄 Switching to more robust fetching approach...`);
+            // First, get the widget with minimal fields to ensure it exists
+            try {
+                const basicResponse = await this.client.searchRecords('sp_widget', `sys_id=${sys_id}`, 1);
+                if (!basicResponse || !basicResponse.success || !basicResponse.data || !basicResponse.data.result || basicResponse.data.result.length === 0) {
+                    throw new Error(`Widget with sys_id ${sys_id} not found`);
+                }
+                // Widget exists, now get it via getRecord which might handle large fields better
+                const widgetData = basicResponse.data.result[0];
+                // Store what we got
+                if (widgetData) {
+                    // Add all available fields to results
+                    Object.assign(results, widgetData);
+                    // Organize into field groups
+                    for (const group of WIDGET_FIELD_GROUPS) {
+                        const groupData = {};
+                        for (const fieldName of group.fields) {
+                            if (widgetData[fieldName] !== undefined) {
+                                groupData[fieldName] = widgetData[fieldName];
+                            }
+                        }
                         results._field_groups[group.groupName] = {
                             data: groupData,
                             description: group.description,
                             fields: group.fields
                         };
-                        // Add to flat structure
-                        Object.assign(results, groupData);
-                    }
-                    else {
-                        throw new Error('No data returned for group');
                     }
+                    // Log what we got
+                    console.log(`📊 Retrieved widget fields:`);
+                    console.log(`  - name: ${widgetData.name || 'N/A'}`);
+                    console.log(`  - template: ${widgetData.template ? widgetData.template.length + ' chars' : 'empty'}`);
+                    console.log(`  - script: ${widgetData.script ? widgetData.script.length + ' chars' : 'empty'}`);
+                    console.log(`  - client_script: ${widgetData.client_script ? widgetData.client_script.length + ' chars' : 'empty'}`);
+                    console.log(`  - css: ${widgetData.css ? widgetData.css.length + ' chars' : 'empty'}`);
                 }
-                catch (groupError) {
-                    console.log(`  ⚠️ Group ${group.groupName} failed, fetching fields individually...`);
-                    // If group fails, fetch fields one by one
-                    const groupData = {};
-                    for (const fieldName of group.fields) {
-                        console.log(`    📄 Fetching field: ${fieldName}`);
-                        try {
-                            // Fetch just this single field
-                            const fieldResponse = await this.client.searchRecordsWithFields('sp_widget', `sys_id=${sys_id}`, [fieldName], 1);
-                            if (fieldResponse && fieldResponse.success && fieldResponse.data && fieldResponse.data.result && fieldResponse.data.result.length > 0) {
-                                const fieldValue = fieldResponse.data.result[0][fieldName];
-                                if (fieldValue !== undefined && fieldValue !== null) {
-                                    groupData[fieldName] = fieldValue;
-                                    results[fieldName] = fieldValue; // Also add to flat structure
-                                    console.log(`      ✅ Got ${fieldName} (${typeof fieldValue === 'string' ? fieldValue.length : 0} chars)`);
-                                }
-                                else {
-                                    groupData[fieldName] = '';
-                                    console.log(`      ⚠️ ${fieldName} is empty`);
-                                }
-                            }
-                        }
-                        catch (fieldError) {
-                            console.log(`      ❌ Failed to fetch ${fieldName}: ${fieldError.message}`);
-                            groupData[fieldName] = ''; // Empty string for failed fields
-                        }
+                // If critical fields are missing, try alternative approach
+                if (!widgetData.script && !widgetData.client_script && !widgetData.template) {
+                    console.log(`⚠️ Critical fields missing, trying direct API call...`);
+                    // Try using getRecord instead of searchRecords
+                    const directResponse = await this.client.getRecord('sp_widget', sys_id);
+                    if (directResponse && directResponse.success && directResponse.data && directResponse.data.result) {
+                        const directData = directResponse.data.result;
+                        // Merge any new data we got
+                        Object.assign(results, directData);
+                        console.log(`📊 Direct API retrieved:`);
+                        console.log(`  - template: ${directData.template ? directData.template.length + ' chars' : 'empty'}`);
+                        console.log(`  - script: ${directData.script ? directData.script.length + ' chars' : 'empty'}`);
+                        console.log(`  - client_script: ${directData.client_script ? directData.client_script.length + ' chars' : 'empty'}`);
                     }
-                    results._field_groups[group.groupName] = {
-                        data: groupData,
-                        description: group.description,
-                        fields: group.fields,
-                        _fetched_individually: true
-                    };
                 }
             }
+            catch (fallbackError) {
+                console.log(`❌ All fetch attempts failed: ${fallbackError.message}`);
+                // At least return basic structure with sys_id
+                results.sys_id = sys_id;
+                results.name = 'Unknown Widget';
+                results.template = '';
+                results.script = '';
+                results.client_script = '';
+                results.css = '';
+            }
             // Make sure we have at least the sys_id
             if (!results.sys_id) {
                 results.sys_id = sys_id;
@@ -350,6 +354,69 @@ class SmartFieldFetcher {
             return [];
         }
     }
+    /**
+     * Debug method to directly test API calls
+     */
+    async debugFetchWidget(sys_id) {
+        console.log(`\n🔍 DEBUG: Testing different fetch approaches for widget ${sys_id}\n`);
+        const results = {};
+        // Test 1: Basic searchRecords
+        try {
+            console.log(`Test 1: searchRecords...`);
+            const test1 = await this.client.searchRecords('sp_widget', `sys_id=${sys_id}`, 1);
+            console.log(`  - Response structure: success=${test1?.success}, has data=${!!test1?.data}, has result=${!!test1?.data?.result}`);
+            if (test1?.data?.result?.[0]) {
+                const widget = test1.data.result[0];
+                console.log(`  - Fields received: ${Object.keys(widget).join(', ')}`);
+                console.log(`  - Script length: ${widget.script?.length || 0}`);
+                console.log(`  - Client script length: ${widget.client_script?.length || 0}`);
+                console.log(`  - Template length: ${widget.template?.length || 0}`);
+                results.searchRecords = widget;
+            }
+        }
+        catch (e) {
+            console.log(`  ❌ Error: ${e.message}`);
+        }
+        // Test 2: getRecord
+        try {
+            console.log(`Test 2: getRecord...`);
+            const test2 = await this.client.getRecord('sp_widget', sys_id);
+            console.log(`  - Response structure: success=${test2?.success}, has data=${!!test2?.data}, has result=${!!test2?.data?.result}`);
+            if (test2?.data?.result) {
+                const widget = test2.data.result;
+                console.log(`  - Fields received: ${Object.keys(widget).join(', ')}`);
+                console.log(`  - Script length: ${widget.script?.length || 0}`);
+                console.log(`  - Client script length: ${widget.client_script?.length || 0}`);
+                console.log(`  - Template length: ${widget.template?.length || 0}`);
+                results.getRecord = widget;
+            }
+        }
+        catch (e) {
+            console.log(`  ❌ Error: ${e.message}`);
+        }
+        // Test 3: searchRecordsWithFields
+        try {
+            console.log(`Test 3: searchRecordsWithFields with specific fields...`);
+            const test3 = await this.client.searchRecordsWithFields('sp_widget', `sys_id=${sys_id}`, ['name', 'script', 'client_script', 'template', 'css'], 1);
+            console.log(`  - Response structure: success=${test3?.success}, has data=${!!test3?.data}, has result=${!!test3?.data?.result}`);
+            if (test3?.data?.result?.[0]) {
+                const widget = test3.data.result[0];
+                console.log(`  - Fields received: ${Object.keys(widget).join(', ')}`);
+                console.log(`  - Script length: ${widget.script?.length || 0}`);
+                console.log(`  - Client script length: ${widget.client_script?.length || 0}`);
+                console.log(`  - Template length: ${widget.template?.length || 0}`);
+                results.searchRecordsWithFields = widget;
+            }
+        }
+        catch (e) {
+            console.log(`  ❌ Error: ${e.message}`);
+        }
+        console.log(`\n📊 Debug Results Summary:`);
+        console.log(`  - searchRecords got: ${results.searchRecords ? Object.keys(results.searchRecords).length + ' fields' : 'failed'}`);
+        console.log(`  - getRecord got: ${results.getRecord ? Object.keys(results.getRecord).length + ' fields' : 'failed'}`);
+        console.log(`  - searchRecordsWithFields got: ${results.searchRecordsWithFields ? Object.keys(results.searchRecordsWithFields).length + ' fields' : 'failed'}`);
+        return results;
+    }
     /**
      * Get smart fetch strategy based on table - NOW USES ARTIFACT REGISTRY!
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "3.5.9",
+  "version": "3.5.10",
   "description": "ServiceNow development framework with MCP server integration. Executes background scripts using ES5 JavaScript only (ServiceNow Rhino engine requirement). Provides 18 MCP servers including local development sync for editing ServiceNow artifacts with Claude Code native tools, widget deployment with coherence validation, table operations, script execution, machine learning, advanced features, and comprehensive platform management.",
   "main": "dist/index.js",
   "type": "commonjs",