claude-flow 2.0.0-alpha.55 → 2.0.0-alpha.57

package/src/cli/simple-commands/monitor.js

@@ -1,5 +1,9 @@
-// monitor.js - System monitoring commands
+// monitor.js - System monitoring commands with real metrics
 import { printSuccess, printError, printWarning } from '../utils.js';
+import os from 'os';
+import { performance } from 'perf_hooks';
+import fs from 'fs/promises';
+import path from 'path';
 
 export async function monitorCommand(subArgs, flags) {
   const interval = getFlag(subArgs, '--interval') || flags.interval || 5000;
@@ -27,22 +31,37 @@ async function runContinuousMonitoring(interval, format) {
   printSuccess(`Starting continuous monitoring (interval: ${interval}ms)`);
   console.log('Press Ctrl+C to stop monitoring\n');
   
-  // Simulate monitoring - in a real implementation, this would collect actual metrics
-  let iteration = 0;
-  const maxIterations = 10; // Limit for demo purposes
-  
-  const monitorInterval = setInterval(async () => {
-    iteration++;
-    
-    if (iteration > maxIterations) {
-      console.log('\n📊 Monitoring demo completed (limited to 10 iterations)');
-      console.log('In production, this would run continuously until stopped');
+  // Set up signal handler for graceful shutdown
+  let monitorInterval;
+  const cleanup = () => {
+    if (monitorInterval) {
       clearInterval(monitorInterval);
-      return;
     }
-    
-    console.clear(); // Clear screen for fresh output
-    console.log(`🔄 Monitoring Claude-Flow System - Update #${iteration}`);
+    console.log('\n👋 Monitoring stopped');
+    process.exit(0);
+  };
+  
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+  
+  // Initial display
+  const initialMetrics = await collectMetrics();
+  console.clear();
+  console.log(`🔄 Monitoring Claude-Flow System`);
+  console.log(`⏰ ${new Date().toLocaleTimeString()}\n`);
+  
+  if (format === 'json') {
+    console.log(JSON.stringify(initialMetrics, null, 2));
+  } else {
+    displayMetrics(initialMetrics);
+  }
+  
+  console.log(`\n🔄 Next update in ${interval}ms...`);
+  
+  // Start continuous monitoring
+  monitorInterval = setInterval(async () => {
+    console.clear();
+    console.log(`🔄 Monitoring Claude-Flow System`);
     console.log(`⏰ ${new Date().toLocaleTimeString()}\n`);
     
     const metrics = await collectMetrics();
@@ -54,48 +73,227 @@ async function runContinuousMonitoring(interval, format) {
     }
     
     console.log(`\n🔄 Next update in ${interval}ms...`);
-    
   }, interval);
-  
-  // In a real implementation, you would handle Ctrl+C gracefully
-  setTimeout(() => {
-    clearInterval(monitorInterval);
-    console.log('\n👋 Monitoring stopped');
-  }, interval * (maxIterations + 1));
 }
 
 async function collectMetrics() {
-  // Simulate metric collection - in real implementation, this would gather actual system data
   const timestamp = Date.now();
   
+  // Collect real system metrics
+  const cpuUsage = await getCPUUsage();
+  const memoryInfo = getMemoryInfo();
+  const diskUsage = await getDiskUsage();
+  const systemUptime = os.uptime();
+  
+  // Try to get orchestrator metrics from file or socket
+  const orchestratorMetrics = await getOrchestratorMetrics();
+  
+  // Collect performance metrics
+  const performanceMetrics = getPerformanceMetrics();
+  
+  // Collect resource utilization
+  const resourceMetrics = await getResourceMetrics();
+  
   return {
     timestamp,
     system: {
-      uptime: Math.floor(Math.random() * 86400), // Random uptime in seconds
-      cpu_usage: Math.round(Math.random() * 100 * 100) / 100, // Random CPU %
-      memory_usage: Math.round(Math.random() * 8192 * 100) / 100, // Random memory MB
-      disk_usage: Math.round(Math.random() * 100 * 100) / 100 // Random disk %
-    },
-    orchestrator: {
-      status: Math.random() > 0.8 ? 'running' : 'stopped',
-      active_agents: Math.floor(Math.random() * 5),
-      queued_tasks: Math.floor(Math.random() * 10),
-      completed_tasks: Math.floor(Math.random() * 50),
-      errors: Math.floor(Math.random() * 3)
+      uptime: systemUptime,
+      cpu_usage: cpuUsage,
+      memory_usage: memoryInfo.usedMB,
+      memory_total: memoryInfo.totalMB,
+      memory_percentage: memoryInfo.percentage,
+      disk_usage: diskUsage.percentage,
+      disk_used: diskUsage.usedGB,
+      disk_total: diskUsage.totalGB,
+      load_average: os.loadavg(),
+      cpu_count: os.cpus().length,
+      platform: os.platform(),
+      node_version: process.version
     },
-    performance: {
-      avg_task_duration: Math.round(Math.random() * 5000 * 100) / 100, // ms
-      throughput: Math.round(Math.random() * 100 * 100) / 100, // tasks/min
-      success_rate: Math.round((0.85 + Math.random() * 0.15) * 100 * 100) / 100 // %
-    },
-    resources: {
-      memory_entries: Math.floor(Math.random() * 100),
-      terminal_sessions: Math.floor(Math.random() * 5),
-      mcp_connections: Math.floor(Math.random() * 3)
+    orchestrator: orchestratorMetrics,
+    performance: performanceMetrics,
+    resources: resourceMetrics
+  };
+}
+
+// Get real CPU usage
+async function getCPUUsage() {
+  const cpus = os.cpus();
+  let totalIdle = 0;
+  let totalTick = 0;
+  
+  cpus.forEach(cpu => {
+    for (const type in cpu.times) {
+      totalTick += cpu.times[type];
     }
+    totalIdle += cpu.times.idle;
+  });
+  
+  const idle = totalIdle / cpus.length;
+  const total = totalTick / cpus.length;
+  const usage = 100 - ~~(100 * idle / total);
+  
+  return Math.max(0, Math.min(100, usage));
+}
+
+// Get real memory information
+function getMemoryInfo() {
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+  const usedMem = totalMem - freeMem;
+  
+  return {
+    totalMB: Math.round(totalMem / 1024 / 1024),
+    freeMB: Math.round(freeMem / 1024 / 1024),
+    usedMB: Math.round(usedMem / 1024 / 1024),
+    percentage: Math.round((usedMem / totalMem) * 100)
   };
 }
 
+// Get real disk usage (simplified - checks current working directory)
+async function getDiskUsage() {
+  try {
+    const stats = await fs.statfs(process.cwd());
+    const totalBytes = stats.blocks * stats.bsize;
+    const freeBytes = stats.bavail * stats.bsize;
+    const usedBytes = totalBytes - freeBytes;
+    
+    return {
+      totalGB: Math.round(totalBytes / 1024 / 1024 / 1024 * 10) / 10,
+      usedGB: Math.round(usedBytes / 1024 / 1024 / 1024 * 10) / 10,
+      freeGB: Math.round(freeBytes / 1024 / 1024 / 1024 * 10) / 10,
+      percentage: Math.round((usedBytes / totalBytes) * 100)
+    };
+  } catch (error) {
+    // Fallback for older Node.js versions or unsupported platforms
+    return {
+      totalGB: 0,
+      usedGB: 0,
+      freeGB: 0,
+      percentage: 0
+    };
+  }
+}
+
+// Get orchestrator metrics from running instance
+async function getOrchestratorMetrics() {
+  try {
+    // Try to read from metrics file if orchestrator is running
+    const metricsPath = path.join(process.cwd(), '.claude-flow', 'metrics.json');
+    const metricsData = await fs.readFile(metricsPath, 'utf8');
+    const metrics = JSON.parse(metricsData);
+    
+    return {
+      status: 'running',
+      active_agents: metrics.activeAgents || 0,
+      queued_tasks: metrics.queuedTasks || 0,
+      completed_tasks: metrics.completedTasks || 0,
+      failed_tasks: metrics.failedTasks || 0,
+      errors: metrics.errors || 0,
+      uptime: metrics.uptime || 0
+    };
+  } catch (error) {
+    // Check if orchestrator process is running
+    const isRunning = await checkOrchestratorRunning();
+    
+    return {
+      status: isRunning ? 'running' : 'stopped',
+      active_agents: 0,
+      queued_tasks: 0,
+      completed_tasks: 0,
+      failed_tasks: 0,
+      errors: 0,
+      uptime: 0
+    };
+  }
+}
+
+// Check if orchestrator is running
+async function checkOrchestratorRunning() {
+  try {
+    const pidPath = path.join(process.cwd(), '.claude-flow', 'orchestrator.pid');
+    const pidData = await fs.readFile(pidPath, 'utf8');
+    const pid = parseInt(pidData.trim());
+    
+    // Check if process is running
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Get performance metrics
+function getPerformanceMetrics() {
+  const memUsage = process.memoryUsage();
+  const cpuUsage = process.cpuUsage();
+  
+  return {
+    avg_task_duration: 0, // Would need to track actual tasks
+    throughput: 0, // Would need to track actual throughput
+    success_rate: 100, // Default to 100% if no errors
+    memory_heap_used: Math.round(memUsage.heapUsed / 1024 / 1024 * 100) / 100,
+    memory_heap_total: Math.round(memUsage.heapTotal / 1024 / 1024 * 100) / 100,
+    memory_external: Math.round(memUsage.external / 1024 / 1024 * 100) / 100,
+    cpu_user: Math.round(cpuUsage.user / 1000), // Convert to milliseconds
+    cpu_system: Math.round(cpuUsage.system / 1000)
+  };
+}
+
+// Get resource metrics
+async function getResourceMetrics() {
+  try {
+    // Count memory entries from memory database if available
+    const memoryDbPath = path.join(process.cwd(), '.claude-flow', 'memory.db');
+    const memoryExists = await fs.access(memoryDbPath).then(() => true).catch(() => false);
+    
+    // Count terminal sessions
+    const terminalSessions = await countTerminalSessions();
+    
+    // Count MCP connections
+    const mcpConnections = await countMCPConnections();
+    
+    return {
+      memory_entries: memoryExists ? 'Available' : 0,
+      terminal_sessions: terminalSessions,
+      mcp_connections: mcpConnections,
+      open_files: process._getActiveHandles ? process._getActiveHandles().length : 0,
+      open_requests: process._getActiveRequests ? process._getActiveRequests().length : 0
+    };
+  } catch (error) {
+    return {
+      memory_entries: 0,
+      terminal_sessions: 0,
+      mcp_connections: 0,
+      open_files: 0,
+      open_requests: 0
+    };
+  }
+}
+
+// Count active terminal sessions
+async function countTerminalSessions() {
+  try {
+    const sessionsPath = path.join(process.cwd(), '.claude-flow', 'sessions');
+    const files = await fs.readdir(sessionsPath);
+    return files.filter(f => f.endsWith('.json')).length;
+  } catch {
+    return 0;
+  }
+}
+
+// Count MCP connections
+async function countMCPConnections() {
+  try {
+    const mcpPath = path.join(process.cwd(), '.claude-flow', 'mcp-connections.json');
+    const data = await fs.readFile(mcpPath, 'utf8');
+    const connections = JSON.parse(data);
+    return Array.isArray(connections) ? connections.length : 0;
+  } catch {
+    return 0;
+  }
+}
+
 function displayMetrics(metrics) {
   const timestamp = new Date(metrics.timestamp).toLocaleTimeString();
   
@@ -104,30 +302,47 @@ function displayMetrics(metrics) {
   
   // System metrics
   console.log('\n🖥️  System Resources:');
+  console.log(`   Platform: ${metrics.system.platform} (${metrics.system.cpu_count} CPUs)`);
+  console.log(`   Node Version: ${metrics.system.node_version}`);
   console.log(`   CPU Usage: ${metrics.system.cpu_usage.toFixed(1)}%`);
-  console.log(`   Memory: ${metrics.system.memory_usage.toFixed(1)} MB`);
-  console.log(`   Disk Usage: ${metrics.system.disk_usage.toFixed(1)}%`);
+  console.log(`   Memory: ${metrics.system.memory_usage.toFixed(1)} MB / ${metrics.system.memory_total.toFixed(1)} MB (${metrics.system.memory_percentage}%)`);
+  console.log(`   Disk Usage: ${metrics.system.disk_used} GB / ${metrics.system.disk_total} GB (${metrics.system.disk_usage}%)`);
+  console.log(`   Load Average: ${metrics.system.load_average.map(l => l.toFixed(2)).join(', ')}`);
   console.log(`   Uptime: ${formatUptime(metrics.system.uptime)}`);
   
   // Orchestrator metrics
   console.log('\n🎭 Orchestrator:');
   console.log(`   Status: ${getStatusIcon(metrics.orchestrator.status)} ${metrics.orchestrator.status}`);
-  console.log(`   Active Agents: ${metrics.orchestrator.active_agents}`);
-  console.log(`   Queued Tasks: ${metrics.orchestrator.queued_tasks}`);
-  console.log(`   Completed: ${metrics.orchestrator.completed_tasks}`);
-  console.log(`   Errors: ${metrics.orchestrator.errors}`);
+  if (metrics.orchestrator.status === 'running') {
+    console.log(`   Active Agents: ${metrics.orchestrator.active_agents}`);
+    console.log(`   Queued Tasks: ${metrics.orchestrator.queued_tasks}`);
+    console.log(`   Completed: ${metrics.orchestrator.completed_tasks}`);
+    console.log(`   Failed: ${metrics.orchestrator.failed_tasks}`);
+    console.log(`   Errors: ${metrics.orchestrator.errors}`);
+    if (metrics.orchestrator.uptime > 0) {
+      console.log(`   Orchestrator Uptime: ${formatUptime(Math.floor(metrics.orchestrator.uptime / 1000))}`);
+    }
+  }
   
   // Performance metrics
   console.log('\n⚡ Performance:');
-  console.log(`   Avg Task Duration: ${metrics.performance.avg_task_duration.toFixed(0)}ms`);
-  console.log(`   Throughput: ${metrics.performance.throughput.toFixed(1)} tasks/min`);
-  console.log(`   Success Rate: ${metrics.performance.success_rate.toFixed(1)}%`);
+  console.log(`   Process Memory (Heap): ${metrics.performance.memory_heap_used.toFixed(1)} MB / ${metrics.performance.memory_heap_total.toFixed(1)} MB`);
+  console.log(`   External Memory: ${metrics.performance.memory_external.toFixed(1)} MB`);
+  console.log(`   CPU Time (User): ${metrics.performance.cpu_user}ms`);
+  console.log(`   CPU Time (System): ${metrics.performance.cpu_system}ms`);
+  if (metrics.performance.avg_task_duration > 0) {
+    console.log(`   Avg Task Duration: ${metrics.performance.avg_task_duration.toFixed(0)}ms`);
+    console.log(`   Throughput: ${metrics.performance.throughput.toFixed(1)} tasks/min`);
+    console.log(`   Success Rate: ${metrics.performance.success_rate.toFixed(1)}%`);
+  }
   
   // Resource utilization
   console.log('\n📦 Resources:');
   console.log(`   Memory Entries: ${metrics.resources.memory_entries}`);
   console.log(`   Terminal Sessions: ${metrics.resources.terminal_sessions}`);
   console.log(`   MCP Connections: ${metrics.resources.mcp_connections}`);
+  console.log(`   Open File Handles: ${metrics.resources.open_files}`);
+  console.log(`   Active Requests: ${metrics.resources.open_requests}`);
   
   console.log(`\n⏰ Last Updated: ${timestamp}`);
 }
@@ -143,11 +358,14 @@ function getStatusIcon(status) {
 }
 
 function formatUptime(seconds) {
-  const hours = Math.floor(seconds / 3600);
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
   const minutes = Math.floor((seconds % 3600) / 60);
   const secs = seconds % 60;
   
-  if (hours > 0) {
+  if (days > 0) {
+    return `${days}d ${hours}h ${minutes}m`;
+  } else if (hours > 0) {
     return `${hours}h ${minutes}m ${secs}s`;
   } else if (minutes > 0) {
     return `${minutes}m ${secs}s`;

package/src/cli/simple-commands/swarm-ui.js

@@ -23,6 +23,7 @@ class SwarmUI {
     this.updateInterval = null;
     this.logBuffer = [];
     this.maxLogLines = 100;
+    this.activeProcesses = new Map(); // Track active processes for cross-platform termination
   }
 
   async init() {
@@ -500,7 +501,7 @@ class SwarmUI {
       '',
       'Task Data:',
       JSON.stringify(task.task, null, 2)
-    ].join('\\n');
+    ].join('\n');
 
     this.taskDetails.setContent(details);
     this.screen.render();
@@ -550,7 +551,11 @@ class SwarmUI {
 
       process.unref();
       
-      this.log(`Launched swarm with PID: ${process.pid}`);
+      // Track the process for later termination
+      const processId = `swarm-${Date.now()}`;
+      this.activeProcesses.set(processId, process);
+      
+      this.log(`Launched swarm with PID: ${process.pid} (ID: ${processId})`);
       
       // Update data after a delay
       setTimeout(() => {
@@ -566,16 +571,32 @@ class SwarmUI {
     this.log('Stopping all swarm operations...');
     
     try {
-      // Kill all swarm processes (simplified)
-      const { exec } = require('child_process');
-      exec('pkill -f "claude-flow swarm"', (error) => {
-        if (error) {
-          this.log(`Error stopping swarm: ${error.message}`, 'error');
-        } else {
-          this.log('Swarm operations stopped');
+      // Cross-platform process termination
+      let stoppedCount = 0;
+      
+      // First, try to stop tracked processes
+      for (const [processId, process] of this.activeProcesses) {
+        try {
+          // Use process.kill() for cross-platform compatibility
+          if (process.pid && !process.killed) {
+            process.kill('SIGTERM');
+            stoppedCount++;
+            this.log(`Stopped process ${processId} (PID: ${process.pid})`);
+          }
+        } catch (err) {
+          // Process might already be dead
+          this.log(`Process ${processId} already terminated`, 'warn');
         }
-      });
-
+      }
+      
+      // Clear the tracked processes
+      this.activeProcesses.clear();
+      
+      // Also find and stop any orphaned processes
+      await this.stopOrphanedProcesses();
+      
+      this.log(`Swarm operations stopped (${stoppedCount} processes terminated)`);
+      
       // Update display
       this.swarmData.status = 'stopped';
       this.updateDisplay();
@@ -585,6 +606,50 @@ class SwarmUI {
     }
   }
 
+  async stopOrphanedProcesses() {
+    // Cross-platform approach to find and stop orphaned processes
+    const { exec } = require('child_process');
+    const os = require('os');
+    
+    if (os.platform() === 'win32') {
+      // Windows: Use wmic to find and kill processes
+      exec('wmic process where "commandline like \'%claude-flow swarm%\'" get processid', (error, stdout) => {
+        if (!error && stdout) {
+          const pids = stdout.split('\n')
+            .map(line => line.trim())
+            .filter(line => /^\d+$/.test(line));
+          
+          pids.forEach(pid => {
+            exec(`taskkill /F /PID ${pid}`, (killError) => {
+              if (!killError) {
+                this.log(`Stopped orphaned process PID: ${pid}`);
+              }
+            });
+          });
+        }
+      });
+    } else {
+      // Unix-like systems: Use ps and grep
+      exec('ps aux | grep "claude-flow swarm" | grep -v grep', (error, stdout) => {
+        if (!error && stdout) {
+          const lines = stdout.split('\n').filter(line => line.trim());
+          lines.forEach(line => {
+            const parts = line.split(/\s+/);
+            const pid = parts[1];
+            if (pid && /^\d+$/.test(pid)) {
+              try {
+                process.kill(parseInt(pid), 'SIGTERM');
+                this.log(`Stopped orphaned process PID: ${pid}`);
+              } catch (killError) {
+                // Process might not exist or no permission
+              }
+            }
+          });
+        }
+      });
+    }
+  }
+
   async executeCommand(command) {
     this.log(`Executing command: ${command}`);
     
@@ -629,6 +694,18 @@ class SwarmUI {
     if (this.updateInterval) {
       clearInterval(this.updateInterval);
     }
+    
+    // Clean up any remaining processes
+    for (const [processId, process] of this.activeProcesses) {
+      try {
+        if (process.pid && !process.killed) {
+          process.kill('SIGTERM');
+        }
+      } catch (err) {
+        // Ignore errors during cleanup
+      }
+    }
+    this.activeProcesses.clear();
   }
 }
 

package/src/cli/simple-commands/task.js

@@ -1,5 +1,6 @@
-// task.js - Task management commands
+// task.js - Task management commands with improved argument parsing
 import { printSuccess, printError, printWarning } from '../utils.js';
+import { Command } from 'commander';
 
 export async function taskCommand(subArgs, flags) {
   const taskCmd = subArgs[0];
@@ -35,8 +36,32 @@ export async function taskCommand(subArgs, flags) {
 }
 
 async function createTask(subArgs, flags) {
-  const taskType = subArgs[1];
-  const description = subArgs.slice(2).join(' ');
+  // Use commander for robust argument parsing
+  const program = new Command()
+    .exitOverride()
+    .allowUnknownOption()
+    .option('--priority <value>', 'Set task priority (1-10)', '5');
+
+  try {
+    // Parse the arguments starting from the create command
+    program.parse(subArgs, { from: 'user' });
+  } catch (err) {
+    // Continue even if commander throws
+  }
+
+  const opts = program.opts();
+  const args = program.args;
+  
+  // Extract task type and description with proper quote handling
+  const taskType = args[1]; // First arg after 'create'
+  
+  // Join remaining args for description, handling quoted strings properly
+  let description = '';
+  if (args.length > 2) {
+    // If the description starts with a quote, find the matching end quote
+    const descriptionArgs = args.slice(2);
+    description = parseQuotedDescription(descriptionArgs);
+  }
   
   if (!taskType || !description) {
     printError('Usage: task create <type> "<description>"');
@@ -45,7 +70,7 @@ async function createTask(subArgs, flags) {
   }
   
   const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  const priority = getFlag(subArgs, '--priority') || '5';
+  const priority = opts.priority || '5';
   
   printSuccess(`Creating ${taskType} task: ${taskId}`);
   console.log(`📋 Description: ${description}`);
@@ -55,9 +80,41 @@ async function createTask(subArgs, flags) {
   console.log('\n📋 Note: Task queued for execution when orchestrator starts');
 }
 
+function parseQuotedDescription(args) {
+  const fullString = args.join(' ');
+  
+  // Check if it starts with a quote
+  if (fullString.startsWith('"') || fullString.startsWith("'")) {
+    const quoteChar = fullString[0];
+    const endIndex = fullString.lastIndexOf(quoteChar);
+    
+    if (endIndex > 0) {
+      // Extract the quoted content
+      return fullString.substring(1, endIndex);
+    }
+  }
+  
+  // If not quoted or improperly quoted, return the full string
+  return fullString;
+}
+
 async function listTasks(subArgs, flags) {
-  const filter = getFlag(subArgs, '--filter');
-  const verbose = subArgs.includes('--verbose') || subArgs.includes('-v');
+  const program = new Command()
+    .exitOverride()
+    .allowUnknownOption()
+    .option('--filter <status>', 'Filter by task status')
+    .option('--verbose', 'Show detailed output')
+    .option('-v', 'Show detailed output');
+
+  try {
+    program.parse(subArgs, { from: 'user' });
+  } catch (err) {
+    // Continue
+  }
+
+  const opts = program.opts();
+  const filter = opts.filter;
+  const verbose = opts.verbose || opts.v;
   
   printSuccess('Task queue:');
   
@@ -142,11 +199,6 @@ async function manageCoordination(subArgs, flags) {
   }
 }
 
-function getFlag(args, flagName) {
-  const index = args.indexOf(flagName);
-  return index !== -1 && index + 1 < args.length ? args[index + 1] : null;
-}
-
 function showTaskHelp() {
   console.log('Task commands:');
   console.log('  create <type> "<description>"    Create new task');

package/src/cli/swarm-standalone.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env -S deno run --allow-all
 /**
  * Standalone swarm executable for npm package
  * This handles swarm execution when installed via npm
@@ -8,7 +7,7 @@ import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { existsSync } from 'node:fs';
-import { Deno, cwd, exit, existsSync } from '../node-compat.js';
+import { Deno, cwd, exit } from './node-compat.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -224,11 +223,11 @@ Use all available tools including file operations, web search, and code executio
     }
   }
   
-  const deno = spawn(Deno.execPath(), ['run', '--allow-all', swarmPath, ...swarmArgs], {
+  const node = spawn('node', [swarmPath, ...swarmArgs], {
     stdio: 'inherit'
   });
   
-  deno.on('exit', (code) => {
-    Deno.exit(code || 0);
+  node.on('exit', (code) => {
+    exit(code || 0);
   });
 }

package/src/index.js

@@ -8,7 +8,7 @@ app.use(cors());
 app.use(express.json());
 
 app.get('/', (req, res) => {
-  res.json({ message: 'Welcome to project2 API' });
+  res.json({ message: 'Welcome to Claude-Flow API' });
 });
 
 app.listen(PORT, () => {

package/src/mcp/mcp-server.js

@@ -15,7 +15,7 @@ const __dirname = path.dirname(__filename);
 
 class ClaudeFlowMCPServer {
   constructor() {
-    this.version = '2.0.0-alpha.55';
+    this.version = '2.0.0-alpha.56';
     this.memoryStore = new EnhancedMemory();
     this.capabilities = {
       tools: {