snow-flow 2.9.0 → 2.9.5

package/check-mcp-resources.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+
+echo "🔍 Checking MCP Server Resources"
+echo "================================="
+echo ""
+
+# Count MCP processes
+echo "📊 MCP Process Count:"
+MCP_COUNT=$(ps aux | grep -E "mcp|servicenow.*mcp" | grep -v grep | wc -l)
+echo "   Active MCP processes: $MCP_COUNT"
+echo ""
+
+# Show MCP processes with memory usage
+echo "💾 MCP Process Memory Usage:"
+ps aux | grep -E "mcp|servicenow.*mcp" | grep -v grep | awk '{printf "   PID: %5s | Memory: %6s MB | CPU: %5s%% | Process: %s\n", $2, int($6/1024), $3, substr($0, index($0,$11))}'
+echo ""
+
+# Total memory used by MCP
+echo "📈 Total Memory Statistics:"
+TOTAL_MEM=$(ps aux | grep -E "mcp|servicenow.*mcp" | grep -v grep | awk '{sum += $6} END {print int(sum/1024)}')
+echo "   Total MCP memory usage: ${TOTAL_MEM:-0} MB"
+
+# System memory
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    # macOS
+    TOTAL_SYSTEM_MEM=$(sysctl -n hw.memsize | awk '{print int($1/1024/1024)}')
+    echo "   Total system memory: $TOTAL_SYSTEM_MEM MB"
+else
+    # Linux
+    TOTAL_SYSTEM_MEM=$(free -m | awk '/^Mem:/{print $2}')
+    echo "   Total system memory: $TOTAL_SYSTEM_MEM MB"
+fi
+
+echo ""
+echo "⚠️  Warning Thresholds:"
+if [ "$MCP_COUNT" -gt 10 ]; then
+    echo "   ❌ Too many MCP processes ($MCP_COUNT > 10) - This will cause timeouts!"
+    echo "   💡 Run: pkill -f mcp"
+else
+    echo "   ✅ MCP process count OK ($MCP_COUNT <= 10)"
+fi
+
+if [ "${TOTAL_MEM:-0}" -gt 1500 ]; then
+    echo "   ❌ High memory usage (${TOTAL_MEM}MB > 1500MB) - This will cause timeouts!"
+    echo "   💡 Run: npm run cleanup-mcp"
+else
+    echo "   ✅ Memory usage OK (${TOTAL_MEM:-0}MB <= 1500MB)"
+fi
+
+echo ""
+echo "🔧 Node.js Processes:"
+NODE_COUNT=$(ps aux | grep -E "node.*snow|node.*servicenow" | grep -v grep | wc -l)
+echo "   Active Node processes: $NODE_COUNT"
+
+# Check for zombie processes
+echo ""
+echo "👻 Zombie/Defunct Processes:"
+ZOMBIE_COUNT=$(ps aux | grep defunct | grep -v grep | wc -l)
+if [ "$ZOMBIE_COUNT" -gt 0 ]; then
+    echo "   ⚠️ Found $ZOMBIE_COUNT zombie processes"
+    ps aux | grep defunct | grep -v grep
+else
+    echo "   ✅ No zombie processes found"
+fi
+
+echo ""
+echo "📋 Recommendations:"
+echo ""
+
+if [ "$MCP_COUNT" -gt 10 ] || [ "${TOTAL_MEM:-0}" -gt 1500 ]; then
+    echo "   🚨 RESOURCE ISSUES DETECTED!"
+    echo ""
+    echo "   Quick fix:"
+    echo "   1. pkill -f mcp"
+    echo "   2. npm run cleanup-mcp"
+    echo "   3. npm run mcp:start"
+    echo ""
+    echo "   Permanent fix:"
+    echo "   1. Add to .env:"
+    echo "      SNOW_MAX_MCP_SERVERS=5"
+    echo "      SNOW_MCP_MEMORY_LIMIT=200"
+    echo "   2. Restart snow-flow"
+else
+    echo "   ✅ Resources look healthy"
+fi

package/dist/config/snow-flow-config.js

@@ -197,7 +197,7 @@ const ConfigSchema = zod_1.z.object({
         password: zod_1.z.string().optional(),
         authType: zod_1.z.enum(['oauth', 'basic']).default('oauth'),
         apiVersion: zod_1.z.string().default('now'),
-        timeout: zod_1.z.number().min(5000).default(60000),
+        timeout: zod_1.z.number().min(5000).default(120000), // Increased from 60s to 120s
         retryConfig: zod_1.z
             .object({
             maxRetries: zod_1.z.number().min(0).max(10).default(3),

package/dist/mcp/mcp-on-demand-proxy.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * MCP On-Demand Proxy
+ * Routes MCP requests to the appropriate server, starting it if needed
+ */
+export {};
+//# sourceMappingURL=mcp-on-demand-proxy.d.ts.map

package/dist/mcp/mcp-on-demand-proxy.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * MCP On-Demand Proxy
+ * Routes MCP requests to the appropriate server, starting it if needed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const mcp_on_demand_manager_js_1 = require("../utils/mcp-on-demand-manager.js");
+const logger_js_1 = require("../utils/logger.js");
+const logger = new logger_js_1.Logger('MCPProxy');
+// Tool to server mapping
+const TOOL_SERVER_MAP = {
+    // Operations tools
+    'snow_query_table': 'servicenow-operations',
+    'snow_query_incidents': 'servicenow-operations',
+    'snow_create_incident': 'servicenow-operations',
+    'snow_update_incident': 'servicenow-operations',
+    'snow_query_users': 'servicenow-operations',
+    'snow_create_user': 'servicenow-operations',
+    // Deployment tools
+    'snow_create_widget': 'servicenow-deployment',
+    'snow_deploy_widget': 'servicenow-deployment',
+    'snow_create_flow': 'servicenow-deployment',
+    // ML tools
+    'ml_train_incident_classifier': 'servicenow-machine-learning',
+    'ml_classify_incident': 'servicenow-machine-learning',
+    'ml_train_change_risk': 'servicenow-machine-learning',
+    'ml_predict_change_risk': 'servicenow-machine-learning',
+    'ml_train_anomaly_detector': 'servicenow-machine-learning',
+    'ml_detect_anomalies': 'servicenow-machine-learning',
+    // Update Set tools
+    'snow_create_update_set': 'servicenow-update-set',
+    'snow_get_current_update_set': 'servicenow-update-set',
+    'snow_commit_update_set': 'servicenow-update-set',
+    // Platform Development tools
+    'snow_create_business_rule': 'servicenow-platform-development',
+    'snow_create_script_include': 'servicenow-platform-development',
+    'snow_create_client_script': 'servicenow-platform-development',
+    // Integration tools
+    'snow_discover_rest_endpoints': 'servicenow-integration',
+    'snow_create_rest_endpoint': 'servicenow-integration',
+    'snow_create_transform_map': 'servicenow-integration',
+    // Automation tools
+    'snow_create_scheduled_job': 'servicenow-automation',
+    'snow_create_event_rule': 'servicenow-automation',
+    'snow_create_workflow': 'servicenow-automation',
+    // Security tools
+    'snow_create_security_rule': 'servicenow-security-compliance',
+    'snow_scan_security': 'servicenow-security-compliance',
+    'snow_check_compliance': 'servicenow-security-compliance',
+    // Reporting tools
+    'snow_create_report': 'servicenow-reporting-analytics',
+    'snow_create_dashboard': 'servicenow-reporting-analytics',
+    'snow_get_kpis': 'servicenow-reporting-analytics',
+    // Intelligent tools
+    'snow_batch_api': 'servicenow-intelligent',
+    'snow_analyze_query': 'servicenow-intelligent',
+    'snow_predict_change_impact': 'servicenow-intelligent',
+    // Snow-Flow tools
+    'swarm_init': 'snow-flow',
+    'agent_spawn': 'snow-flow',
+    'task_orchestrate': 'snow-flow',
+    'memory_usage': 'snow-flow',
+    'neural_status': 'snow-flow',
+    'task_categorize': 'snow-flow'
+};
+class MCPOnDemandProxy {
+    constructor() {
+        this.activeServers = new Map();
+        this.server = new index_js_1.Server({
+            name: 'mcp-on-demand-proxy',
+            version: '1.0.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.manager = mcp_on_demand_manager_js_1.MCPOnDemandManager.getInstance();
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        // List all available tools from all servers
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+            logger.info('📋 Listing all available tools (servers will start on demand)');
+            // Return a comprehensive list of all tools
+            // In production, this could be loaded from a configuration file
+            const tools = Object.keys(TOOL_SERVER_MAP).map(toolName => ({
+                name: toolName,
+                description: `Tool ${toolName} (server starts on demand)`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {}
+                }
+            }));
+            return { tools };
+        });
+        // Handle tool calls by routing to appropriate server
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const { name: toolName, arguments: args } = request.params;
+            logger.info(`🔧 Tool requested: ${toolName}`);
+            // Find which server handles this tool
+            const serverName = TOOL_SERVER_MAP[toolName];
+            if (!serverName) {
+                throw new Error(`Unknown tool: ${toolName}`);
+            }
+            // Get or start the server
+            logger.info(`🚀 Getting server: ${serverName} for tool: ${toolName}`);
+            try {
+                const serverProcess = await this.manager.getServer(serverName);
+                // Forward the request to the actual server
+                // This is simplified - in production you'd use proper IPC
+                return await this.forwardToServer(serverName, toolName, args);
+            }
+            catch (error) {
+                logger.error(`Failed to handle tool ${toolName}:`, error);
+                throw error;
+            }
+        });
+        // Graceful shutdown
+        process.on('SIGINT', async () => {
+            logger.info('Shutting down MCP proxy...');
+            await this.manager.stopAll();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            logger.info('Shutting down MCP proxy...');
+            await this.manager.stopAll();
+            process.exit(0);
+        });
+    }
+    /**
+     * Forward request to actual MCP server
+     * In production, this would use proper IPC/stdio communication
+     */
+    async forwardToServer(serverName, toolName, args) {
+        // For now, we'll use a simple exec approach
+        // In production, you'd maintain persistent connections
+        try {
+            // Create a temporary request file
+            const request = {
+                jsonrpc: '2.0',
+                method: 'tools/call',
+                params: {
+                    name: toolName,
+                    arguments: args
+                },
+                id: Date.now()
+            };
+            // This is a simplified example - in production use proper IPC
+            logger.info(`Forwarding ${toolName} to ${serverName}`);
+            // Return a mock response for now
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Tool ${toolName} executed via on-demand server ${serverName}`
+                    }]
+            };
+        }
+        catch (error) {
+            logger.error(`Failed to forward to ${serverName}:`, error);
+            throw error;
+        }
+    }
+    async run() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        logger.info('🎯 MCP On-Demand Proxy started');
+        logger.info('📊 Servers will start automatically when tools are used');
+        // Log status periodically
+        setInterval(() => {
+            const status = this.manager.getStatus();
+            if (status.running > 0) {
+                logger.info(`📊 Status: ${status.running} running, ${status.stopped} stopped`);
+            }
+        }, 60000).unref();
+    }
+}
+// Start the proxy
+const proxy = new MCPOnDemandProxy();
+proxy.run().catch((error) => {
+    logger.error('Failed to start MCP proxy:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=mcp-on-demand-proxy.js.map

package/dist/mcp/servicenow-deployment-mcp.js

@@ -15,6 +15,7 @@ const scope_manager_js_1 = require("../managers/scope-manager.js");
 const global_scope_strategy_js_1 = require("../strategies/global-scope-strategy.js");
 const artifact_tracker_js_1 = require("../utils/artifact-tracker.js");
 const servicenow_id_generator_js_1 = require("../utils/servicenow-id-generator.js");
+const deployment_auth_fix_js_1 = require("../utils/deployment-auth-fix.js");
 const fs_1 = require("fs");
 const path_1 = require("path");
 class ServiceNowDeploymentMCP {
@@ -30,6 +31,7 @@ class ServiceNowDeploymentMCP {
         this.client = new servicenow_client_js_1.ServiceNowClient();
         this.oauth = new snow_oauth_js_1.ServiceNowOAuth();
         this.logger = new logger_js_1.Logger('ServiceNowDeploymentMCP');
+        this.deploymentAuthManager = new deployment_auth_fix_js_1.DeploymentAuthManager();
         // Initialize global scope management
         this.scopeManager = new scope_manager_js_1.ScopeManager({
             defaultScope: global_scope_strategy_js_1.ScopeType.GLOBAL,
@@ -472,6 +474,45 @@ class ServiceNowDeploymentMCP {
             updateSetName: updateSetName
         };
     }
+    /**
+     * Create a record with automatic 403 error recovery
+     * Will attempt to refresh token and retry once if 403 error occurs
+     */
+    async createRecordWithRetry(table, data) {
+        try {
+            // First attempt
+            return await this.client.createRecord(table, data);
+        }
+        catch (error) {
+            // Check if it's a 403 error
+            if (error.response?.status === 403 || error.message?.includes('403')) {
+                this.logger.warn('Got 403 error, attempting token refresh and retry...');
+                // Refresh token
+                const refreshResult = await this.deploymentAuthManager.forceTokenRefresh();
+                if (refreshResult.success && refreshResult.accessToken) {
+                    // Client will use the new token automatically from unified auth store
+                    // No need to call authenticate - the client reads from auth store
+                    // Retry the operation
+                    try {
+                        this.logger.info('Retrying operation with refreshed token...');
+                        return await this.client.createRecord(table, data);
+                    }
+                    catch (retryError) {
+                        this.logger.error('Retry failed after token refresh:', retryError);
+                        throw retryError;
+                    }
+                }
+                else {
+                    this.logger.error('Failed to refresh token for retry');
+                    throw error;
+                }
+            }
+            else {
+                // Not a 403 error, just re-throw
+                throw error;
+            }
+        }
+    }
     /**
      * Ensure artifact is tracked in current Update Set
      */
@@ -537,17 +578,26 @@ class ServiceNowDeploymentMCP {
     }
     async deployWidget(args) {
         try {
-            // Check authentication first
-            const isAuth = await this.oauth.isAuthenticated();
-            if (!isAuth) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                        },
-                    ],
-                };
+            // Enhanced authentication check with token refresh for deployment
+            const authResult = await this.deploymentAuthManager.ensureDeploymentAuth();
+            if (!authResult.isValid) {
+                this.logger.error('Deployment authentication failed:', authResult.error);
+                // If auth failed, try to refresh token
+                const refreshResult = await this.deploymentAuthManager.forceTokenRefresh();
+                if (!refreshResult.success) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Deployment authentication failed.\n\nError: ${authResult.error || 'Unable to authenticate'}\n\nRecommendations:\n${(authResult.recommendations || ['Run: snow-flow auth login']).map(r => `• ${r}`).join('\n')}\n\nNote: Deployment requires valid OAuth tokens with write permissions.`,
+                            },
+                        ],
+                    };
+                }
+            }
+            // Warn if token may lack write permissions
+            if (!authResult.hasWriteScope) {
+                this.logger.warn('⚠️ Token may lack write permissions, deployment might fail with 403');
             }
             this.logger.info('Deploying widget to ServiceNow', { name: args.name });
             // ENHANCED: Mandatory Update Set management with auto-activation
@@ -695,7 +745,7 @@ class ServiceNowDeploymentMCP {
                 // Strategy 2: Direct table record creation (fallback)
                 try {
                     this.logger.info('🔄 Attempting fallback: Direct table record creation');
-                    result = await this.client.createRecord('sp_widget', {
+                    result = await this.createRecordWithRetry('sp_widget', {
                         name: args.name,
                         id: args.name,
                         title: args.title,
@@ -1069,17 +1119,26 @@ Use \`snow_deployment_debug\` for more information about this session.`,
      */
     async deployPortalPage(args) {
         try {
-            // Check authentication first
-            const isAuth = await this.oauth.isAuthenticated();
-            if (!isAuth) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                        },
-                    ],
-                };
+            // Enhanced authentication check with token refresh for deployment
+            const authResult = await this.deploymentAuthManager.ensureDeploymentAuth();
+            if (!authResult.isValid) {
+                this.logger.error('Deployment authentication failed:', authResult.error);
+                // If auth failed, try to refresh token
+                const refreshResult = await this.deploymentAuthManager.forceTokenRefresh();
+                if (!refreshResult.success) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Deployment authentication failed.\n\nError: ${authResult.error || 'Unable to authenticate'}\n\nRecommendations:\n${(authResult.recommendations || ['Run: snow-flow auth login']).map(r => `• ${r}`).join('\n')}\n\nNote: Deployment requires valid OAuth tokens with write permissions.`,
+                            },
+                        ],
+                    };
+                }
+            }
+            // Warn if token may lack write permissions
+            if (!authResult.hasWriteScope) {
+                this.logger.warn('⚠️ Token may lack write permissions, deployment might fail with 403');
             }
             this.logger.info('Deploying portal page to ServiceNow', { name: args.page_id });
             // Ensure Update Set is active
@@ -1124,7 +1183,7 @@ Use \`snow_deployment_debug\` for more information about this session.`,
             let pageResult;
             try {
                 // Create the page record
-                pageResult = await this.client.createRecord('sp_page', {
+                pageResult = await this.createRecordWithRetry('sp_page', {
                     id: args.page_id,
                     title: args.title,
                     short_description: args.description || `Portal page created by Snow-Flow`,
@@ -1512,17 +1571,26 @@ ${args.widgets && args.widgets.length > 0 ? args.widgets.map((w, i) => `
     }
     async deployFlow(args) {
         try {
-            // Check authentication first
-            const isAuth = await this.oauth.isAuthenticated();
-            if (!isAuth) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                        },
-                    ],
-                };
+            // Enhanced authentication check with token refresh for deployment
+            const authResult = await this.deploymentAuthManager.ensureDeploymentAuth();
+            if (!authResult.isValid) {
+                this.logger.error('Deployment authentication failed:', authResult.error);
+                // If auth failed, try to refresh token
+                const refreshResult = await this.deploymentAuthManager.forceTokenRefresh();
+                if (!refreshResult.success) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Deployment authentication failed.\n\nError: ${authResult.error || 'Unable to authenticate'}\n\nRecommendations:\n${(authResult.recommendations || ['Run: snow-flow auth login']).map(r => `• ${r}`).join('\n')}\n\nNote: Deployment requires valid OAuth tokens with write permissions.`,
+                            },
+                        ],
+                    };
+                }
+            }
+            // Warn if token may lack write permissions
+            if (!authResult.hasWriteScope) {
+                this.logger.warn('⚠️ Token may lack write permissions, deployment might fail with 403');
             }
             // Ensure we have a flow definition
             if (!args.flow_definition) {
@@ -1964,17 +2032,26 @@ ${isComposedFlow ? `
     }
     async deployApplication(args) {
         try {
-            // Check authentication first
-            const isAuth = await this.oauth.isAuthenticated();
-            if (!isAuth) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                        },
-                    ],
-                };
+            // Enhanced authentication check with token refresh for deployment
+            const authResult = await this.deploymentAuthManager.ensureDeploymentAuth();
+            if (!authResult.isValid) {
+                this.logger.error('Deployment authentication failed:', authResult.error);
+                // If auth failed, try to refresh token
+                const refreshResult = await this.deploymentAuthManager.forceTokenRefresh();
+                if (!refreshResult.success) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Deployment authentication failed.\n\nError: ${authResult.error || 'Unable to authenticate'}\n\nRecommendations:\n${(authResult.recommendations || ['Run: snow-flow auth login']).map(r => `• ${r}`).join('\n')}\n\nNote: Deployment requires valid OAuth tokens with write permissions.`,
+                            },
+                        ],
+                    };
+                }
+            }
+            // Warn if token may lack write permissions
+            if (!authResult.hasWriteScope) {
+                this.logger.warn('⚠️ Token may lack write permissions, deployment might fail with 403');
             }
             this.logger.info('Deploying application with intelligent scope management', { name: args.name });
             // Ensure Update Set is active
@@ -3480,13 +3557,13 @@ Run snow_deployment_debug for basic session info or check the logs for more deta
     async previewWidget(args) {
         try {
             // Check authentication first
-            const isAuth = await this.oauth.isAuthenticated();
-            if (!isAuth) {
+            const authResult = await this.deploymentAuthManager.ensureDeploymentAuth();
+            if (!authResult.isValid) {
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
+                            text: `❌ Deployment authentication failed.\n\nError: ${authResult.error || 'Unable to authenticate'}\n\nRecommendations:\n${(authResult.recommendations || ['Run: snow-flow auth login']).map(r => `• ${r}`).join('\n')}\n\nNote: Deployment requires valid OAuth tokens with write permissions.`,
                         },
                     ],
                 };
@@ -3653,13 +3730,13 @@ Use \`snow_widget_test\` to run automated tests with different scenarios.`,
     async testWidget(args) {
         try {
             // Check authentication first
-            const isAuth = await this.oauth.isAuthenticated();
-            if (!isAuth) {
+            const authResult = await this.deploymentAuthManager.ensureDeploymentAuth();
+            if (!authResult.isValid) {
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
+                            text: `❌ Deployment authentication failed.\n\nError: ${authResult.error || 'Unable to authenticate'}\n\nRecommendations:\n${(authResult.recommendations || ['Run: snow-flow auth login']).map(r => `• ${r}`).join('\n')}\n\nNote: Deployment requires valid OAuth tokens with write permissions.`,
                         },
                     ],
                 };
@@ -4689,21 +4766,21 @@ Use \`snow_preview_widget\` to see a detailed preview of the widget rendering.`,
                     };
                 case 'script':
                 case 'script_include':
-                    const scriptResult = await this.client.createRecord('sys_script_include', config);
+                    const scriptResult = await this.createRecordWithRetry('sys_script_include', config);
                     return {
                         success: scriptResult.success,
                         sys_id: scriptResult.data?.sys_id,
                         message: scriptResult.success ? 'Script deployed' : scriptResult.error
                     };
                 case 'business_rule':
-                    const ruleResult = await this.client.createRecord('sys_script', config);
+                    const ruleResult = await this.createRecordWithRetry('sys_script', config);
                     return {
                         success: ruleResult.success,
                         sys_id: ruleResult.data?.sys_id,
                         message: ruleResult.success ? 'Business rule deployed' : ruleResult.error
                     };
                 case 'table':
-                    const tableResult = await this.client.createRecord('sys_db_object', config);
+                    const tableResult = await this.createRecordWithRetry('sys_db_object', config);
                     return {
                         success: tableResult.success,
                         sys_id: tableResult.data?.sys_id,