snow-flow 3.5.8 → 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.d.ts

@@ -37,7 +37,7 @@ export declare class ArtifactLocalSync {
     private artifacts;
     private client;
     private smartFetcher;
-    constructor(client: ServiceNowClient);
+    constructor(client: ServiceNowClient, customBaseDir?: string);
     /**
      * DYNAMIC pull artifact from ServiceNow using artifact registry
      * Works with ANY artifact type defined in the registry!

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

@@ -45,20 +45,76 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArtifactLocalSync = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
 const smart_field_fetcher_js_1 = require("./smart-field-fetcher.js");
 const artifact_registry_1 = require("./artifact-sync/artifact-registry");
 class ArtifactLocalSync {
-    constructor(client) {
+    constructor(client, customBaseDir) {
         this.artifacts = new Map();
         this.client = client;
         this.smartFetcher = new smart_field_fetcher_js_1.SmartFieldFetcher(client);
-        // Create base directory for Snow-Flow artifacts
-        this.baseDir = path.join(os.tmpdir(), 'snow-flow-artifacts');
+        // 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`);
+        }
+        else {
+            console.log(`  ✅ Directory exists`);
+        }
+        // Create .gitignore if it doesn't exist to optionally exclude from version control
+        const gitignorePath = path.join(this.baseDir, '.gitignore');
+        if (!fs.existsSync(gitignorePath)) {
+            fs.writeFileSync(gitignorePath, '# ServiceNow Artifacts\n' +
+                '# Uncomment the following lines to exclude from version control:\n' +
+                '# *\n' +
+                '# !.gitignore\n' +
+                '# !README.md\n');
+        }
+        // Create README if it doesn't exist
+        const readmePath = path.join(this.baseDir, 'README.md');
+        if (!fs.existsSync(readmePath)) {
+            fs.writeFileSync(readmePath, '# ServiceNow Artifacts Directory\n\n' +
+                'This directory contains ServiceNow artifacts synchronized from your instance for local development.\n\n' +
+                '## Structure\n\n' +
+                '```\n' +
+                'servicenow/\n' +
+                '├── widgets/          # Service Portal widgets\n' +
+                '├── script_includes/  # Script Includes\n' +
+                '├── business_rules/   # Business Rules\n' +
+                '├── flows/           # Flow Designer flows\n' +
+                '├── ui_pages/        # UI Pages\n' +
+                '└── ...              # Other artifact types\n' +
+                '```\n\n' +
+                '## Workflow\n\n' +
+                '1. **Pull artifacts**: `snow_pull_artifact` downloads artifacts here\n' +
+                '2. **Edit locally**: Use your IDE/editor to modify files\n' +
+                '3. **Push changes**: `snow_push_artifact` syncs changes back to ServiceNow\n' +
+                '4. **Clean up**: `snow_sync_cleanup` removes local files after sync\n\n' +
+                '## Version Control\n\n' +
+                'You can choose to:\n' +
+                '- **Track changes**: Keep artifacts in git for version history\n' +
+                '- **Ignore artifacts**: Edit `.gitignore` to exclude from git\n\n' +
+                '## Configuration\n\n' +
+                'Set custom location with environment variable:\n' +
+                '```bash\n' +
+                'export SNOW_FLOW_ARTIFACTS_DIR=/path/to/artifacts\n' +
+                '```\n');
         }
-        console.log(`📁 Snow-Flow local sync directory: ${this.baseDir}`);
     }
     /**
      * DYNAMIC pull artifact from ServiceNow using artifact registry
@@ -143,8 +199,11 @@ class ArtifactLocalSync {
             artifactConfig: config
         };
         this.artifacts.set(sys_id, artifact);
+        // Show relative path if in project directory
+        const relativePath = path.relative(process.cwd(), artifactPath);
+        const displayPath = relativePath.startsWith('..') ? artifactPath : relativePath;
         console.log(`✅ ${config.displayName} synced to local files:`);
-        console.log(`📁 Location: ${artifactPath}`);
+        console.log(`📁 Location: ${displayPath}`);
         console.log(`📄 Files created:`);
         files.forEach(f => console.log(`   - ${f.filename} (${f.type})`));
         console.log(`\n💡 Claude Code can now use its native tools on these files!`);
@@ -158,77 +217,6 @@ class ArtifactLocalSync {
      */
     async pullWidget(sys_id) {
         return this.pullArtifact('sp_widget', sys_id);
-        console.log(`\n🔄 Pulling widget ${sys_id} to local files...`);
-        // Fetch widget with smart chunking
-        const widget = await this.smartFetcher.fetchWidget(sys_id);
-        // Create local directory structure
-        const widgetName = this.sanitizeFilename(widget.name || `widget_${sys_id}`);
-        const widgetPath = path.join(this.baseDir, 'widgets', widgetName);
-        // Clean up any existing files
-        if (fs.existsSync(widgetPath)) {
-            fs.rmSync(widgetPath, { recursive: true });
-        }
-        fs.mkdirSync(widgetPath, { recursive: true });
-        // Create local files for each widget component
-        const files = [];
-        // 1. HTML Template
-        if (widget.template) {
-            const htmlFile = this.createLocalFile(widgetPath, `${widgetName}.html`, widget.template, 'template', 'html', '<!-- ServiceNow Widget Template -->\n<!-- Widget: ' + widget.name + ' -->\n<!-- Bindings: {{data.x}} from server, ng-click calls client methods -->\n\n');
-            files.push(htmlFile);
-        }
-        // 2. Server Script (ES5)
-        if (widget.script) {
-            const serverFile = this.createLocalFile(widgetPath, `${widgetName}.server.js`, widget.script, 'script', 'js', '/**\n * ServiceNow Widget Server Script (ES5 ONLY!)\n * Widget: ' + widget.name + '\n * \n * Available objects:\n * - data: Object to send to client\n * - input: Data from client\n * - options: Widget instance options\n * - gs: GlideSystem\n * - $sp: Service Portal API\n */\n\n(function() {\n', '\n})();');
-            files.push(serverFile);
-        }
-        // 3. Client Script (AngularJS)
-        if (widget.client_script) {
-            const clientFile = this.createLocalFile(widgetPath, `${widgetName}.client.js`, widget.client_script, 'client_script', 'js', '/**\n * ServiceNow Widget Client Controller (AngularJS)\n * Widget: ' + widget.name + '\n * \n * Available objects:\n * - c: Widget controller (this)\n * - c.data: Data from server\n * - c.server: Server communication\n * - $scope: Angular scope\n */\n\nfunction(');
-            files.push(clientFile);
-        }
-        // 4. CSS
-        if (widget.css) {
-            const cssFile = this.createLocalFile(widgetPath, `${widgetName}.css`, widget.css, 'css', 'css', '/* ServiceNow Widget Styles */\n/* Widget: ' + widget.name + ' */\n/* Prefix classes to avoid conflicts */\n\n');
-            files.push(cssFile);
-        }
-        // 5. Widget Configuration (JSON)
-        const config = {
-            sys_id: widget.sys_id,
-            name: widget.name,
-            title: widget.title,
-            option_schema: widget.option_schema,
-            data_table: widget.data_table,
-            roles: widget.roles,
-            public: widget.public,
-            _coherence_hints: widget._coherence_hints || []
-        };
-        const configFile = this.createLocalFile(widgetPath, `${widgetName}.config.json`, JSON.stringify(config, null, 2), 'metadata', 'json');
-        files.push(configFile);
-        // 6. README with context
-        const readmeContent = this.generateWidgetReadme(widget, files);
-        const readmeFile = this.createLocalFile(widgetPath, 'README.md', readmeContent, 'documentation', 'md');
-        files.push(readmeFile);
-        // Create artifact record
-        const artifact = {
-            sys_id: widget.sys_id,
-            name: widget.name,
-            type: 'widget',
-            tableName: 'sp_widget', // Added missing tableName
-            localPath: widgetPath,
-            files: files,
-            metadata: widget,
-            syncStatus: 'synced',
-            createdAt: new Date(),
-            lastSyncedAt: new Date()
-        };
-        this.artifacts.set(sys_id, artifact);
-        console.log(`✅ Widget synced to local files:`);
-        console.log(`📁 Location: ${widgetPath}`);
-        console.log(`📄 Files created:`);
-        files.forEach(f => console.log(`   - ${f.filename} (${f.type})`));
-        console.log(`\n💡 Claude Code can now use its native tools on these files!`);
-        console.log(`   Edit, search, refactor - then run 'pushWidget' to sync back.`);
-        return artifact;
     }
     /**
      * DYNAMIC push local changes back to ServiceNow using artifact registry
@@ -336,60 +324,6 @@ class ArtifactLocalSync {
      */
     async pushWidget(sys_id) {
         return this.pushArtifact(sys_id);
-        const artifact = this.artifacts.get(sys_id);
-        if (!artifact) {
-            throw new Error(`No local artifact found for ${sys_id}. Run pullWidget first.`);
-        }
-        console.log(`\n🔄 Pushing local changes back to ServiceNow...`);
-        // Read current content from all files
-        const updates = {};
-        let hasChanges = false;
-        for (const file of artifact.files) {
-            if (fs.existsSync(file.path)) {
-                const currentContent = fs.readFileSync(file.path, 'utf8');
-                // Strip our added headers/footers for comparison
-                const cleanContent = this.stripAddedWrappers(currentContent, file.type);
-                if (cleanContent !== file.originalContent) {
-                    hasChanges = true;
-                    file.currentContent = cleanContent;
-                    file.isModified = true;
-                    // Map back to ServiceNow field
-                    if (file.field && file.field !== 'documentation' && file.field !== 'metadata') {
-                        updates[file.field] = cleanContent;
-                        console.log(`   📝 Changed: ${file.filename} (${file.field})`);
-                    }
-                }
-            }
-        }
-        if (!hasChanges) {
-            console.log(`✅ No changes detected. Widget is up to date.`);
-            return true;
-        }
-        // Validate ES5 compliance for server script
-        if (updates.script) {
-            const es5Issues = this.validateES5(updates.script);
-            if (es5Issues.length > 0) {
-                console.log(`\n⚠️ ES5 Validation Issues in server script:`);
-                es5Issues.forEach(issue => console.log(`   - ${issue}`));
-                console.log(`\n❓ Continue with deployment anyway? (ServiceNow might fail)`);
-                // In real implementation, prompt for confirmation
-            }
-        }
-        // Update in ServiceNow
-        try {
-            console.log(`\n📤 Updating widget in ServiceNow...`);
-            await this.client.updateRecord('sp_widget', sys_id, updates);
-            artifact.syncStatus = 'synced';
-            artifact.lastSyncedAt = new Date();
-            console.log(`✅ Widget successfully updated in ServiceNow!`);
-            console.log(`🔗 sys_id: ${sys_id}`);
-            return true;
-        }
-        catch (error) {
-            console.error(`❌ Failed to update widget:`, error);
-            artifact.syncStatus = 'pending_upload';
-            return false;
-        }
     }
     /**
      * Clean up local files after successful sync

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.8",
+  "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",