snow-flow 3.5.10 → 3.5.12

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

@@ -190,44 +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;
-                    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}`);
-                }
+                // 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
@@ -249,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: [
                     {
@@ -431,8 +452,14 @@ 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 debugResults = await this.syncManager['smartFetcher'].debugFetchWidget(sys_id);
+            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'];
@@ -490,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,6 +46,7 @@ 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) {
@@ -126,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}`);
@@ -301,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!`);
@@ -575,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';
+    // Balanced timeouts - long enough for real work, short enough to prevent hanging
+    const config = {
+        // Server should start reasonably quickly
+        serverInitTimeout: parseInt(process.env.MCP_SERVER_INIT_TIMEOUT || '10000'), // 10s for server init
+        // Tool timeouts - balanced for real operations
+        defaultToolTimeout: parseInt(process.env.MCP_DEFAULT_TOOL_TIMEOUT || '30000'), // 30s default
+        queryToolTimeout: parseInt(process.env.MCP_QUERY_TIMEOUT || '15000'), // 15s for queries
+        pullToolTimeout: parseInt(process.env.MCP_PULL_TIMEOUT || '60000'), // 60s for pulls (large widgets)
+        pushToolTimeout: parseInt(process.env.MCP_PUSH_TIMEOUT || '45000'), // 45s for pushes
+        debugToolTimeout: parseInt(process.env.MCP_DEBUG_TIMEOUT || '30000'), // 30s for debug
+        scriptToolTimeout: parseInt(process.env.MCP_SCRIPT_TIMEOUT || '120000'), // 2 min for scripts
+        // API calls get reasonable time
+        apiCallTimeout: parseInt(process.env.MCP_API_TIMEOUT || '15000'), // 15s per API call
+        apiRetryDelay: parseInt(process.env.MCP_API_RETRY_DELAY || '2000'), // 2s between retries
+        apiMaxRetries: parseInt(process.env.MCP_API_MAX_RETRIES || '3'), // 3 retries for resilience
+        // 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.js

@@ -86,8 +86,6 @@ class ServiceNowClient {
         // 🔧 CRITICAL FIX: Add makeRequest method to Axios instance to fix phantom calls
         // Some code expects makeRequest to exist on this.client (the Axios instance)
         this.client.makeRequest = async (config) => {
-            this.logger.debug('🔧 AXIOS makeRequest called! Config:', config);
-            this.logger.debug('🔧 Routing to appropriate HTTP method...');
             // Route to the appropriate Axios method based on the request config
             const method = (config.method || 'GET').toLowerCase();
             const url = config.url || config.endpoint;
@@ -2888,17 +2886,13 @@ try {
      * This method provides compatibility for code that expects makeRequest
      */
     async makeRequest(config) {
-        this.logger.info('🔧 MAKEQUEST CALLED! Stack trace:', new Error().stack);
-        this.logger.info('🔧 TEMP FIX: makeRequest called with config:', config);
-        this.logger.info('🔧 This instance constructor:', this.constructor.name);
-        this.logger.info('🔧 This instance methods:', Object.getOwnPropertyNames(Object.getPrototypeOf(this)));
+        // Debug logging removed - was causing noise in production
         try {
             await this.ensureAuthenticated();
             // Route the request to the appropriate HTTP method
             const method = (config.method || 'GET').toLowerCase();
             const url = config.url || config.endpoint;
             const data = config.data || config.body;
-            this.logger.info(`🔧 Routing ${method.toUpperCase()} request to: ${url}`);
             switch (method) {
                 case 'get':
                     return await this.get(url, config.params);

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,9 +161,10 @@ 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);
+            // 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`);
@@ -192,7 +194,7 @@ class SmartFieldFetcher {
             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);
+                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`);
                 }
@@ -227,8 +229,9 @@ class SmartFieldFetcher {
                 // 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);
+                    // 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
@@ -360,10 +363,11 @@ class SmartFieldFetcher {
     async debugFetchWidget(sys_id) {
         console.log(`\n🔍 DEBUG: Testing different fetch approaches for widget ${sys_id}\n`);
         const results = {};
-        // Test 1: Basic searchRecords
+        const timeoutConfig = (0, mcp_timeout_config_js_1.getMCPTimeoutConfig)();
+        // Test 1: Basic searchRecords with timeout
         try {
-            console.log(`Test 1: searchRecords...`);
-            const test1 = await this.client.searchRecords('sp_widget', `sys_id=${sys_id}`, 1);
+            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];
@@ -377,10 +381,10 @@ class SmartFieldFetcher {
         catch (e) {
             console.log(`  ❌ Error: ${e.message}`);
         }
-        // Test 2: getRecord
+        // Test 2: getRecord with timeout
         try {
-            console.log(`Test 2: getRecord...`);
-            const test2 = await this.client.getRecord('sp_widget', sys_id);
+            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;
@@ -394,10 +398,10 @@ class SmartFieldFetcher {
         catch (e) {
             console.log(`  ❌ Error: ${e.message}`);
         }
-        // Test 3: searchRecordsWithFields
+        // Test 3: searchRecordsWithFields with timeout
         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(`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];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "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.",
+  "version": "3.5.12",
+  "description": "ServiceNow development framework with MCP server integration and balanced timeout protection. Features intelligent timeout configuration for long operations while preventing Claude API timeouts. Debug logging cleaned up for production use. 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": {