kynjal-cli 4.0.0 → 4.0.2

package/dist/src/commands/daemon.js

@@ -2,62 +2,6 @@
  * V3 CLI Daemon Command
  * Manages background worker daemon (Node.js-based, similar to shell helpers)
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { output } from '../output.js';
 import { getDaemon, startDaemon, stopDaemon } from '../services/worker-daemon.js';
 import { spawn } from 'child_process';
@@ -65,13 +9,13 @@ import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
 import * as fs from 'fs';
 // Start daemon subcommand
-var startCommand = {
+const startCommand = {
     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: '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)' },
         { name: 'headless', type: 'boolean', description: 'Enable headless worker execution (E2B sandbox)' },
         { name: 'sandbox', type: 'string', description: 'Default sandbox mode for headless workers', choices: ['strict', 'permissive', 'disabled'] },
@@ -84,255 +28,248 @@ var startCommand = {
         { command: 'claude-flow daemon start -w map,audit,optimize', description: 'Start with specific workers' },
         { command: 'claude-flow daemon start --headless --sandbox strict', description: 'Start with headless workers in strict sandbox' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var quiet, foreground, projectRoot, isDaemonProcess, config, rawMaxCpu, rawMinMem, NUMERIC_RE, sanitize, thresholds, val, val, bgPid, stateDir, pidFile_1, cleanup_1, spinner, daemon, status, error_1;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    quiet = ctx.flags.quiet;
-                    foreground = ctx.flags.foreground;
-                    projectRoot = process.cwd();
-                    isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
-                    config = {};
-                    rawMaxCpu = ctx.flags['max-cpu-load'];
-                    rawMinMem = ctx.flags['min-free-memory'];
-                    NUMERIC_RE = /^\d+(\.\d+)?$/;
-                    sanitize = function (s) { return s.replace(/[\x00-\x1f\x7f-\x9f]/g, ''); };
-                    if (rawMaxCpu || rawMinMem) {
-                        thresholds = {};
-                        if (rawMaxCpu) {
-                            val = parseFloat(rawMaxCpu);
-                            if (NUMERIC_RE.test(rawMaxCpu) && isFinite(val) && val > 0 && val <= 1000) {
-                                thresholds.maxCpuLoad = val;
-                            }
-                            else if (!quiet) {
-                                output.printWarning("Ignoring invalid --max-cpu-load value: " + sanitize(rawMaxCpu));
-                            }
-                        }
-                        if (rawMinMem) {
-                            val = parseFloat(rawMinMem);
-                            if (NUMERIC_RE.test(rawMinMem) && isFinite(val) && val >= 0 && val <= 100) {
-                                thresholds.minFreeMemoryPercent = val;
-                            }
-                            else if (!quiet) {
-                                output.printWarning("Ignoring invalid --min-free-memory value: " + sanitize(rawMinMem));
-                            }
-                        }
-                        if (thresholds.maxCpuLoad !== undefined || thresholds.minFreeMemoryPercent !== undefined) {
-                            config.resourceThresholds = thresholds;
-                        }
-                    }
-                    // Check if background daemon already running (skip if we ARE the daemon process)
-                    if (!isDaemonProcess) {
-                        bgPid = getBackgroundDaemonPid(projectRoot);
-                        if (bgPid && isProcessRunning(bgPid)) {
-                            if (!quiet) {
-                                output.printWarning("Daemon already running in background (PID: " + bgPid + ")");
-                            }
-                            return [2 /*return*/, { success: true }];
-                        }
-                    }
-                    // Background mode (default): fork a detached process
-                    if (!foreground) {
-                        return [2 /*return*/, startBackgroundDaemon(projectRoot, quiet, rawMaxCpu, rawMinMem)];
-                    }
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 8, , 9]);
-                    stateDir = join(projectRoot, '.claude-flow');
-                    pidFile_1 = join(stateDir, 'daemon.pid');
-                    // Ensure state directory exists
-                    if (!fs.existsSync(stateDir)) {
-                        fs.mkdirSync(stateDir, { recursive: true });
-                    }
-                    // Write PID file for foreground mode
-                    fs.writeFileSync(pidFile_1, String(process.pid));
-                    cleanup_1 = function () {
-                        try {
-                            if (fs.existsSync(pidFile_1)) {
-                                fs.unlinkSync(pidFile_1);
-                            }
-                        }
-                        catch ( /* ignore */_a) { /* ignore */ }
-                    };
-                    process.on('exit', cleanup_1);
-                    process.on('SIGINT', function () { cleanup_1(); process.exit(0); });
-                    process.on('SIGTERM', function () { cleanup_1(); process.exit(0); });
-                    // Ignore SIGHUP on macOS/Linux — prevents daemon death when terminal closes (#1283)
-                    if (process.platform !== 'win32') {
-                        process.on('SIGHUP', function () { });
+    action: async (ctx) => {
+        const quiet = ctx.flags.quiet;
+        const foreground = ctx.flags.foreground;
+        const projectRoot = process.cwd();
+        const isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
+        // Parse resource threshold overrides from CLI flags
+        const config = {};
+        const rawMaxCpu = ctx.flags['max-cpu-load'];
+        const rawMinMem = ctx.flags['min-free-memory'];
+        // Strict numeric pattern to prevent command injection when forwarding to subprocess (S1)
+        const NUMERIC_RE = /^\d+(\.\d+)?$/;
+        const sanitize = (s) => s.replace(/[\x00-\x1f\x7f-\x9f]/g, '');
+        if (rawMaxCpu || rawMinMem) {
+            const thresholds = {};
+            if (rawMaxCpu) {
+                const val = parseFloat(rawMaxCpu);
+                if (NUMERIC_RE.test(rawMaxCpu) && isFinite(val) && val > 0 && val <= 1000) {
+                    thresholds.maxCpuLoad = val;
+                }
+                else if (!quiet) {
+                    output.printWarning(`Ignoring invalid --max-cpu-load value: ${sanitize(rawMaxCpu)}`);
+                }
+            }
+            if (rawMinMem) {
+                const val = parseFloat(rawMinMem);
+                if (NUMERIC_RE.test(rawMinMem) && isFinite(val) && val >= 0 && val <= 100) {
+                    thresholds.minFreeMemoryPercent = val;
+                }
+                else if (!quiet) {
+                    output.printWarning(`Ignoring invalid --min-free-memory value: ${sanitize(rawMinMem)}`);
+                }
+            }
+            if (thresholds.maxCpuLoad !== undefined || thresholds.minFreeMemoryPercent !== undefined) {
+                config.resourceThresholds = thresholds;
+            }
+        }
+        // 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, rawMaxCpu, rawMinMem);
+        }
+        // Foreground mode: run in current process (blocks terminal)
+        try {
+            const stateDir = join(projectRoot, '.claude-flow');
+            const pidFile = join(stateDir, 'daemon.pid');
+            // Ensure state directory exists
+            if (!fs.existsSync(stateDir)) {
+                fs.mkdirSync(stateDir, { recursive: true });
+            }
+            // Write PID file for foreground mode
+            fs.writeFileSync(pidFile, String(process.pid));
+            // Clean up PID file on exit
+            const cleanup = () => {
+                try {
+                    if (fs.existsSync(pidFile)) {
+                        fs.unlinkSync(pidFile);
                     }
-                    if (!!quiet) return [3 /*break*/, 4];
-                    spinner = output.createSpinner({ text: 'Starting worker daemon...', spinner: 'dots' });
-                    spinner.start();
-                    return [4 /*yield*/, startDaemon(projectRoot, config)];
-                case 2:
-                    daemon = _b.sent();
-                    status = daemon.getStatus();
-                    spinner.succeed('Worker daemon started (foreground mode)');
-                    output.writeln();
-                    output.printBox([
-                        "PID: " + status.pid,
-                        "Started: " + ((_a = status.startedAt) === null || _a === void 0 ? void 0 : _a.toISOString()),
-                        "Workers: " + status.config.workers.filter(function (w) { return w.enabled; }).length + " enabled",
-                        "Max Concurrent: " + status.config.maxConcurrent,
-                        "Max CPU Load: " + status.config.resourceThresholds.maxCpuLoad,
-                        "Min Free Memory: " + status.config.resourceThresholds.minFreeMemoryPercent + "%",
-                    ].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(function (w) { return w.enabled; })
-                            .map(function (w) { return ({
-                            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', function (_a) {
-                        var type = _a.type;
-                        output.writeln(output.dim("[daemon] Worker starting: " + type));
-                    });
-                    daemon.on('worker:complete', function (_a) {
-                        var type = _a.type, durationMs = _a.durationMs;
-                        output.writeln(output.success("[daemon] Worker completed: " + type + " (" + durationMs + "ms)"));
-                    });
-                    daemon.on('worker:error', function (_a) {
-                        var type = _a.type, error = _a.error;
-                        output.writeln(output.error("[daemon] Worker failed: " + type + " - " + error));
-                    });
-                    // Keep process alive
-                    return [4 /*yield*/, new Promise(function () { })];
-                case 3:
-                    // Keep process alive
-                    _b.sent(); // Never resolves - daemon runs until killed
-                    return [3 /*break*/, 7];
-                case 4: return [4 /*yield*/, startDaemon(projectRoot, config)];
-                case 5:
-                    _b.sent();
-                    return [4 /*yield*/, new Promise(function () { })];
-                case 6:
-                    _b.sent(); // Keep alive
-                    _b.label = 7;
-                case 7: return [2 /*return*/, { success: true }];
-                case 8:
-                    error_1 = _b.sent();
-                    output.printError("Failed to start daemon: " + (error_1 instanceof Error ? error_1.message : String(error_1)));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 9: return [2 /*return*/];
+                }
+                catch { /* ignore */ }
+            };
+            process.on('exit', cleanup);
+            process.on('SIGINT', () => { cleanup(); process.exit(0); });
+            process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+            // Ignore SIGHUP on macOS/Linux — prevents daemon death when terminal closes (#1283)
+            if (process.platform !== 'win32') {
+                process.on('SIGHUP', () => { });
+            }
+            if (!quiet) {
+                const spinner = output.createSpinner({ text: 'Starting worker daemon...', spinner: 'dots' });
+                spinner.start();
+                const daemon = await startDaemon(projectRoot, config);
+                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}`,
+                    `Max CPU Load: ${status.config.resourceThresholds.maxCpuLoad}`,
+                    `Min Free Memory: ${status.config.resourceThresholds.minFreeMemoryPercent}%`,
+                ].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 }) => {
+                    output.writeln(output.dim(`[daemon] Worker starting: ${type}`));
+                });
+                daemon.on('worker:complete', ({ type, durationMs }) => {
+                    output.writeln(output.success(`[daemon] Worker completed: ${type} (${durationMs}ms)`));
+                });
+                daemon.on('worker:error', ({ type, error }) => {
+                    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, config);
+                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 };
+        }
+    },
 };
 /**
  * Validate path for security - prevents path traversal and injection
  */
 function validatePath(path, label) {
     // Must be absolute after resolution
-    var resolved = resolve(path);
+    const resolved = resolve(path);
     // Check for null bytes (injection attack)
     if (path.includes('\0')) {
-        throw new Error(label + " contains null bytes");
+        throw new Error(`${label} contains null bytes`);
     }
     // Check for shell metacharacters in path components
     if (/[;&|`$<>]/.test(path)) {
-        throw new Error(label + " contains shell metacharacters");
+        throw new Error(`${label} contains shell metacharacters`);
     }
     // Prevent path traversal outside expected directories
     if (!resolved.includes('.claude-flow') && !resolved.includes('bin')) {
         // Allow only paths within project structure
-        var cwd = process.cwd();
+        const cwd = process.cwd();
         if (!resolved.startsWith(cwd)) {
-            throw new Error(label + " escapes project directory");
+            throw new Error(`${label} escapes project directory`);
         }
     }
 }
 /**
  * Start daemon as a detached background process
  */
-function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemory) {
-    return __awaiter(this, void 0, Promise, function () {
-        var resolvedRoot, stateDir, pidFile, logFile, __filename, __dirname, cliPath, isWin, spawnOpts, spawnArgs, SPAWN_NUMERIC_RE, child, pid;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    resolvedRoot = resolve(projectRoot);
-                    validatePath(resolvedRoot, 'Project root');
-                    stateDir = join(resolvedRoot, '.claude-flow');
-                    pidFile = join(stateDir, 'daemon.pid');
-                    logFile = join(stateDir, 'daemon.log');
-                    // Validate all paths
-                    validatePath(stateDir, 'State directory');
-                    validatePath(pidFile, 'PID file');
-                    validatePath(logFile, 'Log file');
-                    // Ensure state directory exists
-                    if (!fs.existsSync(stateDir)) {
-                        fs.mkdirSync(stateDir, { recursive: true });
-                    }
-                    __filename = fileURLToPath(import.meta.url);
-                    __dirname = dirname(__filename);
-                    cliPath = resolve(join(__dirname, '..', '..', '..', 'bin', 'cli.js'));
-                    validatePath(cliPath, 'CLI path');
-                    // Verify CLI path exists
-                    if (!fs.existsSync(cliPath)) {
-                        output.printError("CLI not found at: " + cliPath);
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    isWin = process.platform === 'win32';
-                    spawnOpts = __assign({ cwd: resolvedRoot, detached: !isWin, stdio: ['ignore', fs.openSync(logFile, 'a'), fs.openSync(logFile, 'a')], env: __assign(__assign(__assign({}, process.env), { CLAUDE_FLOW_DAEMON: '1' }), (process.platform === 'darwin' ? { NOHUP: '1' } : {})) }, (isWin ? { shell: true, windowsHide: true } : {}));
-                    spawnArgs = [
-                        cliPath,
-                        'daemon', 'start', '--foreground', '--quiet',
-                    ];
-                    SPAWN_NUMERIC_RE = /^\d+(\.\d+)?$/;
-                    if (maxCpuLoad && SPAWN_NUMERIC_RE.test(maxCpuLoad)) {
-                        spawnArgs.push('--max-cpu-load', maxCpuLoad);
-                    }
-                    if (minFreeMemory && SPAWN_NUMERIC_RE.test(minFreeMemory)) {
-                        spawnArgs.push('--min-free-memory', minFreeMemory);
-                    }
-                    child = spawn(process.execPath, spawnArgs, spawnOpts);
-                    pid = child.pid;
-                    if (!pid || pid <= 0) {
-                        output.printError('Failed to get daemon PID');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    // Unref BEFORE writing PID file — prevents race where parent exits
-                    // but child hasn't fully detached yet (fixes macOS daemon death #1283)
-                    child.unref();
-                    // Small delay to let the child process fully detach on macOS
-                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
-                case 1:
-                    // Small delay to let the child process fully detach on macOS
-                    _a.sent();
-                    // Save PID only after child is detached
-                    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");
-                    }
-                    return [2 /*return*/, { success: true }];
-            }
-        });
-    });
+async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemory) {
+    // Validate and resolve project root
+    const resolvedRoot = resolve(projectRoot);
+    validatePath(resolvedRoot, 'Project root');
+    const stateDir = join(resolvedRoot, '.claude-flow');
+    const pidFile = join(stateDir, 'daemon.pid');
+    const logFile = join(stateDir, 'daemon.log');
+    // Validate all paths
+    validatePath(stateDir, 'State directory');
+    validatePath(pidFile, 'PID file');
+    validatePath(logFile, 'Log file');
+    // 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 = resolve(join(__dirname, '..', '..', '..', 'bin', 'cli.js'));
+    validatePath(cliPath, 'CLI path');
+    // Verify CLI path exists
+    if (!fs.existsSync(cliPath)) {
+        output.printError(`CLI not found at: ${cliPath}`);
+        return { success: false, exitCode: 1 };
+    }
+    // Platform-aware spawn flags
+    const isWin = process.platform === 'win32';
+    const spawnOpts = {
+        cwd: resolvedRoot,
+        detached: !isWin, // detached is POSIX-only; Windows uses windowsHide
+        stdio: ['ignore', fs.openSync(logFile, 'a'), fs.openSync(logFile, 'a')],
+        env: {
+            ...process.env,
+            CLAUDE_FLOW_DAEMON: '1',
+            // Prevent macOS SIGHUP kill when terminal closes
+            ...(process.platform === 'darwin' ? { NOHUP: '1' } : {}),
+        },
+        ...(isWin ? { shell: true, windowsHide: true } : {}),
+    };
+    // Use spawn with explicit arguments instead of shell string interpolation
+    // This prevents command injection via paths
+    const spawnArgs = [
+        cliPath,
+        'daemon', 'start', '--foreground', '--quiet',
+    ];
+    // Forward resource threshold flags to the foreground child process
+    // Validate with strict numeric pattern to prevent shell injection on Windows (S1)
+    const SPAWN_NUMERIC_RE = /^\d+(\.\d+)?$/;
+    if (maxCpuLoad && SPAWN_NUMERIC_RE.test(maxCpuLoad)) {
+        spawnArgs.push('--max-cpu-load', maxCpuLoad);
+    }
+    if (minFreeMemory && SPAWN_NUMERIC_RE.test(minFreeMemory)) {
+        spawnArgs.push('--min-free-memory', minFreeMemory);
+    }
+    const child = spawn(process.execPath, spawnArgs, spawnOpts);
+    // Get PID from spawned process directly (no shell echo needed)
+    const pid = child.pid;
+    if (!pid || pid <= 0) {
+        output.printError('Failed to get daemon PID');
+        return { success: false, exitCode: 1 };
+    }
+    // Unref BEFORE writing PID file — prevents race where parent exits
+    // but child hasn't fully detached yet (fixes macOS daemon death #1283)
+    child.unref();
+    // Small delay to let the child process fully detach on macOS
+    await new Promise(resolve => setTimeout(resolve, 100));
+    // Save PID only after child is detached
+    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`);
+    }
+    return { success: true };
 }
 // Stop daemon subcommand
-var stopCommand = {
+const stopCommand = {
     name: 'stop',
     description: 'Stop the worker daemon and all background workers',
     options: [
@@ -341,121 +278,93 @@ var stopCommand = {
     examples: [
         { command: 'claude-flow daemon stop', description: 'Stop the daemon' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var quiet, projectRoot, spinner, killed, error_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    quiet = ctx.flags.quiet;
-                    projectRoot = process.cwd();
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 8, , 9]);
-                    if (!!quiet) return [3 /*break*/, 4];
-                    spinner = output.createSpinner({ text: 'Stopping worker daemon...', spinner: 'dots' });
-                    spinner.start();
-                    // Try to stop in-process daemon first
-                    return [4 /*yield*/, stopDaemon()];
-                case 2:
-                    // Try to stop in-process daemon first
-                    _a.sent();
-                    return [4 /*yield*/, killBackgroundDaemon(projectRoot)];
-                case 3:
-                    killed = _a.sent();
-                    spinner.succeed(killed ? 'Worker daemon stopped' : 'Worker daemon was not running');
-                    return [3 /*break*/, 7];
-                case 4: return [4 /*yield*/, stopDaemon()];
-                case 5:
-                    _a.sent();
-                    return [4 /*yield*/, killBackgroundDaemon(projectRoot)];
-                case 6:
-                    _a.sent();
-                    _a.label = 7;
-                case 7: return [2 /*return*/, { success: true }];
-                case 8:
-                    error_2 = _a.sent();
-                    output.printError("Failed to stop daemon: " + (error_2 instanceof Error ? error_2.message : String(error_2)));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 9: return [2 /*return*/];
+    action: async (ctx) => {
+        const quiet = ctx.flags.quiet;
+        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
  */
-function killBackgroundDaemon(projectRoot) {
-    return __awaiter(this, void 0, Promise, function () {
-        var pidFile, pid, error_3;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
-                    if (!fs.existsSync(pidFile)) {
-                        return [2 /*return*/, false];
-                    }
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-                    if (isNaN(pid)) {
-                        fs.unlinkSync(pidFile);
-                        return [2 /*return*/, false];
-                    }
-                    // Check if process is running
-                    try {
-                        process.kill(pid, 0); // Signal 0 = check if alive
-                    }
-                    catch (_b) {
-                        // Process not running, clean up stale PID file
-                        fs.unlinkSync(pidFile);
-                        return [2 /*return*/, false];
-                    }
-                    // Kill the process
-                    process.kill(pid, 'SIGTERM');
-                    // Wait a moment then force kill if needed
-                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
-                case 2:
-                    // Wait a moment then force kill if needed
-                    _a.sent();
-                    try {
-                        process.kill(pid, 0);
-                        // Still alive, force kill
-                        process.kill(pid, 'SIGKILL');
-                    }
-                    catch (_c) {
-                        // Process terminated
-                    }
-                    // Clean up PID file
-                    if (fs.existsSync(pidFile)) {
-                        fs.unlinkSync(pidFile);
-                    }
-                    return [2 /*return*/, true];
-                case 3:
-                    error_3 = _a.sent();
-                    // Clean up PID file on any error
-                    if (fs.existsSync(pidFile)) {
-                        fs.unlinkSync(pidFile);
-                    }
-                    return [2 /*return*/, false];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
+async function killBackgroundDaemon(projectRoot) {
+    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) {
-    var pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
+    const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
     if (!fs.existsSync(pidFile)) {
         return null;
     }
     try {
-        var pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+        const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
         return isNaN(pid) ? null : pid;
     }
-    catch (_a) {
+    catch {
         return null;
     }
 }
@@ -467,12 +376,12 @@ function isProcessRunning(pid) {
         process.kill(pid, 0); // Signal 0 = check if alive
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
 // Status subcommand
-var statusCommand = {
+const statusCommand = {
     name: 'status',
     description: 'Show daemon and worker status',
     options: [
@@ -484,111 +393,109 @@ var statusCommand = {
         { command: 'claude-flow daemon status -v', description: 'Show detailed status' },
         { command: 'claude-flow daemon status --show-modes', description: 'Show worker execution modes' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var verbose, showModes, projectRoot, daemon, status_1, bgPid, bgRunning, isRunning, displayPid, statusIcon, statusText, mode, workerData, baseColumns, modeColumns;
-        return __generator(this, function (_a) {
-            verbose = ctx.flags.verbose;
-            showModes = ctx.flags['show-modes'];
-            projectRoot = process.cwd();
-            try {
-                daemon = getDaemon(projectRoot);
-                status_1 = daemon.getStatus();
-                bgPid = getBackgroundDaemonPid(projectRoot);
-                bgRunning = bgPid ? isProcessRunning(bgPid) : false;
-                isRunning = status_1.running || bgRunning;
-                displayPid = bgPid || status_1.pid;
-                output.writeln();
-                statusIcon = isRunning ? output.success('●') : output.error('○');
-                statusText = isRunning ? output.success('RUNNING') : output.error('STOPPED');
-                mode = bgRunning ? output.dim(' (background)') : status_1.running ? output.dim(' (foreground)') : '';
-                output.printBox([
-                    "Status: " + statusIcon + " " + statusText + mode,
-                    "PID: " + displayPid,
-                    status_1.startedAt ? "Started: " + status_1.startedAt.toISOString() : '',
-                    "Workers Enabled: " + status_1.config.workers.filter(function (w) { return w.enabled; }).length,
-                    "Max Concurrent: " + status_1.config.maxConcurrent,
-                    "Max CPU Load: " + status_1.config.resourceThresholds.maxCpuLoad,
-                    "Min Free Memory: " + status_1.config.resourceThresholds.minFreeMemoryPercent + "%",
-                ].filter(Boolean).join('\n'), 'RuFlo Daemon');
+    action: async (ctx) => {
+        const verbose = ctx.flags.verbose;
+        const showModes = ctx.flags['show-modes'];
+        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}`,
+                `Max CPU Load: ${status.config.resourceThresholds.maxCpuLoad}`,
+                `Min Free Memory: ${status.config.resourceThresholds.minFreeMemoryPercent}%`,
+            ].filter(Boolean).join('\n'), 'RuFlo Daemon');
+            output.writeln();
+            output.writeln(output.bold('Worker Status'));
+            const workerData = status.config.workers.map(w => {
+                const state = status.workers.get(w.type);
+                // Check for headless mode from worker config or state
+                const isHeadless = w.headless || state?.headless || false;
+                const sandboxMode = w.sandbox || state?.sandbox || null;
+                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('-'),
+                    mode: isHeadless ? output.highlight('headless') : output.dim('local'),
+                    sandbox: isHeadless ? (sandboxMode || 'strict') : output.dim('-'),
+                };
+            });
+            // Build columns based on --show-modes flag
+            const baseColumns = [
+                { 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 },
+            ];
+            const modeColumns = showModes ? [
+                { key: 'mode', header: 'Mode', width: 10 },
+                { key: 'sandbox', header: 'Sandbox', width: 12 },
+            ] : [];
+            output.printTable({
+                columns: [...baseColumns, ...modeColumns],
+                data: workerData,
+            });
+            if (verbose) {
                 output.writeln();
-                output.writeln(output.bold('Worker Status'));
-                workerData = status_1.config.workers.map(function (w) {
-                    var _a, _b, _c;
-                    var state = status_1.workers.get(w.type);
-                    // Check for headless mode from worker config or state
-                    var isHeadless = w.headless || ((_a = state) === null || _a === void 0 ? void 0 : _a.headless) || false;
-                    var sandboxMode = w.sandbox || ((_b = state) === null || _b === void 0 ? void 0 : _b.sandbox) || null;
-                    return {
-                        type: w.enabled ? output.highlight(w.type) : output.dim(w.type),
-                        enabled: w.enabled ? output.success('✓') : output.dim('○'),
-                        status: (state === null || state === void 0 ? void 0 : state.isRunning) ? output.warning('running') :
-                            w.enabled ? output.success('idle') : output.dim('disabled'),
-                        runs: (_c = state === null || state === void 0 ? void 0 : state.runCount) !== null && _c !== void 0 ? _c : 0,
-                        success: state ? Math.round((state.successCount / Math.max(state.runCount, 1)) * 100) + "%" : '-',
-                        lastRun: (state === null || state === void 0 ? void 0 : state.lastRun) ? formatTimeAgo(state.lastRun) : output.dim('never'),
-                        nextRun: (state === null || state === void 0 ? void 0 : state.nextRun) && w.enabled ? formatTimeUntil(state.nextRun) : output.dim('-'),
-                        mode: isHeadless ? output.highlight('headless') : output.dim('local'),
-                        sandbox: isHeadless ? (sandboxMode || 'strict') : output.dim('-')
-                    };
-                });
-                baseColumns = [
-                    { 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 },
-                ];
-                modeColumns = showModes ? [
-                    { key: 'mode', header: 'Mode', width: 10 },
-                    { key: 'sandbox', header: 'Sandbox', width: 12 },
-                ] : [];
+                output.writeln(output.bold('Worker Configuration'));
                 output.printTable({
-                    columns: __spreadArray(__spreadArray([], baseColumns, true), modeColumns, true),
-                    data: workerData
+                    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,
+                        };
+                    }),
                 });
-                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_1.config.workers.map(function (w) {
-                            var state = status_1.workers.get(w.type);
-                            return {
-                                type: w.type,
-                                interval: Math.round(w.intervalMs / 60000) + "min",
-                                priority: w.priority,
-                                avgDuration: (state === null || state === void 0 ? void 0 : state.averageDurationMs) ? Math.round(state.averageDurationMs) + "ms" : '-',
-                                description: w.description
-                            };
-                        })
-                    });
-                }
-                return [2 /*return*/, { success: true, data: status_1 }];
             }
-            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'), 'RuFlo Daemon');
-                return [2 /*return*/, { success: true }];
-            }
-            return [2 /*return*/];
-        });
-    }); }
+            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'), 'RuFlo Daemon');
+            return { success: true };
+        }
+    },
 };
 // Trigger subcommand - manually run a worker
-var triggerCommand = {
+const triggerCommand = {
     name: 'trigger',
     description: 'Manually trigger a specific worker',
     options: [
@@ -600,50 +507,40 @@ var triggerCommand = {
         { command: 'claude-flow daemon trigger -w audit', description: 'Trigger security audit' },
         { command: 'claude-flow daemon trigger -w audit --headless', description: 'Trigger audit in headless sandbox' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var workerType, daemon, spinner, result, error_4;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    workerType = ctx.flags.worker;
-                    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 [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    daemon = getDaemon(process.cwd());
-                    spinner = output.createSpinner({ text: "Running " + workerType + " worker...", spinner: 'dots' });
-                    spinner.start();
-                    return [4 /*yield*/, daemon.triggerWorker(workerType)];
-                case 2:
-                    result = _a.sent();
-                    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 [2 /*return*/, { success: result.success, data: result }];
-                case 3:
-                    error_4 = _a.sent();
-                    output.printError("Failed to trigger worker: " + (error_4 instanceof Error ? error_4.message : String(error_4)));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 4: return [2 /*return*/];
+    action: async (ctx) => {
+        const workerType = ctx.flags.worker;
+        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
-var enableCommand = {
+const enableCommand = {
     name: 'enable',
     description: 'Enable or disable a specific worker',
     options: [
@@ -654,54 +551,50 @@ var enableCommand = {
         { command: 'claude-flow daemon enable -w predict', description: 'Enable predict worker' },
         { command: 'claude-flow daemon enable -w document --disable', description: 'Disable document worker' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var workerType, disable, daemon;
-        return __generator(this, function (_a) {
-            workerType = ctx.flags.worker;
-            disable = ctx.flags.disable;
-            if (!workerType) {
-                output.printError('Worker type is required. Use --worker or -w flag.');
-                return [2 /*return*/, { success: false, exitCode: 1 }];
-            }
-            try {
-                daemon = getDaemon(process.cwd());
-                daemon.setWorkerEnabled(workerType, !disable);
-                output.printSuccess("Worker " + workerType + " " + (disable ? 'disabled' : 'enabled'));
-                return [2 /*return*/, { success: true }];
-            }
-            catch (error) {
-                output.printError("Failed to " + (disable ? 'disable' : 'enable') + " worker: " + (error instanceof Error ? error.message : String(error)));
-                return [2 /*return*/, { success: false, exitCode: 1 }];
-            }
-            return [2 /*return*/];
-        });
-    }); }
+    action: async (ctx) => {
+        const workerType = ctx.flags.worker;
+        const disable = ctx.flags.disable;
+        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) {
-    var seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
     if (seconds < 60)
-        return seconds + "s ago";
+        return `${seconds}s ago`;
     if (seconds < 3600)
-        return Math.floor(seconds / 60) + "m ago";
+        return `${Math.floor(seconds / 60)}m ago`;
     if (seconds < 86400)
-        return Math.floor(seconds / 3600) + "h ago";
-    return Math.floor(seconds / 86400) + "d ago";
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
 }
 function formatTimeUntil(date) {
-    var seconds = Math.floor((date.getTime() - Date.now()) / 1000);
+    const seconds = Math.floor((date.getTime() - Date.now()) / 1000);
     if (seconds < 0)
         return 'now';
     if (seconds < 60)
-        return "in " + seconds + "s";
+        return `in ${seconds}s`;
     if (seconds < 3600)
-        return "in " + Math.floor(seconds / 60) + "m";
+        return `in ${Math.floor(seconds / 60)}m`;
     if (seconds < 86400)
-        return "in " + Math.floor(seconds / 3600) + "h";
-    return "in " + Math.floor(seconds / 86400) + "d";
+        return `in ${Math.floor(seconds / 3600)}h`;
+    return `in ${Math.floor(seconds / 86400)}d`;
 }
 // Main daemon command
-export var daemonCommand = {
+export const daemonCommand = {
     name: 'daemon',
     description: 'Manage background worker daemon (Node.js-based, auto-runs like shell helpers)',
     subcommands: [
@@ -719,47 +612,45 @@ export var daemonCommand = {
         { command: 'claude-flow daemon stop', description: 'Stop the daemon' },
         { command: 'claude-flow daemon trigger -w audit', description: 'Run security audit' },
     ],
-    action: function () { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('RuFlo 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('Headless Mode'));
-            output.writeln('Workers can run in headless mode using E2B sandboxes for isolated execution.');
-            output.writeln('Use --headless flag with start/trigger commands. Sandbox modes: strict, permissive, disabled.');
-            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 [2 /*return*/, { success: true }];
-        });
-    }); }
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('RuFlo 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('Headless Mode'));
+        output.writeln('Workers can run in headless mode using E2B sandboxes for isolated execution.');
+        output.writeln('Use --headless flag with start/trigger commands. Sandbox modes: strict, permissive, disabled.');
+        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;
 //# sourceMappingURL=daemon.js.map