@claude-flow/cli 3.0.0-alpha.7 → 3.0.0-alpha.9

package/src/commands/daemon.ts

@@ -6,6 +6,10 @@
 import type { Command, CommandContext, CommandResult } from '../types.js';
 import { output } from '../output.js';
 import { WorkerDaemon, getDaemon, startDaemon, stopDaemon, type WorkerType } from '../services/worker-daemon.js';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import * as fs from 'fs';
 
 // Start daemon subcommand
 const startCommand: Command = {
@@ -14,15 +18,37 @@ const startCommand: Command = {
   options: [
     { name: 'workers', short: 'w', type: 'string', description: 'Comma-separated list of workers to enable (default: map,audit,optimize,consolidate,testgaps)' },
     { name: 'quiet', short: 'q', type: 'boolean', description: 'Suppress output' },
+    { name: 'background', short: 'b', type: 'boolean', description: 'Run daemon in background (detached process)', default: true },
+    { name: 'foreground', short: 'f', type: 'boolean', description: 'Run daemon in foreground (blocks terminal)' },
   ],
   examples: [
-    { command: 'claude-flow daemon start', description: 'Start daemon with default workers' },
+    { command: 'claude-flow daemon start', description: 'Start daemon in background (default)' },
+    { command: 'claude-flow daemon start --foreground', description: 'Start in foreground (blocks terminal)' },
     { command: 'claude-flow daemon start -w map,audit,optimize', description: 'Start with specific workers' },
   ],
   action: async (ctx: CommandContext): Promise<CommandResult> => {
     const quiet = ctx.flags.quiet as boolean;
+    const foreground = ctx.flags.foreground as boolean;
     const projectRoot = process.cwd();
+    const isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
+
+    // Check if background daemon already running (skip if we ARE the daemon process)
+    if (!isDaemonProcess) {
+      const bgPid = getBackgroundDaemonPid(projectRoot);
+      if (bgPid && isProcessRunning(bgPid)) {
+        if (!quiet) {
+          output.printWarning(`Daemon already running in background (PID: ${bgPid})`);
+        }
+        return { success: true };
+      }
+    }
 
+    // Background mode (default): fork a detached process
+    if (!foreground) {
+      return startBackgroundDaemon(projectRoot, quiet);
+    }
+
+    // Foreground mode: run in current process (blocks terminal)
     try {
       if (!quiet) {
         const spinner = output.createSpinner({ text: 'Starting worker daemon...', spinner: 'dots' });
@@ -31,7 +57,7 @@ const startCommand: Command = {
         const daemon = await startDaemon(projectRoot);
         const status = daemon.getStatus();
 
-        spinner.succeed('Worker daemon started');
+        spinner.succeed('Worker daemon started (foreground mode)');
 
         output.writeln();
         output.printBox(
@@ -65,6 +91,9 @@ const startCommand: Command = {
             })),
         });
 
+        output.writeln();
+        output.writeln(output.dim('Press Ctrl+C to stop daemon'));
+
         // Listen for worker events
         daemon.on('worker:start', ({ type }: { type: string }) => {
           output.writeln(output.dim(`[daemon] Worker starting: ${type}`));
@@ -77,8 +106,12 @@ const startCommand: Command = {
         daemon.on('worker:error', ({ type, error }: { type: string; error: string }) => {
           output.writeln(output.error(`[daemon] Worker failed: ${type} - ${error}`));
         });
+
+        // Keep process alive
+        await new Promise(() => {}); // Never resolves - daemon runs until killed
       } else {
         await startDaemon(projectRoot);
+        await new Promise(() => {}); // Keep alive
       }
 
       return { success: true };
@@ -89,6 +122,75 @@ const startCommand: Command = {
   },
 };
 
+/**
+ * Start daemon as a detached background process
+ */
+async function startBackgroundDaemon(projectRoot: string, quiet: boolean): Promise<CommandResult> {
+  const stateDir = join(projectRoot, '.claude-flow');
+  const pidFile = join(stateDir, 'daemon.pid');
+  const logFile = join(stateDir, 'daemon.log');
+
+  // Ensure state directory exists
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
+  }
+
+  // Get path to CLI (from dist/src/commands/daemon.js -> bin/cli.js)
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  // dist/src/commands -> dist/src -> dist -> package root -> bin/cli.js
+  const cliPath = join(__dirname, '..', '..', '..', 'bin', 'cli.js');
+
+  // Verify CLI path exists
+  if (!fs.existsSync(cliPath)) {
+    output.printError(`CLI not found at: ${cliPath}`);
+    return { success: false, exitCode: 1 };
+  }
+
+  // Use shell to spawn daemon with proper output redirection
+  // This ensures the log file stays open even after parent exits
+  const shellCmd = `"${process.execPath}" "${cliPath}" daemon start --foreground --quiet >> "${logFile}" 2>&1 & echo $!`;
+
+  const child = spawn('sh', ['-c', shellCmd], {
+    cwd: projectRoot,
+    detached: true,
+    stdio: ['ignore', 'pipe', 'ignore'],
+    env: { ...process.env, CLAUDE_FLOW_DAEMON: '1' },
+  });
+
+  // Wait for the PID to be echoed back
+  return new Promise((resolve) => {
+    let pidStr = '';
+    child.stdout?.on('data', (data: Buffer) => {
+      pidStr += data.toString();
+    });
+
+    child.on('close', () => {
+      const pid = parseInt(pidStr.trim(), 10);
+
+      if (isNaN(pid) || pid <= 0) {
+        output.printError('Failed to get daemon PID');
+        resolve({ success: false, exitCode: 1 });
+        return;
+      }
+
+      // Save PID
+      fs.writeFileSync(pidFile, String(pid));
+
+      if (!quiet) {
+        output.printSuccess(`Daemon started in background (PID: ${pid})`);
+        output.printInfo(`Logs: ${logFile}`);
+        output.printInfo(`Stop with: claude-flow daemon stop`);
+      }
+
+      resolve({ success: true });
+    });
+
+    // Unref so parent can exit immediately
+    child.unref();
+  });
+}
+
 // Stop daemon subcommand
 const stopCommand: Command = {
   name: 'stop',
@@ -101,17 +203,23 @@ const stopCommand: Command = {
   ],
   action: async (ctx: CommandContext): Promise<CommandResult> => {
     const quiet = ctx.flags.quiet as boolean;
+    const projectRoot = process.cwd();
 
     try {
       if (!quiet) {
         const spinner = output.createSpinner({ text: 'Stopping worker daemon...', spinner: 'dots' });
         spinner.start();
 
+        // Try to stop in-process daemon first
         await stopDaemon();
 
-        spinner.succeed('Worker daemon stopped');
+        // Also kill any background daemon by PID
+        const killed = await killBackgroundDaemon(projectRoot);
+
+        spinner.succeed(killed ? 'Worker daemon stopped' : 'Worker daemon was not running');
       } else {
         await stopDaemon();
+        await killBackgroundDaemon(projectRoot);
       }
 
       return { success: true };
@@ -122,6 +230,92 @@ const stopCommand: Command = {
   },
 };
 
+/**
+ * Kill background daemon process using PID file
+ */
+async function killBackgroundDaemon(projectRoot: string): Promise<boolean> {
+  const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
+
+  if (!fs.existsSync(pidFile)) {
+    return false;
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+
+    if (isNaN(pid)) {
+      fs.unlinkSync(pidFile);
+      return false;
+    }
+
+    // Check if process is running
+    try {
+      process.kill(pid, 0); // Signal 0 = check if alive
+    } catch {
+      // Process not running, clean up stale PID file
+      fs.unlinkSync(pidFile);
+      return false;
+    }
+
+    // Kill the process
+    process.kill(pid, 'SIGTERM');
+
+    // Wait a moment then force kill if needed
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    try {
+      process.kill(pid, 0);
+      // Still alive, force kill
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      // Process terminated
+    }
+
+    // Clean up PID file
+    if (fs.existsSync(pidFile)) {
+      fs.unlinkSync(pidFile);
+    }
+
+    return true;
+  } catch (error) {
+    // Clean up PID file on any error
+    if (fs.existsSync(pidFile)) {
+      fs.unlinkSync(pidFile);
+    }
+    return false;
+  }
+}
+
+/**
+ * Get PID of background daemon from PID file
+ */
+function getBackgroundDaemonPid(projectRoot: string): number | null {
+  const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
+
+  if (!fs.existsSync(pidFile)) {
+    return null;
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a process is running
+ */
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0); // Signal 0 = check if alive
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // Status subcommand
 const statusCommand: Command = {
   name: 'status',
@@ -135,21 +329,30 @@ const statusCommand: Command = {
   ],
   action: async (ctx: CommandContext): Promise<CommandResult> => {
     const verbose = ctx.flags.verbose as boolean;
+    const projectRoot = process.cwd();
 
     try {
-      const daemon = getDaemon(process.cwd());
+      const daemon = getDaemon(projectRoot);
       const status = daemon.getStatus();
 
+      // Also check for background daemon
+      const bgPid = getBackgroundDaemonPid(projectRoot);
+      const bgRunning = bgPid ? isProcessRunning(bgPid) : false;
+
+      const isRunning = status.running || bgRunning;
+      const displayPid = bgPid || status.pid;
+
       output.writeln();
 
       // Daemon status box
-      const statusIcon = status.running ? output.success('●') : output.error('○');
-      const statusText = status.running ? output.success('RUNNING') : output.error('STOPPED');
+      const statusIcon = isRunning ? output.success('●') : output.error('○');
+      const statusText = isRunning ? output.success('RUNNING') : output.error('STOPPED');
+      const mode = bgRunning ? output.dim(' (background)') : status.running ? output.dim(' (foreground)') : '';
 
       output.printBox(
         [
-          `Status: ${statusIcon} ${statusText}`,
-          `PID: ${status.pid}`,
+          `Status: ${statusIcon} ${statusText}${mode}`,
+          `PID: ${displayPid}`,
           status.startedAt ? `Started: ${status.startedAt.toISOString()}` : '',
           `Workers Enabled: ${status.config.workers.filter(w => w.enabled).length}`,
           `Max Concurrent: ${status.config.maxConcurrent}`,

package/src/index.ts

@@ -78,6 +78,21 @@ export class CLI {
         this.output.setColorEnabled(false);
       }
 
+      // Set verbosity level based on flags
+      if (flags.quiet) {
+        this.output.setVerbosity('quiet');
+      } else if (flags.verbose) {
+        this.output.setVerbosity(process.env.DEBUG ? 'debug' : 'verbose');
+      }
+
+      // Verbose mode: show parsed arguments
+      if (this.output.isVerbose()) {
+        this.output.printDebug(`Command: ${commandPath.join(' ') || '(none)'}`);
+        this.output.printDebug(`Positional: [${positional.join(', ')}]`);
+        this.output.printDebug(`Flags: ${JSON.stringify(Object.fromEntries(Object.entries(flags).filter(([k]) => k !== '_')))}`);
+        this.output.printDebug(`CWD: ${process.cwd()}`);
+      }
+
       // No command - show help
       if (commandPath.length === 0 || flags.help || flags.h) {
         if (commandPath.length > 0) {
@@ -176,8 +191,17 @@ export class CLI {
 
       // Execute command
       if (targetCommand.action) {
+        if (this.output.isVerbose()) {
+          this.output.printDebug(`Executing: ${targetCommand.name}`);
+        }
+
+        const startTime = Date.now();
         const result = await targetCommand.action(ctx);
 
+        if (this.output.isVerbose()) {
+          this.output.printDebug(`Completed in ${Date.now() - startTime}ms`);
+        }
+
         if (result && !result.success) {
           process.exit(result.exitCode || 1);
         }
@@ -379,7 +403,7 @@ export * from './types.js';
 export { CommandParser, commandParser } from './parser.js';
 
 // Output
-export { OutputFormatter, output, Progress, Spinner } from './output.js';
+export { OutputFormatter, output, Progress, Spinner, type VerbosityLevel } from './output.js';
 
 // Prompt
 export * from './prompt.js';

package/src/output.ts

@@ -50,15 +50,46 @@ const COLORS = {
 
 type ColorName = keyof typeof COLORS;
 
+export type VerbosityLevel = 'quiet' | 'normal' | 'verbose' | 'debug';
+
 export class OutputFormatter {
   private colorEnabled: boolean;
   private outputStream: NodeJS.WriteStream;
   private errorStream: NodeJS.WriteStream;
+  private verbosity: VerbosityLevel;
 
-  constructor(options: { color?: boolean } = {}) {
+  constructor(options: { color?: boolean; verbosity?: VerbosityLevel } = {}) {
     this.colorEnabled = options.color ?? this.supportsColor();
     this.outputStream = process.stdout;
     this.errorStream = process.stderr;
+    this.verbosity = options.verbosity ?? 'normal';
+  }
+
+  /**
+   * Set verbosity level
+   * - quiet: Only errors and direct results
+   * - normal: Errors, warnings, info, and results
+   * - verbose: All of normal + debug messages
+   * - debug: All output including trace
+   */
+  setVerbosity(level: VerbosityLevel): void {
+    this.verbosity = level;
+  }
+
+  getVerbosity(): VerbosityLevel {
+    return this.verbosity;
+  }
+
+  isQuiet(): boolean {
+    return this.verbosity === 'quiet';
+  }
+
+  isVerbose(): boolean {
+    return this.verbosity === 'verbose' || this.verbosity === 'debug';
+  }
+
+  isDebug(): boolean {
+    return this.verbosity === 'debug';
   }
 
   private supportsColor(): boolean {
@@ -136,11 +167,13 @@ export class OutputFormatter {
   // ============================================
 
   printSuccess(message: string): void {
+    // Success always shows (result output)
     const icon = this.color('[OK]', 'green', 'bold');
     this.writeln(`${icon} ${message}`);
   }
 
   printError(message: string, details?: string): void {
+    // Errors always show
     const icon = this.color('[ERROR]', 'red', 'bold');
     this.writeErrorln(`${icon} ${message}`);
     if (details) {
@@ -149,20 +182,33 @@ export class OutputFormatter {
   }
 
   printWarning(message: string): void {
+    // Warnings suppressed in quiet mode
+    if (this.verbosity === 'quiet') return;
     const icon = this.color('[WARN]', 'yellow', 'bold');
     this.writeln(`${icon} ${message}`);
   }
 
   printInfo(message: string): void {
+    // Info suppressed in quiet mode
+    if (this.verbosity === 'quiet') return;
     const icon = this.color('[INFO]', 'blue', 'bold');
     this.writeln(`${icon} ${message}`);
   }
 
   printDebug(message: string): void {
+    // Debug only shows in verbose/debug mode
+    if (this.verbosity !== 'verbose' && this.verbosity !== 'debug') return;
     const icon = this.color('[DEBUG]', 'gray');
     this.writeln(`${icon} ${this.dim(message)}`);
   }
 
+  printTrace(message: string): void {
+    // Trace only shows in debug mode
+    if (this.verbosity !== 'debug') return;
+    const icon = this.color('[TRACE]', 'gray', 'dim');
+    this.writeln(`${icon} ${this.dim(message)}`);
+  }
+
   // ============================================
   // Table Formatting
   // ============================================