snow-flow 1.3.0 → 1.3.2

package/dist/health/system-health.js

@@ -3,6 +3,39 @@
  * Snow-Flow System Health Monitoring
  * Comprehensive health checks for all components
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -12,12 +45,14 @@ const events_1 = require("events");
 const servicenow_client_1 = require("../utils/servicenow-client");
 const logger_1 = require("../utils/logger");
 const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
 class SystemHealth extends events_1.EventEmitter {
     constructor(options) {
         super();
         this.checkHistory = [];
         this.totalChecks = 0;
         this.failedChecks = 0;
+        this.lastCPUInfo = null;
         this.memory = options.memory;
         this.mcpManager = options.mcpManager;
         this.config = options.config;
@@ -32,7 +67,8 @@ class SystemHealth extends events_1.EventEmitter {
         // Initialize ServiceNow client for health checks
         try {
             this.serviceNowClient = new servicenow_client_1.ServiceNowClient();
-            await this.serviceNowClient.initialize();
+            // Note: ServiceNowClient may not have an initialize method
+            // await this.serviceNowClient.initialize();
         }
         catch (error) {
             this.logger.warn('ServiceNow client initialization failed:', error);
@@ -72,6 +108,10 @@ class SystemHealth extends events_1.EventEmitter {
             this.checkInterval = undefined;
             this.logger.info('Health monitoring stopped');
         }
+        if (this.cpuCheckInterval) {
+            clearInterval(this.cpuCheckInterval);
+            this.cpuCheckInterval = undefined;
+        }
     }
     /**
      * Perform comprehensive health check
@@ -214,10 +254,10 @@ class SystemHealth extends events_1.EventEmitter {
     async checkMCP() {
         const startTime = Date.now();
         try {
-            const serverStatuses = await this.mcpManager.getServerStatuses();
-            const totalServers = Object.keys(serverStatuses).length;
-            const healthyServers = Object.values(serverStatuses).filter(s => s.status === 'running').length;
-            const unhealthyServers = Object.values(serverStatuses).filter(s => s.status === 'error').length;
+            const serverStatuses = this.mcpManager.getServerStatus();
+            const totalServers = serverStatuses.length;
+            const healthyServers = serverStatuses.filter(s => s.status === 'running').length;
+            const unhealthyServers = serverStatuses.filter(s => s.status === 'error').length;
             const responseTime = Date.now() - startTime;
             let status = 'healthy';
             let message = `All ${totalServers} MCP servers running`;
@@ -286,8 +326,7 @@ class SystemHealth extends events_1.EventEmitter {
                 status,
                 message,
                 details: {
-                    instance: testResult.instance,
-                    version: testResult.version,
+                    connected: true,
                     responseTime
                 },
                 timestamp: new Date(),
@@ -355,6 +394,7 @@ class SystemHealth extends events_1.EventEmitter {
         const startTime = Date.now();
         try {
             const resources = await this.getSystemResources();
+            const enhancedMetrics = await this.getEnhancedSystemMetrics();
             const responseTime = Date.now() - startTime;
             let status = 'healthy';
             let message = 'System resources within normal limits';
@@ -375,6 +415,21 @@ class SystemHealth extends events_1.EventEmitter {
                 status = 'unhealthy';
                 issues.push(`Critical disk usage: ${resources.diskUsage.toFixed(1)}%`);
             }
+            else if (resources.diskUsage > 80) {
+                status = status === 'healthy' ? 'degraded' : status;
+                issues.push(`High disk usage: ${resources.diskUsage.toFixed(1)}%`);
+            }
+            // Check process memory
+            const heapUsagePercent = (enhancedMetrics.process.memory.heapUsed / enhancedMetrics.process.memory.heapTotal) * 100;
+            if (heapUsagePercent > 90) {
+                status = status === 'degraded' ? 'unhealthy' : 'degraded';
+                issues.push(`High heap usage: ${heapUsagePercent.toFixed(1)}%`);
+            }
+            // Check network connectivity
+            if (!enhancedMetrics.network.connected) {
+                status = 'degraded';
+                issues.push('Network connectivity issues detected');
+            }
             if (issues.length > 0) {
                 message = issues.join(', ');
             }
@@ -382,7 +437,10 @@ class SystemHealth extends events_1.EventEmitter {
                 component: 'system',
                 status,
                 message,
-                details: resources,
+                details: {
+                    ...resources,
+                    enhanced: enhancedMetrics
+                },
                 timestamp: new Date(),
                 responseTime
             };
@@ -465,19 +523,10 @@ class SystemHealth extends events_1.EventEmitter {
         const totalMemory = os_1.default.totalmem();
         const freeMemory = os_1.default.freemem();
         const usedMemory = totalMemory - freeMemory;
-        // Calculate CPU usage
-        let totalIdle = 0;
-        let totalTick = 0;
-        cpus.forEach(cpu => {
-            for (const type in cpu.times) {
-                totalTick += cpu.times[type];
-            }
-            totalIdle += cpu.times.idle;
-        });
-        const cpuUsage = 100 - ~~(100 * totalIdle / totalTick);
-        // Get disk usage (simplified - you may want to use a library like 'diskusage')
-        const diskUsage = 50; // Placeholder - implement actual disk usage check
-        const diskTotal = 100; // Placeholder
+        // Calculate CPU usage with averaging
+        const cpuUsage = await this.calculateCPUUsage();
+        // Get real disk usage
+        const { diskUsage, diskTotal } = await this.getDiskUsage();
         return {
             cpuUsage,
             memoryUsage: usedMemory / 1024 / 1024, // MB
@@ -575,5 +624,223 @@ class SystemHealth extends events_1.EventEmitter {
             return 0;
         return responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length;
     }
+    /**
+     * Calculate real CPU usage with averaging
+     */
+    async calculateCPUUsage() {
+        const cpus = os_1.default.cpus();
+        const currentCPUInfo = cpus.map(cpu => {
+            const total = Object.values(cpu.times).reduce((acc, time) => acc + time, 0);
+            return {
+                idle: cpu.times.idle,
+                total: total
+            };
+        });
+        if (!this.lastCPUInfo) {
+            this.lastCPUInfo = currentCPUInfo;
+            // Wait a bit and calculate again for initial reading
+            await new Promise(resolve => setTimeout(resolve, 100));
+            return this.calculateCPUUsage();
+        }
+        let totalIdleDiff = 0;
+        let totalDiff = 0;
+        for (let i = 0; i < cpus.length; i++) {
+            const lastCPU = this.lastCPUInfo[i];
+            const currentCPU = currentCPUInfo[i];
+            const idleDiff = currentCPU.idle - lastCPU.idle;
+            const totalCPUDiff = currentCPU.total - lastCPU.total;
+            totalIdleDiff += idleDiff;
+            totalDiff += totalCPUDiff;
+        }
+        this.lastCPUInfo = currentCPUInfo;
+        if (totalDiff === 0)
+            return 0;
+        const idlePercentage = (totalIdleDiff / totalDiff) * 100;
+        const usagePercentage = 100 - idlePercentage;
+        return Math.max(0, Math.min(100, usagePercentage));
+    }
+    /**
+     * Get real disk usage statistics
+     */
+    async getDiskUsage() {
+        try {
+            // Platform-specific disk usage calculation
+            if (process.platform === 'darwin' || process.platform === 'linux') {
+                return this.getUnixDiskUsage();
+            }
+            else if (process.platform === 'win32') {
+                return this.getWindowsDiskUsage();
+            }
+            else {
+                // Fallback for unsupported platforms
+                return { diskUsage: 0, diskTotal: 0 };
+            }
+        }
+        catch (error) {
+            this.logger.warn('Failed to get disk usage:', error);
+            return { diskUsage: 0, diskTotal: 0 };
+        }
+    }
+    /**
+     * Get disk usage for Unix-based systems (macOS, Linux)
+     */
+    getUnixDiskUsage() {
+        try {
+            // Get current working directory's mount point
+            const cwd = process.cwd();
+            // Get disk usage for the filesystem containing the current directory
+            const output = (0, child_process_1.execSync)(`df -k "${cwd}"`, { encoding: 'utf8' });
+            const lines = output.trim().split('\n');
+            if (lines.length < 2) {
+                throw new Error('Unexpected df output format');
+            }
+            // Handle cases where the output might span multiple lines
+            let dataLine = lines[1];
+            if (lines.length > 2 && !lines[1].includes('/')) {
+                // Some systems split long filesystem names across lines
+                dataLine = lines[1] + ' ' + lines[2];
+            }
+            // Parse the data line
+            const parts = dataLine.split(/\s+/);
+            // Find the numeric values (skip filesystem name)
+            let totalBlocks = 0;
+            let usedBlocks = 0;
+            let foundNumbers = false;
+            for (let i = 0; i < parts.length; i++) {
+                const num = parseInt(parts[i], 10);
+                if (!isNaN(num) && !foundNumbers) {
+                    totalBlocks = num;
+                    if (i + 1 < parts.length) {
+                        usedBlocks = parseInt(parts[i + 1], 10);
+                        foundNumbers = true;
+                        break;
+                    }
+                }
+            }
+            if (!foundNumbers || isNaN(totalBlocks) || isNaN(usedBlocks)) {
+                throw new Error('Failed to parse disk usage numbers');
+            }
+            const diskTotal = totalBlocks / 1024 / 1024; // Convert to GB
+            const diskUsed = usedBlocks / 1024 / 1024; // Convert to GB
+            const diskUsage = (diskUsed / diskTotal) * 100;
+            return {
+                diskUsage: Math.round(diskUsage * 10) / 10, // Round to 1 decimal
+                diskTotal: Math.round(diskTotal * 10) / 10
+            };
+        }
+        catch (error) {
+            this.logger.error('Unix disk usage check failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get disk usage for Windows systems
+     */
+    getWindowsDiskUsage() {
+        try {
+            // Get disk usage for C: drive using WMIC
+            const output = (0, child_process_1.execSync)('wmic logicaldisk where caption="C:" get size,freespace /value', { encoding: 'utf8' });
+            const sizeMatch = output.match(/Size=(\d+)/);
+            const freeMatch = output.match(/FreeSpace=(\d+)/);
+            if (!sizeMatch || !freeMatch) {
+                throw new Error('Failed to parse Windows disk usage');
+            }
+            const totalBytes = parseInt(sizeMatch[1], 10);
+            const freeBytes = parseInt(freeMatch[1], 10);
+            const usedBytes = totalBytes - freeBytes;
+            const diskTotal = totalBytes / 1024 / 1024 / 1024; // Convert to GB
+            const diskUsed = usedBytes / 1024 / 1024 / 1024; // Convert to GB
+            const diskUsage = (diskUsed / diskTotal) * 100;
+            return {
+                diskUsage: Math.round(diskUsage * 10) / 10,
+                diskTotal: Math.round(diskTotal * 10) / 10
+            };
+        }
+        catch (error) {
+            this.logger.error('Windows disk usage check failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get process-specific memory usage
+     */
+    getProcessMemoryUsage() {
+        const usage = process.memoryUsage();
+        return {
+            heapUsed: usage.heapUsed / 1024 / 1024, // MB
+            heapTotal: usage.heapTotal / 1024 / 1024, // MB
+            rss: usage.rss / 1024 / 1024, // MB
+            external: usage.external / 1024 / 1024, // MB
+            arrayBuffers: usage.arrayBuffers / 1024 / 1024 // MB
+        };
+    }
+    /**
+     * Check network connectivity
+     */
+    async checkNetworkConnectivity() {
+        try {
+            // Simple DNS lookup to check network connectivity
+            const dns = await Promise.resolve().then(() => __importStar(require('dns'))).then(m => m.promises);
+            await dns.lookup('google.com');
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get additional SQLite database statistics
+     */
+    async getExtendedDatabaseStats() {
+        try {
+            // Use the existing memory system stats
+            const dbStats = await this.memory.getDatabaseStats();
+            // Get additional table information if possible
+            try {
+                const tableInfo = await this.memory.query(`
+          SELECT 
+            COUNT(DISTINCT name) as table_count,
+            SUM(CASE WHEN type = 'index' THEN 1 ELSE 0 END) as index_count
+          FROM sqlite_master 
+          WHERE type IN ('table', 'index')
+        `);
+                return {
+                    ...dbStats,
+                    tables: tableInfo[0]?.table_count || 0,
+                    indexes: tableInfo[0]?.index_count || 0
+                };
+            }
+            catch (error) {
+                // If query fails, just return basic stats
+                return dbStats;
+            }
+        }
+        catch (error) {
+            this.logger.warn('Failed to get extended database stats:', error);
+            return null;
+        }
+    }
+    /**
+     * Enhanced system check with more detailed metrics
+     */
+    async getEnhancedSystemMetrics() {
+        const processMemory = this.getProcessMemoryUsage();
+        const networkConnected = await this.checkNetworkConnectivity();
+        const dbStats = await this.getExtendedDatabaseStats();
+        return {
+            process: {
+                memory: processMemory,
+                uptime: process.uptime(),
+                pid: process.pid,
+                version: process.version,
+                platform: process.platform,
+                arch: process.arch
+            },
+            network: {
+                connected: networkConnected
+            },
+            database: dbStats
+        };
+    }
 }
 exports.SystemHealth = SystemHealth;

package/dist/mcp/base-mcp-server.js

@@ -30,6 +30,8 @@ class BaseMCPServer {
          * Tool handlers map
          */
         this.toolHandlers = new Map();
+        // Store the config
+        this.config = config;
         // Initialize server with config
         this.server = new index_js_1.Server({
             name: config.name,

package/dist/mcp/http-transport-wrapper.js

@@ -11,6 +11,7 @@ exports.HttpTransportWrapper = void 0;
 const express_1 = __importDefault(require("express"));
 const logger_js_1 = require("../utils/logger.js");
 const service_discovery_client_js_1 = require("./service-discovery-client.js");
+const mcp_resource_manager_js_1 = require("./shared/mcp-resource-manager.js");
 class HttpTransportWrapper {
     constructor(mcpServer, config) {
         this.isReady = false;
@@ -19,6 +20,7 @@ class HttpTransportWrapper {
         this.logger = new logger_js_1.Logger(`HttpTransport:${config.name}`);
         this.app = (0, express_1.default)();
         this.serviceDiscovery = new service_discovery_client_js_1.ServiceDiscoveryClient();
+        this.resourceManager = new mcp_resource_manager_js_1.MCPResourceManager(config.name);
         this.setupMiddleware();
         this.setupRoutes();
     }
@@ -117,6 +119,7 @@ class HttpTransportWrapper {
         });
         // Service info endpoint
         this.app.get('/info', (req, res) => {
+            const resourceStats = this.resourceManager.getResourceStats();
             res.json({
                 name: this.config.name,
                 version: this.config.version,
@@ -130,9 +133,41 @@ class HttpTransportWrapper {
                         '/mcp/list-resources',
                         '/mcp/read-resource'
                     ]
+                },
+                resources: {
+                    total: resourceStats.total,
+                    cached: resourceStats.cached,
+                    categories: resourceStats.categories
                 }
             });
         });
+        // Resource management endpoint
+        this.app.get('/resources', async (req, res) => {
+            try {
+                const resources = await this.resourceManager.listResources();
+                const stats = this.resourceManager.getResourceStats();
+                res.json({
+                    resources,
+                    stats
+                });
+            }
+            catch (error) {
+                this.handleError(res, error);
+            }
+        });
+        // Resource content endpoint
+        this.app.get('/resources/*', async (req, res) => {
+            try {
+                const resourcePath = req.params[0];
+                const uri = `servicenow://${resourcePath}`;
+                const resource = await this.resourceManager.readResource(uri);
+                res.set('Content-Type', resource.mimeType);
+                res.send(resource.text);
+            }
+            catch (error) {
+                this.handleError(res, error);
+            }
+        });
         // 404 handler
         this.app.use('*', (req, res) => {
             res.status(404).json({
@@ -184,12 +219,38 @@ class HttpTransportWrapper {
                     result = await this.handleToolCall(toolRequest);
                     break;
                 case 'listResources':
-                    // Handle list resources - return empty list if not supported
-                    result = { resources: [] };
+                    // Handle list resources - return available resources
+                    try {
+                        const resources = await this.resourceManager.listResources();
+                        result = { resources };
+                        this.logger.debug(`Listed ${resources.length} resources`);
+                    }
+                    catch (error) {
+                        this.logger.error('Failed to list resources:', error);
+                        result = { resources: [] };
+                    }
                     break;
                 case 'readResource':
-                    // Handle read resource - throw error if not supported
-                    throw new Error('Resource reading not implemented for this server');
+                    // Handle read resource - read specific resource by URI
+                    if (!params.uri) {
+                        throw new Error('Resource URI is required for readResource');
+                    }
+                    try {
+                        const resource = await this.resourceManager.readResource(params.uri);
+                        result = {
+                            contents: [{
+                                    uri: resource.uri,
+                                    mimeType: resource.mimeType,
+                                    text: resource.text
+                                }]
+                        };
+                        this.logger.debug(`Read resource: ${params.uri}`);
+                    }
+                    catch (error) {
+                        this.logger.error(`Failed to read resource ${params.uri}:`, error);
+                        throw new Error(`Failed to read resource: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    break;
                 default:
                     throw new Error(`Unsupported MCP method: ${method}`);
             }

package/dist/mcp/servicenow-automation-mcp-refactored.js

@@ -497,15 +497,96 @@ class ServiceNowAutomationMCP extends base_mcp_server_js_1.BaseMCPServer {
                 throw new Error(`Scheduled job not found: ${args.jobName}`);
             }
             const job = jobResponse.data.result[0];
-            // In a real implementation, this would trigger the job execution
-            // For now, return a simulated test result
-            const testResult = {
-                job_name: job.name,
-                job_id: job.sys_id,
-                test_status: 'success',
-                execution_time: Math.floor(Math.random() * 5000) + 1000,
-                message: 'Job executed successfully in test mode'
-            };
+            // Execute the scheduled job and monitor its execution
+            const executionStartTime = Date.now();
+            let testResult;
+            try {
+                // Trigger the scheduled job execution
+                this.logger.info('Triggering scheduled job execution', {
+                    jobName: job.name,
+                    jobId: job.sys_id
+                });
+                // Method 1: Try to execute via sys_trigger endpoint
+                const triggerResponse = await this.client.post('/api/now/table/sys_trigger', {
+                    script: `gs.eventQueue('sysauto.script.execute', null, '${job.sys_id}', '');`,
+                    name: `Test execution of ${job.name}`,
+                    next_action: new Date(Date.now() + 5000).toISOString() // Execute in 5 seconds
+                });
+                if (triggerResponse.result) {
+                    this.logger.info('Job execution trigger created', {
+                        triggerId: triggerResponse.result.sys_id
+                    });
+                    // Wait a brief moment for execution to begin
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    // Check for recent execution history
+                    const executionHistoryResponse = await this.client.get(`/api/now/table/sys_execution_tracker?sysparm_query=source=${job.sys_id}^ORDERBYDESCsys_created_on&sysparm_limit=1`);
+                    const realExecutionTime = Date.now() - executionStartTime;
+                    if (executionHistoryResponse.result && executionHistoryResponse.result.length > 0) {
+                        const execution = executionHistoryResponse.result[0];
+                        testResult = {
+                            job_name: job.name,
+                            job_id: job.sys_id,
+                            test_status: 'executed',
+                            execution_time: realExecutionTime,
+                            trigger_id: triggerResponse.result.sys_id,
+                            execution_tracker_id: execution.sys_id,
+                            execution_state: execution.state,
+                            execution_progress: execution.completion_percentage || 0,
+                            message: `Job execution initiated successfully. Trigger created: ${triggerResponse.result.sys_id}`,
+                            details: {
+                                job_active: job.active,
+                                job_script: job.script ? 'Present' : 'Missing',
+                                job_condition: job.condition_script || 'None',
+                                execution_history_found: true
+                            }
+                        };
+                    }
+                    else {
+                        testResult = {
+                            job_name: job.name,
+                            job_id: job.sys_id,
+                            test_status: 'triggered',
+                            execution_time: realExecutionTime,
+                            trigger_id: triggerResponse.result.sys_id,
+                            message: `Job execution trigger created successfully. Check sys_execution_tracker for progress.`,
+                            details: {
+                                job_active: job.active,
+                                job_script: job.script ? 'Present' : 'Missing',
+                                job_condition: job.condition_script || 'None',
+                                execution_history_found: false
+                            }
+                        };
+                    }
+                }
+                else {
+                    throw new Error('Failed to create execution trigger');
+                }
+            }
+            catch (executionError) {
+                // If direct execution fails, perform validation instead
+                this.logger.warn('Job execution failed, performing validation instead', {
+                    jobName: job.name,
+                    error: executionError instanceof Error ? executionError.message : String(executionError)
+                });
+                const realExecutionTime = Date.now() - executionStartTime;
+                testResult = {
+                    job_name: job.name,
+                    job_id: job.sys_id,
+                    test_status: 'validated',
+                    execution_time: realExecutionTime,
+                    message: `Job validation completed. Execution failed: ${executionError instanceof Error ? executionError.message : String(executionError)}`,
+                    details: {
+                        job_active: job.active,
+                        job_script: job.script ? 'Present' : 'Missing',
+                        job_condition: job.condition_script || 'None',
+                        job_run_as: job.run_as || 'system',
+                        job_schedule: job.run_period || 'Not scheduled',
+                        validation_performed: true,
+                        execution_attempted: true,
+                        execution_error: executionError instanceof Error ? executionError.message : String(executionError)
+                    }
+                };
+            }
             return {
                 success: true,
                 result: testResult,