claude-flow 3.7.0-alpha.3 → 3.7.0-alpha.30

package/v3/@claude-flow/cli/dist/src/commands/daemon.js

@@ -21,6 +21,11 @@ const startCommand = {
         { name: 'sandbox', type: 'string', description: 'Default sandbox mode for headless workers', choices: ['strict', 'permissive', 'disabled'] },
         { name: 'max-cpu-load', type: 'string', description: 'Override maxCpuLoad resource threshold (e.g. 4.0)' },
         { name: 'min-free-memory', type: 'string', description: 'Override minFreeMemoryPercent resource threshold (e.g. 15)' },
+        // #1914: workspace root for this daemon. Set automatically when the
+        // background launcher forks the foreground child so the daemon process
+        // carries its workspace path in argv — `killStaleDaemons` then only
+        // reaps daemons belonging to the current workspace (ADR-014 scope).
+        { name: 'workspace', type: 'string', description: 'Workspace root for this daemon (internal — set automatically when forking)' },
     ],
     examples: [
         { command: 'claude-flow daemon start', description: 'Start daemon in background (default)' },
@@ -31,7 +36,9 @@ const startCommand = {
     action: async (ctx) => {
         const quiet = ctx.flags.quiet;
         const foreground = ctx.flags.foreground;
-        const projectRoot = process.cwd();
+        // #1914: a forked daemon child receives --workspace <root>; the launcher
+        // and interactive invocations have no flag and fall back to cwd.
+        const projectRoot = resolveWorkspaceFlag(ctx.flags.workspace) ?? process.cwd();
         const isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
         // Parse resource threshold overrides from CLI flags
         const config = {};
@@ -195,6 +202,37 @@ function validatePath(path, label) {
         }
     }
 }
+/**
+ * #1914: Resolve the `--workspace` flag to an absolute path, or return null
+ * if it is absent / not a usable string. Rejects values with null bytes or
+ * shell metacharacters (defence-in-depth — the value is later embedded in a
+ * forked child's argv and compared against `ps`/`tasklist` output).
+ */
+export function resolveWorkspaceFlag(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.includes('\0') || /[;&|`$<>]/.test(trimmed))
+        return null;
+    return resolve(trimmed);
+}
+/**
+ * #1914: True when a process command line (from `ps -eo command` on POSIX or
+ * the tasklist Window Title column on Windows) belongs to a daemon started
+ * for `workspaceRoot`. The launcher (`startBackgroundDaemon`) always appends
+ * `--workspace <root>` as the FINAL argv entry, so an exact trailing match
+ * after stripping trailing whitespace/quotes is unambiguous — even for
+ * workspace paths containing spaces — and never a bare path-prefix match,
+ * so workspace `/a/proj` does not reap `/a/proj-other`'s daemon. A daemon
+ * whose argv puts `--workspace` mid-list (only possible via a hand-rolled
+ * invocation) simply won't be auto-reaped — `daemon stop` still handles it
+ * via the PID file.
+ */
+export function daemonCommandLineBelongsToWorkspace(commandLine, workspaceRoot) {
+    return commandLine.replace(/[\s"']+$/u, '').endsWith(`--workspace ${workspaceRoot}`);
+}
 /**
  * Start daemon as a detached background process
  */
@@ -266,6 +304,10 @@ async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemo
     if (minFreeMemory && SPAWN_NUMERIC_RE.test(minFreeMemory)) {
         forkArgs.push('--min-free-memory', minFreeMemory);
     }
+    // #1914: stamp the workspace into argv (kept LAST) so the foreground daemon
+    // process is self-identifying and `killStaleDaemons` only reaps daemons
+    // belonging to this workspace. resolvedRoot was validatePath()'d above.
+    forkArgs.push('--workspace', resolvedRoot);
     const child = fork(cliPath, forkArgs, forkOpts);
     // Get PID from spawned process directly (no shell echo needed)
     const pid = child.pid;
@@ -391,22 +433,35 @@ async function killBackgroundDaemon(projectRoot) {
     }
 }
 /**
- * Kill stale daemon processes not tracked by the PID file (#1551).
- * Uses `ps` to find all daemon processes for this project and kills them.
+ * Kill stale daemon processes not tracked by the PID file (#1551, #1857).
+ * Uses `ps` on POSIX and `tasklist` on Windows to find all daemon
+ * processes for this project and kill them.
  */
 async function killStaleDaemons(projectRoot, quiet) {
+    if (process.platform === 'win32') {
+        return killStaleDaemonsWindows(projectRoot, quiet);
+    }
+    return killStaleDaemonsPosix(projectRoot, quiet);
+}
+async function killStaleDaemonsPosix(projectRoot, quiet) {
     try {
         const { execFileSync } = await import('child_process');
         const psOutput = execFileSync('ps', ['-eo', 'pid,command'], { encoding: 'utf-8', timeout: 5000 });
         const lines = psOutput.split('\n');
         const currentPid = process.pid;
         const trackedPid = getBackgroundDaemonPid(projectRoot);
+        // #1914: only ever reap daemons belonging to THIS workspace (ADR-014).
+        const resolvedRoot = resolve(projectRoot);
         let killed = 0;
         for (const line of lines) {
             if (!line.includes('daemon start --foreground'))
                 continue;
             if (!line.includes('claude-flow') && !line.includes('@claude-flow/cli'))
                 continue;
+            // #1914: skip daemons from other workspaces (or pre-#1914 versions that
+            // didn't stamp --workspace — let `daemon stop` handle those via PID file).
+            if (!daemonCommandLineBelongsToWorkspace(line, resolvedRoot))
+                continue;
             const pidStr = line.trim().split(/\s+/)[0];
             const pid = parseInt(pidStr, 10);
             if (isNaN(pid) || pid === currentPid || pid === trackedPid)
@@ -430,6 +485,68 @@ async function killStaleDaemons(projectRoot, quiet) {
         // ps not available or failed — skip stale cleanup
     }
 }
+/**
+ * #1857: Windows replacement for the POSIX `ps -eo pid,command` path.
+ * Uses `tasklist /v /fo csv` which returns CSV with the full Window
+ * Title column (last field) — Node-spawned daemon processes carry
+ * their command line there. Best-effort like the POSIX path: any
+ * tooling failure (tasklist missing, parse error, etc.) is swallowed
+ * silently so cleanup doesn't break daemon start.
+ */
+async function killStaleDaemonsWindows(projectRoot, quiet) {
+    try {
+        const { execFileSync } = await import('child_process');
+        // /v includes the Window Title; /fo csv uses comma-separated quoted fields
+        const out = execFileSync('tasklist', ['/v', '/fo', 'csv', '/nh'], { encoding: 'utf-8', timeout: 5000 });
+        const lines = out.split(/\r?\n/);
+        const currentPid = process.pid;
+        const trackedPid = getBackgroundDaemonPid(projectRoot);
+        // #1914: only ever reap daemons belonging to THIS workspace (ADR-014).
+        const resolvedRoot = resolve(projectRoot);
+        let killed = 0;
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            // Match daemon command line markers — the Window Title field
+            // typically holds the full invocation. Skip rows that aren't ours.
+            if (!line.includes('daemon start --foreground'))
+                continue;
+            if (!line.includes('claude-flow') && !line.includes('@claude-flow/cli'))
+                continue;
+            // #1914: skip daemons from other workspaces (or pre-#1914 versions).
+            if (!daemonCommandLineBelongsToWorkspace(line, resolvedRoot))
+                continue;
+            // Parse CSV: tasklist quotes each field, so split on `","`
+            const fields = line.split(/","/).map(f => f.replace(/^"|"$/g, ''));
+            // fields[0] = Image Name, fields[1] = PID, …
+            const pidStr = fields[1];
+            const pid = parseInt(pidStr ?? '', 10);
+            if (isNaN(pid) || pid === currentPid || pid === trackedPid)
+                continue;
+            if (!isProcessRunning(pid))
+                continue;
+            try {
+                // taskkill is the Windows equivalent of kill — /pid <n> /f forces.
+                // Use SIGTERM-equivalent (no /f) first; the daemon's signal handler
+                // catches and cleans up; force-kill is the next start's job.
+                execFileSync('taskkill', ['/pid', String(pid), '/t'], { encoding: 'utf-8', timeout: 5000 });
+                killed++;
+                if (!quiet) {
+                    output.printWarning(`Killed stale daemon process (PID: ${pid})`);
+                }
+            }
+            catch { /* taskkill failed — process may have exited; ignore */ }
+        }
+        if (killed > 0 && !quiet) {
+            output.printInfo(`Cleaned up ${killed} stale daemon process(es)`);
+        }
+    }
+    catch {
+        // tasklist not available or failed — skip stale cleanup. Defensive
+        // shape matches the POSIX path. Not tested on Windows by the
+        // maintainer; please report regressions on the issue tracker.
+    }
+}
 /**
  * Get PID of background daemon from PID file
  */
@@ -671,6 +788,222 @@ function formatTimeUntil(date) {
         return `in ${Math.floor(seconds / 3600)}h`;
     return `in ${Math.floor(seconds / 86400)}d`;
 }
+// #1565: Supervisor installer subcommand. Writes a native auto-restart
+// unit (launchd plist on macOS, systemd-user .service on Linux) so the
+// daemon survives crashes and reboots without requiring the operator
+// to manually run `daemon start` after every failure.
+const installSupervisorCommand = {
+    name: 'install-supervisor',
+    description: 'Install OS-level auto-restart supervisor (launchd on macOS, systemd-user on Linux)',
+    options: [
+        { name: 'force', short: 'f', type: 'boolean', description: 'Overwrite existing unit file', default: 'false' },
+        { name: 'load', type: 'boolean', description: 'Load/enable the unit immediately', default: 'true' },
+        { name: 'dry-run', type: 'boolean', description: 'Print the unit file content without writing', default: 'false' },
+    ],
+    examples: [
+        { command: 'claude-flow daemon install-supervisor', description: 'Install + load (auto-restart enabled)' },
+        { command: 'claude-flow daemon install-supervisor --no-load', description: 'Write unit file but do not enable yet' },
+        { command: 'claude-flow daemon install-supervisor --dry-run', description: 'Preview the unit file' },
+    ],
+    action: async (ctx) => {
+        const force = ctx.flags.force === true;
+        const load = ctx.flags.load !== false;
+        const dryRun = ctx.flags['dry-run'] === true || ctx.flags.dryRun === true;
+        const projectRoot = process.cwd();
+        const platform = process.platform;
+        if (platform === 'win32') {
+            output.printError('Windows scheduled-task installer is not yet implemented.');
+            output.printInfo('Use Task Scheduler manually, or follow this issue: https://github.com/ruvnet/ruflo/issues/1565');
+            return { success: false, exitCode: 1 };
+        }
+        if (platform !== 'darwin' && platform !== 'linux') {
+            output.printError(`Unsupported platform: ${platform}. Supported: darwin (launchd), linux (systemd-user).`);
+            return { success: false, exitCode: 1 };
+        }
+        // Resolve absolute paths the unit file will reference.
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
+        if (!home) {
+            output.printError('HOME/USERPROFILE not set; cannot resolve user unit path.');
+            return { success: false, exitCode: 1 };
+        }
+        const nodeBin = process.execPath;
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const cliJs = resolve(join(__dirname, '..', '..', '..', 'bin', 'cli.js'));
+        if (!fs.existsSync(cliJs)) {
+            output.printError(`CLI not found at: ${cliJs}`);
+            return { success: false, exitCode: 1 };
+        }
+        if (platform === 'darwin') {
+            const plistDir = join(home, 'Library', 'LaunchAgents');
+            const plistPath = join(plistDir, 'io.ruv.ruflo.daemon.plist');
+            const logDir = join(projectRoot, '.claude-flow', 'logs');
+            const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key><string>io.ruv.ruflo.daemon</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodeBin}</string>
+        <string>${cliJs}</string>
+        <string>daemon</string><string>start</string><string>--foreground</string><string>--quiet</string>
+    </array>
+    <key>WorkingDirectory</key><string>${projectRoot}</string>
+    <key>RunAtLoad</key><true/>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key><false/>
+        <key>Crashed</key><true/>
+    </dict>
+    <key>ThrottleInterval</key><integer>10</integer>
+    <key>StandardOutPath</key><string>${logDir}/supervisor.out.log</string>
+    <key>StandardErrorPath</key><string>${logDir}/supervisor.err.log</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>CLAUDE_FLOW_DAEMON</key><string>1</string>
+    </dict>
+</dict>
+</plist>
+`;
+            if (dryRun) {
+                output.writeln(plist);
+                return { success: true };
+            }
+            if (fs.existsSync(plistPath) && !force) {
+                output.printWarning(`Already installed: ${plistPath}`);
+                output.printInfo('Use --force to overwrite.');
+                return { success: false, exitCode: 1 };
+            }
+            if (!fs.existsSync(plistDir))
+                fs.mkdirSync(plistDir, { recursive: true });
+            if (!fs.existsSync(logDir))
+                fs.mkdirSync(logDir, { recursive: true });
+            fs.writeFileSync(plistPath, plist, 'utf-8');
+            output.printSuccess(`Wrote ${plistPath}`);
+            if (load) {
+                try {
+                    const { execFileSync } = await import('child_process');
+                    // unload first in case a previous version is loaded
+                    try {
+                        execFileSync('launchctl', ['unload', plistPath], { encoding: 'utf-8', timeout: 5000 });
+                    }
+                    catch { /* ok */ }
+                    execFileSync('launchctl', ['load', '-w', plistPath], { encoding: 'utf-8', timeout: 5000 });
+                    output.printSuccess('Supervisor loaded — daemon will auto-restart on crash and survive reboot.');
+                }
+                catch (err) {
+                    output.printWarning(`launchctl load failed: ${err instanceof Error ? err.message : String(err)}`);
+                    output.printInfo(`Run manually: launchctl load -w ${plistPath}`);
+                }
+            }
+            else {
+                output.printInfo(`Run when ready:  launchctl load -w ${plistPath}`);
+            }
+            return { success: true };
+        }
+        // Linux: systemd-user
+        const unitDir = join(home, '.config', 'systemd', 'user');
+        const unitPath = join(unitDir, 'ruflo-daemon.service');
+        const unit = `[Unit]
+Description=RuFlo background worker daemon
+After=default.target
+
+[Service]
+Type=simple
+WorkingDirectory=${projectRoot}
+Environment=CLAUDE_FLOW_DAEMON=1
+ExecStart=${nodeBin} ${cliJs} daemon start --foreground --quiet
+Restart=on-failure
+RestartSec=10
+# Restart on Crashed (signal) too
+StartLimitIntervalSec=300
+StartLimitBurst=5
+
+[Install]
+WantedBy=default.target
+`;
+        if (dryRun) {
+            output.writeln(unit);
+            return { success: true };
+        }
+        if (fs.existsSync(unitPath) && !force) {
+            output.printWarning(`Already installed: ${unitPath}`);
+            output.printInfo('Use --force to overwrite.');
+            return { success: false, exitCode: 1 };
+        }
+        if (!fs.existsSync(unitDir))
+            fs.mkdirSync(unitDir, { recursive: true });
+        fs.writeFileSync(unitPath, unit, 'utf-8');
+        output.printSuccess(`Wrote ${unitPath}`);
+        if (load) {
+            try {
+                const { execFileSync } = await import('child_process');
+                execFileSync('systemctl', ['--user', 'daemon-reload'], { encoding: 'utf-8', timeout: 5000 });
+                execFileSync('systemctl', ['--user', 'enable', '--now', 'ruflo-daemon.service'], { encoding: 'utf-8', timeout: 10000 });
+                output.printSuccess('Supervisor enabled — daemon will auto-restart on crash and survive reboot.');
+                output.printInfo('Note: requires `loginctl enable-linger $USER` for restart-after-logout on some distros.');
+            }
+            catch (err) {
+                output.printWarning(`systemctl --user enable failed: ${err instanceof Error ? err.message : String(err)}`);
+                output.printInfo(`Run manually: systemctl --user daemon-reload && systemctl --user enable --now ruflo-daemon.service`);
+            }
+        }
+        else {
+            output.printInfo(`Run when ready:  systemctl --user daemon-reload && systemctl --user enable --now ruflo-daemon.service`);
+        }
+        return { success: true };
+    },
+};
+const uninstallSupervisorCommand = {
+    name: 'uninstall-supervisor',
+    description: 'Remove the auto-restart supervisor unit (launchd on macOS, systemd-user on Linux)',
+    options: [],
+    action: async () => {
+        const platform = process.platform;
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
+        if (platform === 'darwin') {
+            const plistPath = join(home, 'Library', 'LaunchAgents', 'io.ruv.ruflo.daemon.plist');
+            try {
+                const { execFileSync } = await import('child_process');
+                try {
+                    execFileSync('launchctl', ['unload', plistPath], { encoding: 'utf-8', timeout: 5000 });
+                }
+                catch { /* ok */ }
+            }
+            catch { /* ignore */ }
+            if (fs.existsSync(plistPath)) {
+                fs.unlinkSync(plistPath);
+                output.printSuccess(`Removed ${plistPath}`);
+            }
+            else {
+                output.printInfo(`Not installed: ${plistPath}`);
+            }
+            return { success: true };
+        }
+        if (platform === 'linux') {
+            const unitPath = join(home, '.config', 'systemd', 'user', 'ruflo-daemon.service');
+            try {
+                const { execFileSync } = await import('child_process');
+                try {
+                    execFileSync('systemctl', ['--user', 'disable', '--now', 'ruflo-daemon.service'], { encoding: 'utf-8', timeout: 5000 });
+                }
+                catch { /* ok */ }
+            }
+            catch { /* ignore */ }
+            if (fs.existsSync(unitPath)) {
+                fs.unlinkSync(unitPath);
+                output.printSuccess(`Removed ${unitPath}`);
+            }
+            else {
+                output.printInfo(`Not installed: ${unitPath}`);
+            }
+            return { success: true };
+        }
+        output.printError(`Unsupported platform: ${platform}`);
+        return { success: false, exitCode: 1 };
+    },
+};
 // Main daemon command
 export const daemonCommand = {
     name: 'daemon',
@@ -681,6 +1014,8 @@ export const daemonCommand = {
         statusCommand,
         triggerCommand,
         enableCommand,
+        installSupervisorCommand,
+        uninstallSupervisorCommand,
     ],
     options: [],
     examples: [