snow-flow 3.5.9 → 3.5.11

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',
@@ -176,41 +190,56 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
         }));
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
+            // Add timeout protection for MCP tool execution
+            const TOOL_TIMEOUT = 10000; // 10 seconds max per tool call
             try {
                 this.logger.info(`🔧 Executing tool: ${name}`, args);
-                let result;
-                switch (name) {
-                    case 'snow_pull_artifact':
-                        result = await this.pullArtifact(args);
-                        break;
-                    case 'snow_push_artifact':
-                        result = await this.pushArtifact(args);
-                        break;
-                    case 'snow_validate_artifact_coherence':
-                        result = await this.validateArtifactCoherence(args);
-                        break;
-                    case 'snow_sync_status':
-                        result = await this.getSyncStatus(args);
-                        break;
-                    case 'snow_list_supported_artifacts':
-                        result = await this.listSupportedArtifacts(args);
-                        break;
-                    case 'snow_sync_cleanup':
-                        result = await this.syncCleanup(args);
-                        break;
-                    case 'snow_convert_to_es5':
-                        result = await this.convertToES5(args);
-                        break;
-                    // Legacy compatibility
-                    case 'snow_pull_widget':
-                        result = await this.pullWidget(args);
-                        break;
-                    case 'snow_push_widget':
-                        result = await this.pushWidget(args);
-                        break;
-                    default:
-                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                }
+                // Create timeout promise
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error(`Tool ${name} timed out after ${TOOL_TIMEOUT / 1000}s`)), TOOL_TIMEOUT);
+                });
+                // Execute tool with timeout protection
+                const toolPromise = (async () => {
+                    let result;
+                    switch (name) {
+                        case 'snow_pull_artifact':
+                            result = await this.pullArtifact(args);
+                            break;
+                        case 'snow_push_artifact':
+                            result = await this.pushArtifact(args);
+                            break;
+                        case 'snow_validate_artifact_coherence':
+                            result = await this.validateArtifactCoherence(args);
+                            break;
+                        case 'snow_sync_status':
+                            result = await this.getSyncStatus(args);
+                            break;
+                        case 'snow_list_supported_artifacts':
+                            result = await this.listSupportedArtifacts(args);
+                            break;
+                        case 'snow_sync_cleanup':
+                            result = await this.syncCleanup(args);
+                            break;
+                        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);
+                            break;
+                        case 'snow_push_widget':
+                            result = await this.pushWidget(args);
+                            break;
+                        default:
+                            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                    }
+                    return result;
+                })();
+                // Race between tool execution and timeout
+                const result = await Promise.race([toolPromise, timeoutPromise]);
                 this.logger.info(`✅ Tool ${name} completed successfully`);
                 return {
                     content: result.content
@@ -232,16 +261,25 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
     }
     async pullArtifact(args) {
         const { sys_id, table } = args;
+        // Add timeout for pull operations
+        const PULL_TIMEOUT = 15000; // 15 seconds for pull operations
         try {
-            let artifact;
-            if (table) {
-                // Use specified table
-                artifact = await this.syncManager.pullArtifact(table, sys_id);
-            }
-            else {
-                // Auto-detect table
-                artifact = await this.syncManager.pullArtifactBySysId(sys_id);
-            }
+            const pullPromise = (async () => {
+                let artifact;
+                if (table) {
+                    // Use specified table
+                    artifact = await this.syncManager.pullArtifact(table, sys_id);
+                }
+                else {
+                    // Auto-detect table
+                    artifact = await this.syncManager.pullArtifactBySysId(sys_id);
+                }
+                return artifact;
+            })();
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`Pull operation timed out after ${PULL_TIMEOUT / 1000}s`)), PULL_TIMEOUT);
+            });
+            const artifact = await Promise.race([pullPromise, timeoutPromise]);
             return {
                 content: [
                     {
@@ -412,6 +450,64 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
             ]
         };
     }
+    async debugWidgetFetch(args) {
+        const { sys_id } = args;
+        // Debug operations get extra time
+        const DEBUG_TIMEOUT = 20000; // 20 seconds for debug operations
+        try {
+            const debugPromise = this.syncManager['smartFetcher'].debugFetchWidget(sys_id);
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`Debug operation timed out after ${DEBUG_TIMEOUT / 1000}s`)), DEBUG_TIMEOUT);
+            });
+            const debugResults = await Promise.race([debugPromise, timeoutPromise]);
+            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' });
@@ -421,13 +517,25 @@ class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.Enhanc
     }
 }
 exports.ServiceNowLocalDevelopmentMCP = ServiceNowLocalDevelopmentMCP;
-// Start the server
+// Start the server with timeout protection
 async function main() {
-    const mcpServer = new ServiceNowLocalDevelopmentMCP();
-    const transport = new stdio_js_1.StdioServerTransport();
-    // Access server through a public method
-    await mcpServer.server.connect(transport);
-    console.error('🚀 ServiceNow Local Development MCP Server started');
+    try {
+        const mcpServer = new ServiceNowLocalDevelopmentMCP();
+        const transport = new stdio_js_1.StdioServerTransport();
+        // Add timeout for server initialization
+        const INIT_TIMEOUT = 5000; // 5 seconds to start
+        const connectPromise = mcpServer.server.connect(transport);
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error('Server initialization timeout')), INIT_TIMEOUT);
+        });
+        await Promise.race([connectPromise, timeoutPromise]);
+        console.error('🚀 ServiceNow Local Development MCP Server started');
+    }
+    catch (error) {
+        console.error('❌ Server failed to start within timeout:', error);
+        // Still allow server to run even if initial connection takes time
+        console.error('⏳ Server may still be initializing...');
+    }
 }
 if (require.main === module) {
     main().catch((error) => {

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

@@ -46,30 +46,36 @@ exports.ArtifactLocalSync = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const smart_field_fetcher_js_1 = require("./smart-field-fetcher.js");
+const mcp_timeout_config_js_1 = require("./mcp-timeout-config.js");
 const artifact_registry_1 = require("./artifact-sync/artifact-registry");
 class ArtifactLocalSync {
     constructor(client, customBaseDir) {
         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');
@@ -121,22 +127,34 @@ class ArtifactLocalSync {
             throw new Error(`Unsupported artifact type: ${tableName}. Supported types: ${Object.keys(artifact_registry_1.ARTIFACT_REGISTRY).join(', ')}`);
         }
         console.log(`\n🔄 Pulling ${config.displayName} (${sys_id}) to local files...`);
+        // Get timeout configuration
+        const timeoutConfig = (0, mcp_timeout_config_js_1.getMCPTimeoutConfig)();
         // Use smart fetcher for known types, otherwise direct query
         let artifactData;
-        if (tableName === 'sp_widget') {
-            artifactData = await this.smartFetcher.fetchWidget(sys_id);
-        }
-        else if (tableName === 'sys_hub_flow') {
-            artifactData = await this.smartFetcher.fetchFlow(sys_id);
-        }
-        else if (tableName === 'sys_script') {
-            artifactData = await this.smartFetcher.fetchBusinessRule(sys_id);
+        // Fetch with timeout protection
+        try {
+            if (tableName === 'sp_widget') {
+                artifactData = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.smartFetcher.fetchWidget(sys_id), timeoutConfig.pullToolTimeout, `Fetch widget ${sys_id}`);
+            }
+            else if (tableName === 'sys_hub_flow') {
+                artifactData = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.smartFetcher.fetchFlow(sys_id), timeoutConfig.pullToolTimeout, `Fetch flow ${sys_id}`);
+            }
+            else if (tableName === 'sys_script') {
+                artifactData = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.smartFetcher.fetchBusinessRule(sys_id), timeoutConfig.pullToolTimeout, `Fetch business rule ${sys_id}`);
+            }
+            else {
+                // Generic fetch for other types
+                const allFields = config.fieldMappings.map(fm => fm.serviceNowField);
+                const response = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.searchRecords(tableName, `sys_id=${sys_id}`, 1), timeoutConfig.queryToolTimeout, `Query ${tableName} ${sys_id}`);
+                artifactData = response.result?.[0];
+            }
         }
-        else {
-            // Generic fetch for other types
-            const allFields = config.fieldMappings.map(fm => fm.serviceNowField);
-            const response = await this.client.searchRecords(tableName, `sys_id=${sys_id}`, 1);
-            artifactData = response.result?.[0];
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timed out')) {
+                console.error(`⏱️ Fetch timed out - ServiceNow may be slow or artifact is very large`);
+                console.error(`💡 Try using snow_debug_widget_fetch to diagnose the issue`);
+            }
+            throw error;
         }
         if (!artifactData) {
             throw new Error(`Artifact not found: ${tableName}/${sys_id}`);
@@ -296,10 +314,11 @@ class ArtifactLocalSync {
             console.log(`\n❓ Continue with deployment anyway? (Issues might cause runtime errors)`);
             // In real implementation, prompt for confirmation
         }
-        // Update in ServiceNow
+        // Update in ServiceNow with timeout protection
         try {
             console.log(`\n📤 Updating ${config.displayName} in ServiceNow...`);
-            await this.client.updateRecord(config.tableName, sys_id, updates);
+            const timeoutConfig = (0, mcp_timeout_config_js_1.getMCPTimeoutConfig)();
+            await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.updateRecord(config.tableName, sys_id, updates), timeoutConfig.pushToolTimeout, `Update ${config.displayName} ${sys_id}`);
             artifact.syncStatus = 'synced';
             artifact.lastSyncedAt = new Date();
             console.log(`✅ ${config.displayName} successfully updated in ServiceNow!`);
@@ -570,9 +589,12 @@ snow-flow sync status ${widget.sys_id}
     async pullArtifactBySysId(sys_id) {
         // Try to detect table by querying common tables
         const tables = Object.keys(artifact_registry_1.ARTIFACT_REGISTRY);
+        const timeoutConfig = (0, mcp_timeout_config_js_1.getMCPTimeoutConfig)();
         for (const table of tables) {
             try {
-                const response = await this.client.searchRecords(table, `sys_id=${sys_id}`, 1);
+                // Quick query with short timeout
+                const response = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.searchRecords(table, `sys_id=${sys_id}`, 1), 3000, // 3 second timeout for detection
+                `Detect table for ${sys_id}`);
                 if (response.result?.[0]) {
                     console.log(`🎆 Found artifact in table: ${table}`);
                     return this.pullArtifact(table, sys_id);

package/dist/utils/mcp-timeout-config.d.ts

@@ -0,0 +1,39 @@
+/**
+ * MCP Server Timeout Configuration
+ *
+ * Provides fast, reliable timeout settings for MCP server operations
+ * to prevent Claude from timing out during API calls.
+ */
+export interface MCPTimeoutConfig {
+    serverInitTimeout: number;
+    defaultToolTimeout: number;
+    queryToolTimeout: number;
+    pullToolTimeout: number;
+    pushToolTimeout: number;
+    debugToolTimeout: number;
+    scriptToolTimeout: number;
+    apiCallTimeout: number;
+    apiRetryDelay: number;
+    apiMaxRetries: number;
+    healthCheckInterval: number;
+    healthCheckTimeout: number;
+    maxResponseSize: number;
+    chunkDelay: number;
+}
+/**
+ * Get MCP timeout configuration based on environment
+ */
+export declare function getMCPTimeoutConfig(): MCPTimeoutConfig;
+/**
+ * Wrap a promise with timeout protection
+ */
+export declare function withMCPTimeout<T>(promise: Promise<T>, timeoutMs: number, operationName?: string): Promise<T>;
+/**
+ * Execute with retry logic and timeout
+ */
+export declare function withMCPRetry<T>(fn: () => Promise<T>, config?: Partial<MCPTimeoutConfig>, operationName?: string): Promise<T>;
+/**
+ * Quick health check with timeout
+ */
+export declare function quickHealthCheck(checkFn: () => Promise<boolean>, timeoutMs?: number): Promise<boolean>;
+//# sourceMappingURL=mcp-timeout-config.d.ts.map

package/dist/utils/mcp-timeout-config.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * MCP Server Timeout Configuration
+ *
+ * Provides fast, reliable timeout settings for MCP server operations
+ * to prevent Claude from timing out during API calls.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMCPTimeoutConfig = getMCPTimeoutConfig;
+exports.withMCPTimeout = withMCPTimeout;
+exports.withMCPRetry = withMCPRetry;
+exports.quickHealthCheck = quickHealthCheck;
+/**
+ * Get MCP timeout configuration based on environment
+ */
+function getMCPTimeoutConfig() {
+    const isDebug = process.env.DEBUG === 'true';
+    const isProduction = process.env.NODE_ENV === 'production';
+    // Fast timeouts to prevent Claude from timing out
+    const config = {
+        // Server should start quickly (3s max)
+        serverInitTimeout: parseInt(process.env.MCP_SERVER_INIT_TIMEOUT || '3000'),
+        // Tool timeouts - keep them short to fail fast
+        defaultToolTimeout: parseInt(process.env.MCP_DEFAULT_TOOL_TIMEOUT || '8000'), // 8s default
+        queryToolTimeout: parseInt(process.env.MCP_QUERY_TIMEOUT || '5000'), // 5s for queries
+        pullToolTimeout: parseInt(process.env.MCP_PULL_TIMEOUT || '10000'), // 10s for pulls
+        pushToolTimeout: parseInt(process.env.MCP_PUSH_TIMEOUT || '10000'), // 10s for pushes
+        debugToolTimeout: parseInt(process.env.MCP_DEBUG_TIMEOUT || '15000'), // 15s for debug
+        scriptToolTimeout: parseInt(process.env.MCP_SCRIPT_TIMEOUT || '20000'), // 20s for scripts
+        // API calls should be fast
+        apiCallTimeout: parseInt(process.env.MCP_API_TIMEOUT || '5000'), // 5s per API call
+        apiRetryDelay: parseInt(process.env.MCP_API_RETRY_DELAY || '1000'), // 1s between retries
+        apiMaxRetries: parseInt(process.env.MCP_API_MAX_RETRIES || '2'), // Only 2 retries
+        // Health checks
+        healthCheckInterval: parseInt(process.env.MCP_HEALTH_INTERVAL || '30000'), // Every 30s
+        healthCheckTimeout: parseInt(process.env.MCP_HEALTH_TIMEOUT || '2000'), // 2s timeout
+        // Response optimization
+        maxResponseSize: parseInt(process.env.MCP_MAX_RESPONSE_SIZE || '100000'), // 100KB chunks
+        chunkDelay: parseInt(process.env.MCP_CHUNK_DELAY || '100'), // 100ms between chunks
+    };
+    // In debug mode, allow longer timeouts
+    if (isDebug) {
+        config.defaultToolTimeout *= 2;
+        config.queryToolTimeout *= 2;
+        config.pullToolTimeout *= 2;
+        config.pushToolTimeout *= 2;
+        config.debugToolTimeout *= 2;
+        config.scriptToolTimeout *= 2;
+    }
+    // In production, ensure fast responses
+    if (isProduction) {
+        config.apiMaxRetries = 1; // Only 1 retry in production
+        config.apiRetryDelay = 500; // Faster retry
+    }
+    return config;
+}
+/**
+ * Wrap a promise with timeout protection
+ */
+async function withMCPTimeout(promise, timeoutMs, operationName = 'Operation') {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error(`${operationName} timed out after ${timeoutMs / 1000}s`));
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('timed out')) {
+            // Log timeout for debugging
+            console.error(`⏱️ MCP Timeout: ${operationName} exceeded ${timeoutMs}ms`);
+            // Add context about what to do
+            error.message += ' - Consider increasing timeout or optimizing the operation';
+        }
+        throw error;
+    }
+}
+/**
+ * Execute with retry logic and timeout
+ */
+async function withMCPRetry(fn, config = {}, operationName = 'Operation') {
+    const fullConfig = { ...getMCPTimeoutConfig(), ...config };
+    let lastError = null;
+    for (let attempt = 0; attempt <= fullConfig.apiMaxRetries; attempt++) {
+        try {
+            // Try with timeout
+            const result = await withMCPTimeout(fn(), fullConfig.defaultToolTimeout, `${operationName} (attempt ${attempt + 1})`);
+            return result;
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry on non-retryable errors
+            if (error instanceof Error) {
+                if (error.message.includes('Authentication') ||
+                    error.message.includes('Permission') ||
+                    error.message.includes('Not found')) {
+                    throw error; // Don't retry auth/permission errors
+                }
+            }
+            // If we have retries left, wait and try again
+            if (attempt < fullConfig.apiMaxRetries) {
+                console.log(`⚠️ ${operationName} failed, retrying in ${fullConfig.apiRetryDelay / 1000}s...`);
+                await new Promise(resolve => setTimeout(resolve, fullConfig.apiRetryDelay));
+            }
+        }
+    }
+    // All retries exhausted
+    throw lastError || new Error(`${operationName} failed after ${fullConfig.apiMaxRetries} retries`);
+}
+/**
+ * Quick health check with timeout
+ */
+async function quickHealthCheck(checkFn, timeoutMs = 2000) {
+    try {
+        return await withMCPTimeout(checkFn(), timeoutMs, 'Health check');
+    }
+    catch (error) {
+        // Health check failed or timed out
+        return false;
+    }
+}
+//# sourceMappingURL=mcp-timeout-config.js.map

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

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmartFieldFetcher = void 0;
 exports.createFetchStrategyHint = createFetchStrategyHint;
 const artifact_registry_js_1 = require("./artifact-sync/artifact-registry.js");
+const mcp_timeout_config_js_1 = require("./mcp-timeout-config.js");
 // Widget field groups with relationship context - 20K per field for better context
 const WIDGET_FIELD_GROUPS = [
     {
@@ -160,11 +161,12 @@ class SmartFieldFetcher {
         };
         // Try to fetch all fields first, then fall back to individual fields if too large
         console.log(`📦 Attempting to fetch complete widget data...`);
+        const timeoutConfig = (0, mcp_timeout_config_js_1.getMCPTimeoutConfig)();
         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];
+            // Try to get all fields at once with timeout protection
+            const response = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.searchRecords('sp_widget', `sys_id=${sys_id}`, 1), timeoutConfig.queryToolTimeout, `Fetch complete widget ${sys_id}`);
+            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 +186,73 @@ 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 (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.searchRecords('sp_widget', `sys_id=${sys_id}`, 1), timeoutConfig.queryToolTimeout, `Basic widget fetch ${sys_id}`);
+                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 with short timeout
+                    const directResponse = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.getRecord('sp_widget', sys_id), 5000, // 5 second timeout for direct fetch
+                    `Direct widget fetch ${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 +357,70 @@ 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 = {};
+        const timeoutConfig = (0, mcp_timeout_config_js_1.getMCPTimeoutConfig)();
+        // Test 1: Basic searchRecords with timeout
+        try {
+            console.log(`Test 1: searchRecords (${timeoutConfig.queryToolTimeout / 1000}s timeout)...`);
+            const test1 = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.searchRecords('sp_widget', `sys_id=${sys_id}`, 1), timeoutConfig.queryToolTimeout, 'searchRecords test');
+            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 with timeout
+        try {
+            console.log(`Test 2: getRecord (${timeoutConfig.queryToolTimeout / 1000}s timeout)...`);
+            const test2 = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.getRecord('sp_widget', sys_id), timeoutConfig.queryToolTimeout, 'getRecord test');
+            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 with timeout
+        try {
+            console.log(`Test 3: searchRecordsWithFields (${timeoutConfig.queryToolTimeout / 1000}s timeout)...`);
+            const test3 = await (0, mcp_timeout_config_js_1.withMCPTimeout)(this.client.searchRecordsWithFields('sp_widget', `sys_id=${sys_id}`, ['name', 'script', 'client_script', 'template', 'css'], 1), timeoutConfig.queryToolTimeout, 'searchRecordsWithFields test');
+            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,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.5.9",
-  "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.",
+  "version": "3.5.11",
+  "description": "ServiceNow development framework with MCP server integration and fast response times. Features timeout-protected MCP operations to prevent Claude API timeouts. 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",
   "bin": {