claude-flow 3.0.0-alpha.8 → 3.0.0-alpha.9

package/src/commands/daemon.ts

@@ -0,0 +1,598 @@
+/**
+ * V3 CLI Daemon Command
+ * Manages background worker daemon (Node.js-based, similar to shell helpers)
+ */
+
+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 = {
+  name: 'start',
+  description: 'Start the worker daemon with all enabled background workers',
+  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 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' });
+        spinner.start();
+
+        const daemon = await startDaemon(projectRoot);
+        const status = daemon.getStatus();
+
+        spinner.succeed('Worker daemon started (foreground mode)');
+
+        output.writeln();
+        output.printBox(
+          [
+            `PID: ${status.pid}`,
+            `Started: ${status.startedAt?.toISOString()}`,
+            `Workers: ${status.config.workers.filter(w => w.enabled).length} enabled`,
+            `Max Concurrent: ${status.config.maxConcurrent}`,
+          ].join('\n'),
+          'Daemon Status'
+        );
+
+        output.writeln();
+        output.writeln(output.bold('Scheduled Workers'));
+        output.printTable({
+          columns: [
+            { key: 'type', header: 'Worker', width: 15 },
+            { key: 'interval', header: 'Interval', width: 12 },
+            { key: 'priority', header: 'Priority', width: 10 },
+            { key: 'description', header: 'Description', width: 30 },
+          ],
+          data: status.config.workers
+            .filter(w => w.enabled)
+            .map(w => ({
+              type: output.highlight(w.type),
+              interval: `${Math.round(w.intervalMs / 60000)}min`,
+              priority: w.priority === 'critical' ? output.error(w.priority) :
+                       w.priority === 'high' ? output.warning(w.priority) :
+                       output.dim(w.priority),
+              description: w.description,
+            })),
+        });
+
+        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}`));
+        });
+
+        daemon.on('worker:complete', ({ type, durationMs }: { type: string; durationMs: number }) => {
+          output.writeln(output.success(`[daemon] Worker completed: ${type} (${durationMs}ms)`));
+        });
+
+        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 };
+    } catch (error) {
+      output.printError(`Failed to start daemon: ${error instanceof Error ? error.message : String(error)}`);
+      return { success: false, exitCode: 1 };
+    }
+  },
+};
+
+/**
+ * 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',
+  description: 'Stop the worker daemon and all background workers',
+  options: [
+    { name: 'quiet', short: 'q', type: 'boolean', description: 'Suppress output' },
+  ],
+  examples: [
+    { command: 'claude-flow daemon stop', description: 'Stop the daemon' },
+  ],
+  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();
+
+        // 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 };
+    } catch (error) {
+      output.printError(`Failed to stop daemon: ${error instanceof Error ? error.message : String(error)}`);
+      return { success: false, exitCode: 1 };
+    }
+  },
+};
+
+/**
+ * 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',
+  description: 'Show daemon and worker status',
+  options: [
+    { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed worker statistics' },
+  ],
+  examples: [
+    { command: 'claude-flow daemon status', description: 'Show daemon status' },
+    { command: 'claude-flow daemon status -v', description: 'Show detailed status' },
+  ],
+  action: async (ctx: CommandContext): Promise<CommandResult> => {
+    const verbose = ctx.flags.verbose as boolean;
+    const projectRoot = process.cwd();
+
+    try {
+      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 = 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}${mode}`,
+          `PID: ${displayPid}`,
+          status.startedAt ? `Started: ${status.startedAt.toISOString()}` : '',
+          `Workers Enabled: ${status.config.workers.filter(w => w.enabled).length}`,
+          `Max Concurrent: ${status.config.maxConcurrent}`,
+        ].filter(Boolean).join('\n'),
+        'Worker Daemon'
+      );
+
+      output.writeln();
+      output.writeln(output.bold('Worker Status'));
+
+      const workerData = status.config.workers.map(w => {
+        const state = status.workers.get(w.type);
+        return {
+          type: w.enabled ? output.highlight(w.type) : output.dim(w.type),
+          enabled: w.enabled ? output.success('✓') : output.dim('○'),
+          status: state?.isRunning ? output.warning('running') :
+                  w.enabled ? output.success('idle') : output.dim('disabled'),
+          runs: state?.runCount ?? 0,
+          success: state ? `${Math.round((state.successCount / Math.max(state.runCount, 1)) * 100)}%` : '-',
+          lastRun: state?.lastRun ? formatTimeAgo(state.lastRun) : output.dim('never'),
+          nextRun: state?.nextRun && w.enabled ? formatTimeUntil(state.nextRun) : output.dim('-'),
+        };
+      });
+
+      output.printTable({
+        columns: [
+          { key: 'type', header: 'Worker', width: 12 },
+          { key: 'enabled', header: 'On', width: 4 },
+          { key: 'status', header: 'Status', width: 10 },
+          { key: 'runs', header: 'Runs', width: 6 },
+          { key: 'success', header: 'Success', width: 8 },
+          { key: 'lastRun', header: 'Last Run', width: 12 },
+          { key: 'nextRun', header: 'Next Run', width: 12 },
+        ],
+        data: workerData,
+      });
+
+      if (verbose) {
+        output.writeln();
+        output.writeln(output.bold('Worker Configuration'));
+        output.printTable({
+          columns: [
+            { key: 'type', header: 'Worker', width: 12 },
+            { key: 'interval', header: 'Interval', width: 10 },
+            { key: 'priority', header: 'Priority', width: 10 },
+            { key: 'avgDuration', header: 'Avg Duration', width: 12 },
+            { key: 'description', header: 'Description', width: 30 },
+          ],
+          data: status.config.workers.map(w => {
+            const state = status.workers.get(w.type);
+            return {
+              type: w.type,
+              interval: `${Math.round(w.intervalMs / 60000)}min`,
+              priority: w.priority,
+              avgDuration: state?.averageDurationMs ? `${Math.round(state.averageDurationMs)}ms` : '-',
+              description: w.description,
+            };
+          }),
+        });
+      }
+
+      return { success: true, data: status };
+    } catch (error) {
+      // Daemon not initialized
+      output.writeln();
+      output.printBox(
+        [
+          `Status: ${output.error('○')} ${output.error('NOT INITIALIZED')}`,
+          '',
+          'Run "claude-flow daemon start" to start the daemon',
+        ].join('\n'),
+        'Worker Daemon'
+      );
+
+      return { success: true };
+    }
+  },
+};
+
+// Trigger subcommand - manually run a worker
+const triggerCommand: Command = {
+  name: 'trigger',
+  description: 'Manually trigger a specific worker',
+  options: [
+    { name: 'worker', short: 'w', type: 'string', description: 'Worker type to trigger', required: true },
+  ],
+  examples: [
+    { command: 'claude-flow daemon trigger -w map', description: 'Trigger the map worker' },
+    { command: 'claude-flow daemon trigger -w audit', description: 'Trigger security audit' },
+  ],
+  action: async (ctx: CommandContext): Promise<CommandResult> => {
+    const workerType = ctx.flags.worker as WorkerType;
+
+    if (!workerType) {
+      output.printError('Worker type is required. Use --worker or -w flag.');
+      output.writeln();
+      output.writeln('Available workers: map, audit, optimize, consolidate, testgaps, predict, document, ultralearn, refactor, benchmark, deepdive, preload');
+      return { success: false, exitCode: 1 };
+    }
+
+    try {
+      const daemon = getDaemon(process.cwd());
+
+      const spinner = output.createSpinner({ text: `Running ${workerType} worker...`, spinner: 'dots' });
+      spinner.start();
+
+      const result = await daemon.triggerWorker(workerType);
+
+      if (result.success) {
+        spinner.succeed(`Worker ${workerType} completed in ${result.durationMs}ms`);
+
+        if (result.output) {
+          output.writeln();
+          output.writeln(output.bold('Output'));
+          output.printJson(result.output);
+        }
+      } else {
+        spinner.fail(`Worker ${workerType} failed: ${result.error}`);
+      }
+
+      return { success: result.success, data: result };
+    } catch (error) {
+      output.printError(`Failed to trigger worker: ${error instanceof Error ? error.message : String(error)}`);
+      return { success: false, exitCode: 1 };
+    }
+  },
+};
+
+// Enable/disable worker subcommand
+const enableCommand: Command = {
+  name: 'enable',
+  description: 'Enable or disable a specific worker',
+  options: [
+    { name: 'worker', short: 'w', type: 'string', description: 'Worker type', required: true },
+    { name: 'disable', short: 'd', type: 'boolean', description: 'Disable instead of enable' },
+  ],
+  examples: [
+    { command: 'claude-flow daemon enable -w predict', description: 'Enable predict worker' },
+    { command: 'claude-flow daemon enable -w document --disable', description: 'Disable document worker' },
+  ],
+  action: async (ctx: CommandContext): Promise<CommandResult> => {
+    const workerType = ctx.flags.worker as WorkerType;
+    const disable = ctx.flags.disable as boolean;
+
+    if (!workerType) {
+      output.printError('Worker type is required. Use --worker or -w flag.');
+      return { success: false, exitCode: 1 };
+    }
+
+    try {
+      const daemon = getDaemon(process.cwd());
+      daemon.setWorkerEnabled(workerType, !disable);
+
+      output.printSuccess(`Worker ${workerType} ${disable ? 'disabled' : 'enabled'}`);
+
+      return { success: true };
+    } catch (error) {
+      output.printError(`Failed to ${disable ? 'disable' : 'enable'} worker: ${error instanceof Error ? error.message : String(error)}`);
+      return { success: false, exitCode: 1 };
+    }
+  },
+};
+
+// Helper functions for time formatting
+function formatTimeAgo(date: Date): string {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+
+function formatTimeUntil(date: Date): string {
+  const seconds = Math.floor((date.getTime() - Date.now()) / 1000);
+
+  if (seconds < 0) return 'now';
+  if (seconds < 60) return `in ${seconds}s`;
+  if (seconds < 3600) return `in ${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) return `in ${Math.floor(seconds / 3600)}h`;
+  return `in ${Math.floor(seconds / 86400)}d`;
+}
+
+// Main daemon command
+export const daemonCommand: Command = {
+  name: 'daemon',
+  description: 'Manage background worker daemon (Node.js-based, auto-runs like shell helpers)',
+  subcommands: [
+    startCommand,
+    stopCommand,
+    statusCommand,
+    triggerCommand,
+    enableCommand,
+  ],
+  options: [],
+  examples: [
+    { command: 'claude-flow daemon start', description: 'Start the daemon' },
+    { command: 'claude-flow daemon status', description: 'Check daemon status' },
+    { command: 'claude-flow daemon stop', description: 'Stop the daemon' },
+    { command: 'claude-flow daemon trigger -w audit', description: 'Run security audit' },
+  ],
+  action: async (): Promise<CommandResult> => {
+    output.writeln();
+    output.writeln(output.bold('Worker Daemon - Background Task Management'));
+    output.writeln();
+    output.writeln('Node.js-based background worker system that auto-runs like shell daemons.');
+    output.writeln('Manages 12 specialized workers for continuous optimization and monitoring.');
+    output.writeln();
+
+    output.writeln(output.bold('Available Workers'));
+    output.printList([
+      `${output.highlight('map')}         - Codebase mapping (5 min interval)`,
+      `${output.highlight('audit')}       - Security analysis (10 min interval)`,
+      `${output.highlight('optimize')}    - Performance optimization (15 min interval)`,
+      `${output.highlight('consolidate')} - Memory consolidation (30 min interval)`,
+      `${output.highlight('testgaps')}    - Test coverage analysis (20 min interval)`,
+      `${output.highlight('predict')}     - Predictive preloading (2 min, disabled by default)`,
+      `${output.highlight('document')}    - Auto-documentation (60 min, disabled by default)`,
+      `${output.highlight('ultralearn')}  - Deep knowledge acquisition (manual trigger)`,
+      `${output.highlight('refactor')}    - Code refactoring suggestions (manual trigger)`,
+      `${output.highlight('benchmark')}   - Performance benchmarking (manual trigger)`,
+      `${output.highlight('deepdive')}    - Deep code analysis (manual trigger)`,
+      `${output.highlight('preload')}     - Resource preloading (manual trigger)`,
+    ]);
+
+    output.writeln();
+    output.writeln(output.bold('Subcommands'));
+    output.printList([
+      `${output.highlight('start')}   - Start the daemon`,
+      `${output.highlight('stop')}    - Stop the daemon`,
+      `${output.highlight('status')}  - Show daemon status`,
+      `${output.highlight('trigger')} - Manually run a worker`,
+      `${output.highlight('enable')}  - Enable/disable a worker`,
+    ]);
+
+    output.writeln();
+    output.writeln('Run "claude-flow daemon <subcommand> --help" for details');
+
+    return { success: true };
+  },
+};
+
+export default daemonCommand;