claude-flow 2.0.0-alpha.78 → 2.0.0-alpha.79

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

@@ -1,6 +1,7 @@
 // memory.js - Memory management commands
 import { printSuccess, printError, printWarning } from '../utils.js';
-import { Deno, cwd, exit, existsSync } from '../node-compat.js';
+import { promises as fs } from 'fs';
+import { cwd, exit, existsSync } from '../node-compat.js';
 
 export async function memoryCommand(subArgs, flags) {
   const memorySubcommand = subArgs[0];
@@ -9,7 +10,7 @@ export async function memoryCommand(subArgs, flags) {
   // Helper to load memory data
   async function loadMemory() {
     try {
-      const content = await Deno.readTextFile(memoryStore);
+      const content = await fs.readFile(memoryStore, 'utf8');
       return JSON.parse(content);
     } catch {
       return {};
@@ -18,8 +19,8 @@ export async function memoryCommand(subArgs, flags) {
 
   // Helper to save memory data
   async function saveMemory(data) {
-    await Deno.mkdir('./memory', { recursive: true });
-    await Deno.writeTextFile(memoryStore, JSON.stringify(data, null, 2));
+    await fs.mkdir('./memory', { recursive: true });
+    await fs.writeFile(memoryStore, JSON.stringify(data, null, 2, 'utf8'));
   }
 
   switch (memorySubcommand) {
@@ -185,7 +186,7 @@ async function exportMemory(subArgs, loadMemory) {
       exportData = { [namespace]: data[namespace] || [] };
     }
 
-    await Deno.writeTextFile(filename, JSON.stringify(exportData, null, 2));
+    await fs.writeFile(filename, JSON.stringify(exportData, null, 2, 'utf8'));
     printSuccess(`Memory exported to ${filename}`);
 
     let totalEntries = 0;
@@ -209,7 +210,7 @@ async function importMemory(subArgs, saveMemory) {
   }
 
   try {
-    const importContent = await Deno.readTextFile(filename);
+    const importContent = await fs.readFile(filename, 'utf8');
     const importData = JSON.parse(importContent);
 
     // Load existing memory
@@ -301,7 +302,7 @@ function getNamespaceFromArgs(subArgs) {
 // Helper to load memory data (needed for import function)
 async function loadMemory() {
   try {
-    const content = await Deno.readTextFile('./memory/memory-store.json');
+    const content = await fs.readFile('./memory/memory-store.json', 'utf8');
     return JSON.parse(content);
   } catch {
     return {};

package/src/cli/simple-commands/process-ui-enhanced.js

@@ -1,4 +1,4 @@
-// process-ui-enhanced.js - Enhanced process management UI with multiple views
+// process-ui-enhanced.js - Enhanced process management UI with multiple views - v2.0.0-alpha.79
 import { printSuccess, printError, printWarning, printInfo } from '../utils.js';
 import { compat } from '../runtime-detector.js';
 import SwarmWebUIIntegration from './swarm-webui-integration.js';
@@ -112,7 +112,7 @@ export class EnhancedProcessUI {
     console.clear();
 
     // Show welcome
-    printSuccess('🧠 Claude-Flow Process Management UI v1.0.71');
+    printSuccess('🧠 Claude-Flow Process Management UI v2.0.0-alpha.79-alpha.79');
     console.log('─'.repeat(80));
     console.log();
 

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

@@ -1,6 +1,6 @@
 // process-ui.js - Simple process management UI in pure JavaScript
 import { printSuccess, printError, printWarning, printInfo } from '../utils.js';
-import { Deno, cwd, exit, existsSync } from '../node-compat.js';
+import { cwd, exit, existsSync } from '../node-compat.js';
 import process from 'process';
 
 // Simple color utilities
@@ -151,7 +151,7 @@ export class ProcessUI {
         this.running = false;
         console.clear();
         printSuccess('Goodbye!');
-        Deno.exit(0); // Exit immediately
+        process.exit(0); // Exit immediately
         break;
 
       case 'a':

package/src/cli/simple-commands/sparc-modes/index.js

@@ -67,7 +67,7 @@ export function getModeOrchestration(modeSlug, taskDescription, memoryNamespace)
 export function createSparcPrompt(mode, taskDescription, memoryNamespace) {
   const orchestration = getModeOrchestration(mode.slug, taskDescription, memoryNamespace);
   // Get the actual working directory where the command was run from
-  const cwd = Deno.env.get('PWD') || Deno.cwd();
+  const cwd = process.env.PWD || process.cwd();
 
   return `# ${mode.name} - Task Execution
 

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

@@ -1,7 +1,10 @@
 // sparc.js - SPARC development mode commands
 import { printSuccess, printError, printWarning } from '../utils.js';
+import { promises as fs } from 'fs';
+import { spawn } from 'child_process';
+import { promisify } from 'util';
 import { createSparcPrompt } from './sparc-modes/index.js';
-import { Deno, cwd, exit, existsSync } from '../node-compat.js';
+import { cwd, exit, existsSync } from '../node-compat.js';
 import process from 'process';
 
 export async function sparcCommand(subArgs, flags) {
@@ -82,7 +85,7 @@ async function listSparcModes(subArgs) {
     const configPath = `${workingDir}/.roomodes`;
     let configContent;
     try {
-      configContent = await Deno.readTextFile(configPath);
+      configContent = await fs.readFile(configPath, 'utf8');
     } catch (error) {
       printError('SPARC configuration file (.roomodes) not found');
       console.log(`Please ensure .roomodes file exists in: ${workingDir}`);
@@ -134,7 +137,7 @@ async function showModeInfo(subArgs) {
     const configPath = `${workingDir}/.roomodes`;
     let configContent;
     try {
-      configContent = await Deno.readTextFile(configPath);
+      configContent = await fs.readFile(configPath, 'utf8');
     } catch (error) {
       printError('SPARC configuration file (.roomodes) not found');
       console.log(`Please ensure .roomodes file exists in: ${workingDir}`);
@@ -191,7 +194,7 @@ async function runSparcMode(subArgs, flags) {
     const configPath = `${workingDir}/.roomodes`;
     let configContent;
     try {
-      configContent = await Deno.readTextFile(configPath);
+      configContent = await fs.readFile(configPath, 'utf8');
     } catch (error) {
       printError('SPARC configuration file (.roomodes) not found');
       console.log(`Please ensure .roomodes file exists in: ${workingDir}`);
@@ -418,12 +421,16 @@ async function executeClaude(enhancedTask, toolsList, instanceId, memoryNamespac
 
     // Check if claude command exists
     try {
-      const checkCommand = new Deno.Command('which', {
-        args: ['claude'],
-        stdout: 'piped',
-        stderr: 'piped',
+      const checkResult = await new Promise((resolve) => {
+        const child = spawn('which', ['claude'], {
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        child.stdout?.on('data', (data) => { stdout += data; });
+        child.on('close', (code) => {
+          resolve({ success: code === 0, stdout: Buffer.from(stdout) });
+        });
       });
-      const checkResult = await checkCommand.output();
       if (!checkResult.success) {
         console.error('❌ Error: claude command not found in PATH');
         console.error('Please ensure claude CLI is installed and in your PATH');
@@ -435,25 +442,20 @@ async function executeClaude(enhancedTask, toolsList, instanceId, memoryNamespac
       console.warn('⚠️  Could not verify claude command location');
     }
 
-    const command = new Deno.Command('claude', {
-      args: claudeArgs,
-      cwd: cwd(), // Explicitly set working directory to current directory
-      env: {
-        ...Deno.env.toObject(),
-        CLAUDE_INSTANCE_ID: instanceId,
-        CLAUDE_SPARC_MODE: 'true',
-        CLAUDE_FLOW_MEMORY_ENABLED: 'true',
-        CLAUDE_FLOW_MEMORY_NAMESPACE: memoryNamespace,
-        CLAUDE_WORKING_DIRECTORY: cwd(), // Also pass as env variable
-      },
-      stdin: 'inherit',
-      stdout: 'inherit',
-      stderr: 'inherit',
-    });
+    // Use spawn for claude command
+    const env = { ...process.env, CLAUDE_INSTANCE_ID: instanceId };
 
     console.log('\n📡 Spawning claude process...\n');
-    const child = command.spawn();
-    const status = await child.status;
+    const child = spawn('claude', claudeArgs, {
+      cwd: cwd(),
+      env: env,
+      stdio: 'inherit'
+    });
+    const status = await new Promise((resolve) => {
+      child.on('close', (code) => {
+        resolve({ code, success: code === 0 });
+      });
+    });
 
     if (status.success) {
       printSuccess(`SPARC instance ${instanceId} completed successfully`);

package/src/cli/simple-commands/start-wrapper.js

@@ -1,6 +1,7 @@
 // start-wrapper.js - Wrapper to maintain backward compatibility with the new modular start command
 import { printSuccess, printError, printWarning, printInfo } from '../utils.js';
-import { Deno, cwd, exit, existsSync } from '../node-compat.js';
+import { promises as fs } from 'fs';
+import { cwd, exit, existsSync } from '../node-compat.js';
 import { compat } from '../runtime-detector.js';
 
 export async function startCommand(subArgs, flags) {
@@ -81,7 +82,7 @@ export async function startCommand(subArgs, flags) {
 
     for (const dir of requiredDirs) {
       try {
-        await Deno.stat(dir);
+        await fs.stat(dir);
       } catch {
         missingDirs.push(dir);
       }
@@ -137,10 +138,10 @@ export async function startCommand(subArgs, flags) {
       const pid = compat.terminal.getPid();
       await compat.safeCall(async () => {
         if (compat.runtime === 'deno') {
-          await Deno.writeTextFile('.claude-flow.pid', pid.toString());
+          await fs.writeFile('.claude-flow.pid', pid.toString(), 'utf8');
         } else {
           const fs = await import('fs/promises');
-          await fs.writeFile('.claude-flow.pid', pid.toString());
+          await fs.writeFile('.claude-flow.pid', pid.toString(), 'utf8');
         }
       });
       console.log(`Process ID: ${pid} (saved to .claude-flow.pid)`);
@@ -213,7 +214,7 @@ async function cleanup() {
   try {
     await compat.safeCall(async () => {
       if (compat.runtime === 'deno') {
-        await Deno.remove('.claude-flow.pid');
+        await fs.unlink('.claude-flow.pid');
       } else {
         const fs = await import('fs/promises');
         await fs.unlink('.claude-flow.pid');

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

@@ -1,6 +1,7 @@
 // status.js - System status and monitoring commands
 import { printSuccess, printError, printWarning } from '../utils.js';
-import { Deno } from '../node-compat.js';
+import { promises as fs } from 'fs';
+// Removed Deno import from '../node-compat.js';
 
 export async function statusCommand(subArgs, flags) {
   const verbose = subArgs.includes('--verbose') || subArgs.includes('-v') || flags.verbose;
@@ -18,7 +19,7 @@ export async function statusCommand(subArgs, flags) {
 async function getSystemStatus(verbose = false) {
   const status = {
     timestamp: Date.now(),
-    version: '1.0.71',
+    version: '2.0.0-alpha.79',
     orchestrator: {
       running: false,
       uptime: 0,
@@ -59,7 +60,7 @@ async function getSystemStatus(verbose = false) {
 async function getMemoryStats() {
   try {
     const memoryStore = './memory/memory-store.json';
-    const content = await Deno.readTextFile(memoryStore);
+    const content = await fs.readFile(memoryStore, 'utf8');
     const data = JSON.parse(content);
 
     let totalEntries = 0;

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

@@ -2,10 +2,16 @@
  * Simple Swarm Executor - Provides basic swarm functionality without TypeScript dependencies
  */
 
-import { generateId } from '../../utils/helpers.js';
 import { promises as fs } from 'fs';
 import path from 'path';
 
+// Simple ID generator to avoid build dependencies
+function generateId(prefix = 'id') {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 9);
+  return `${prefix}_${timestamp}_${random}`;
+}
+
 // Simple SwarmCoordinator implementation
 export class SwarmCoordinator {
   constructor(config) {
@@ -244,5 +250,4 @@ export async function executeSwarm(objective, flags = {}) {
   }
 }
 
-// Export for use in swarm.js
-export { SwarmCoordinator, executeSwarm };
+// Exports are already declared inline above

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

@@ -9,6 +9,139 @@ import { open } from 'fs/promises';
 import process from 'process';
 import path from 'path';
 
+/**
+ * Detects if the environment is headless (non-interactive)
+ */
+function isHeadlessEnvironment() {
+  // Check for common CI environment variables
+  const ciEnvironments = [
+    'CI',
+    'GITHUB_ACTIONS',
+    'GITLAB_CI',
+    'JENKINS_URL',
+    'CIRCLECI',
+    'TRAVIS',
+    'BUILDKITE',
+    'DRONE',
+    'DOCKER_CONTAINER',
+  ];
+  
+  const isCI = ciEnvironments.some(env => process.env[env]);
+  
+  // Check if running in Docker
+  const isDocker = existsSync('/.dockerenv') || 
+    (existsSync('/proc/1/cgroup') && 
+     require('fs').readFileSync('/proc/1/cgroup', 'utf8').includes('docker'));
+  
+  // Check TTY availability
+  const hasTTY = process.stdin.isTTY && process.stdout.isTTY;
+  
+  return isCI || isDocker || !hasTTY;
+}
+
+/**
+ * Basic swarm implementation for fallback scenarios
+ */
+async function basicSwarmNew(args, flags) {
+  const objective = (args || []).join(' ').trim();
+  
+  if (!objective) {
+    console.error('❌ Usage: swarm <objective>');
+    showSwarmHelp();
+    return;
+  }
+
+  const isHeadless = isHeadlessEnvironment();
+  
+  // Configure for headless mode
+  if (isHeadless) {
+    console.log('🤖 Headless environment detected - running in non-interactive mode');
+    flags = {
+      ...flags,
+      'non-interactive': true,
+      'output-format': flags['output-format'] || 'stream-json', // Use stream-json for Claude compatibility
+      'no-auto-permissions': false,
+    };
+  }
+
+  // Set up graceful shutdown handlers
+  const cleanup = () => {
+    console.log('\n🛑 Shutting down swarm gracefully...');
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', cleanup);
+  process.on('SIGINT', cleanup);
+
+  try {
+    // Try to use the swarm executor
+    const { executeSwarm } = await import('./swarm-executor.js');
+    
+    console.log(`🐝 Starting basic swarm execution...`);
+    console.log(`📋 Objective: ${objective}`);
+    console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
+    console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
+    console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
+    
+    if (isHeadless) {
+      console.log(`🖥️  Headless Mode: Enabled`);
+      console.log(`📄 Output Format: ${flags['output-format']}`);
+    }
+
+    const result = await executeSwarm(objective, flags);
+
+    // Handle output based on format
+    if (flags['output-format'] === 'json') {
+      // In JSON mode, output clean JSON
+      const output = {
+        success: result.success,
+        swarmId: result.summary?.swarmId,
+        objective: objective,
+        duration: result.summary?.duration,
+        agents: result.summary?.totalAgents,
+        tasks: result.summary?.totalTasks,
+        timestamp: new Date().toISOString(),
+      };
+      
+      if (flags['output-file']) {
+        const fs = await import('fs/promises');
+        await fs.writeFile(flags['output-file'], JSON.stringify(output, null, 2));
+        console.log(`✅ Output saved to: ${flags['output-file']}`);
+      } else {
+        console.log(JSON.stringify(output, null, 2));
+      }
+    } else {
+      // Text mode output
+      if (result.success) {
+        console.log(`\n✅ Swarm execution completed successfully!`);
+        if (result.summary) {
+          console.log(`   Duration: ${result.summary.duration}`);
+          console.log(`   Agents: ${result.summary.totalAgents}`);
+          console.log(`   Tasks: ${result.summary.totalTasks}`);
+        }
+      } else {
+        console.error(`\n❌ Swarm execution failed: ${result.error}`);
+      }
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`❌ Basic swarm execution error: ${error.message}`);
+    
+    // In headless mode, ensure we output JSON error
+    if (flags['output-format'] === 'json') {
+      const errorOutput = {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString(),
+      };
+      console.log(JSON.stringify(errorOutput, null, 2));
+    }
+    
+    throw error;
+  }
+}
+
 function showSwarmHelp() {
   console.log(`
 🐝 Claude Flow Advanced Swarm System
@@ -92,6 +225,21 @@ ADVANCED OPTIONS:
   --task-scheduling <type>   Task scheduling algorithm
   --load-balancing <type>    Load balancing method
   --fault-tolerance <type>   Fault tolerance strategy
+  --headless                 Force headless mode for CI/Docker environments
+  --health-check             Perform health check and exit (for Docker health)
+  --json-logs                Output all logs in JSON format for log aggregation
+
+HEADLESS MODE:
+  Automatically detected and enabled when running in:
+  - CI/CD environments (GitHub Actions, GitLab CI, Jenkins, etc.)
+  - Docker containers without TTY
+  - Non-interactive shells (no stdin/stdout TTY)
+  
+  In headless mode:
+  - Output defaults to JSON format
+  - Non-interactive mode is enabled
+  - Graceful shutdown on SIGTERM/SIGINT
+  - Suitable for containerized deployments
 
 For complete documentation and examples:
 https://github.com/ruvnet/claude-code-flow/docs/swarm.md
@@ -99,6 +247,39 @@ https://github.com/ruvnet/claude-code-flow/docs/swarm.md
 }
 
 export async function swarmCommand(args, flags) {
+  // Handle headless mode early
+  if (flags && flags.headless) {
+    const isHeadless = isHeadlessEnvironment();
+    // Configure for headless mode
+    flags = {
+      ...flags,
+      'non-interactive': true,
+      'output-format': flags['output-format'] || 'stream-json',
+      'no-auto-permissions': false,
+    };
+  }
+  
+  // Handle health check first
+  if (flags && flags['health-check']) {
+    try {
+      // Quick health check for Docker/K8s
+      console.log(JSON.stringify({
+        status: 'healthy',
+        service: 'claude-flow-swarm',
+        version: process.env.npm_package_version || '2.0.0',
+        timestamp: new Date().toISOString()
+      }));
+      process.exit(0);
+    } catch (error) {
+      console.error(JSON.stringify({
+        status: 'unhealthy',
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }));
+      process.exit(1);
+    }
+  }
+
   const objective = (args || []).join(' ').trim();
 
   if (!objective) {
@@ -107,18 +288,59 @@ export async function swarmCommand(args, flags) {
     return;
   }
 
+  // Force headless mode if flag is set
+  if (flags && flags.headless) {
+    const isHeadless = isHeadlessEnvironment();
+    if (!isHeadless) {
+      console.log('🤖 Forcing headless mode as requested');
+    }
+    flags = {
+      ...flags,
+      'non-interactive': true,
+      'output-format': flags['output-format'] || 'json',
+      'no-auto-permissions': false,
+    };
+  }
+
   // Handle JSON output format
   const outputFormat = flags && flags['output-format'];
   const outputFile = flags && flags['output-file'];
   const isJsonOutput = outputFormat === 'json';
   const isNonInteractive = isJsonOutput || (flags && flags['no-interactive']);
+  const useJsonLogs = flags && flags['json-logs'];
+
+  // Override console.log for JSON logs if requested
+  if (useJsonLogs) {
+    const originalLog = console.log;
+    const originalError = console.error;
+    
+    console.log = (...args) => {
+      originalLog(JSON.stringify({
+        level: 'info',
+        message: args.join(' '),
+        timestamp: new Date().toISOString(),
+        service: 'claude-flow-swarm'
+      }));
+    };
+    
+    console.error = (...args) => {
+      originalError(JSON.stringify({
+        level: 'error',
+        message: args.join(' '),
+        timestamp: new Date().toISOString(),
+        service: 'claude-flow-swarm'
+      }));
+    };
+  }
 
   // Handle analysis/read-only mode
   const isAnalysisMode = flags && (flags.analysis || flags['read-only']);
   const analysisMode = isAnalysisMode ? 'analysis' : 'standard';
 
-  // For JSON output, we need to ensure executor mode since Claude Code doesn't return structured JSON
-  if (isJsonOutput && !(flags && flags.executor)) {
+  // For JSON output, allow using Claude with stream-json format
+  // Only force executor mode if explicitly using 'json' format (not 'stream-json')
+  if (flags && flags['output-format'] === 'json' && !(flags && flags.executor)) {
+    // Keep backward compatibility - regular 'json' format uses executor
     flags = { ...(flags || {}), executor: true };
   }
 
@@ -568,12 +790,30 @@ The swarm should be self-documenting - use memory_store to save all important in
       // Pass the prompt directly as an argument to claude
       const claudeArgs = [swarmPrompt];
 
+      // Check if we're in non-interactive/headless mode
+      const isNonInteractive = flags['no-interactive'] || 
+                               flags['non-interactive'] || 
+                               flags['output-format'] === 'stream-json' ||
+                               isHeadlessEnvironment();
+
       // Add auto-permission flag by default for swarm mode (unless explicitly disabled)
       if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
         claudeArgs.push('--dangerously-skip-permissions');
-        console.log(
-          '🔓 Using --dangerously-skip-permissions by default for seamless swarm execution',
-        );
+        if (!isNonInteractive) {
+          console.log(
+            '🔓 Using --dangerously-skip-permissions by default for seamless swarm execution',
+          );
+        }
+      }
+
+      // Add non-interactive flags if needed
+      if (isNonInteractive) {
+        claudeArgs.push('-p'); // Print mode
+        claudeArgs.push('--output-format', 'stream-json'); // JSON streaming
+        claudeArgs.push('--verbose'); // Verbose output
+        
+        console.log('🤖 Running in non-interactive mode with Claude');
+        console.log('📋 Command: claude [prompt] -p --output-format stream-json --verbose');
       }
 
       // Spawn claude with the prompt as the first argument
@@ -582,13 +822,15 @@ The swarm should be self-documenting - use memory_store to save all important in
         shell: false,
       });
 
-      console.log('✓ Claude Code launched with swarm coordination prompt!');
-      console.log('\n🚀 The swarm coordination instructions have been injected into Claude Code');
-      console.log('   The prompt includes:');
-      console.log('   • Strategy-specific guidance for', strategy);
-      console.log('   • Coordination patterns for', mode, 'mode');
-      console.log('   • Recommended agents and MCP tool usage');
-      console.log('   • Complete workflow documentation\n');
+      if (!isNonInteractive) {
+        console.log('✓ Claude Code launched with swarm coordination prompt!');
+        console.log('\n🚀 The swarm coordination instructions have been injected into Claude Code');
+        console.log('   The prompt includes:');
+        console.log('   • Strategy-specific guidance for', strategy);
+        console.log('   • Coordination patterns for', mode, 'mode');
+        console.log('   • Recommended agents and MCP tool usage');
+        console.log('   • Complete workflow documentation\n');
+      }
 
       // Handle process events
       claudeProcess.on('error', (err) => {
@@ -640,7 +882,7 @@ The swarm should be self-documenting - use memory_store to save all important in
       // Create a script to run the swarm without background flag
       const scriptContent = `#!/usr/bin/env -S deno run --allow-all
 import { swarmCommand } from "${import.meta.url}";
-import { Deno, cwd, exit, existsSync } from '../node-compat.js';
+import { cwd, exit, existsSync } from '../node-compat.js';
 import process from 'process';
 
 // Remove background flag to prevent recursion
@@ -802,19 +1044,23 @@ exit 0
       const module = await import(distPath);
       swarmAction = module.swarmAction;
     } catch (distError) {
-      // Fallback to basic swarm functionality
-      console.log('🚀 Advanced swarm features not available, using basic mode');
-      return await basicSwarmNew(subArgs, flags);
+      // Instead of immediately falling back to basic mode, 
+      // continue to the Claude integration below
+      console.log('📦 Compiled swarm module not found, checking for Claude CLI...');
     }
 
-    // Create command context compatible with TypeScript version
-    const ctx = {
-      args: args || [],
-      flags: flags || {},
-      command: 'swarm',
-    };
-
-    await swarmAction(ctx);
+    // Only call swarmAction if it was successfully loaded
+    if (swarmAction) {
+      // Create command context compatible with TypeScript version
+      const ctx = {
+        args: args || [],
+        flags: flags || {},
+        command: 'swarm',
+      };
+
+      await swarmAction(ctx);
+      return; // Exit after successful execution
+    }
   } catch (error) {
     // If import fails (e.g., in node_modules), provide inline implementation
     if (

package/src/cli/simple-commands/webui-validator.js

@@ -4,6 +4,7 @@
  */
 
 import { compat } from '../runtime-detector.js';
+import { promises as fs } from 'fs';
 
 export class WebUIValidator {
   constructor() {
@@ -64,11 +65,11 @@ export class WebUIValidator {
       try {
         await compat.safeCall(async () => {
           if (compat.runtime === 'deno') {
-            await Deno.writeTextFile('.webui-test', 'test');
-            await Deno.remove('.webui-test');
+            await fs.writeFile('.webui-test', 'test', 'utf8');
+            await fs.unlink('.webui-test');
           } else {
             const fs = await import('fs/promises');
-            await fs.writeFile('.webui-test', 'test');
+            await fs.writeFile('.webui-test', 'test', 'utf8');
             await fs.unlink('.webui-test');
           }
         });