steroids-cli 0.8.24 → 0.8.26

package/dist/commands/runners.js

@@ -38,21 +38,16 @@ exports.runnersCommand = runnersCommand;
  * steroids runners - Manage runner daemons
  */
 const node_util_1 = require("node:util");
-const node_child_process_1 = require("node:child_process");
-const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const os = __importStar(require("node:os"));
-const loader_js_1 = require("../config/loader.js");
 const daemon_js_1 = require("../runners/daemon.js");
-const lock_js_1 = require("../runners/lock.js");
-const wakeup_js_1 = require("../runners/wakeup.js");
-const cron_js_1 = require("../runners/cron.js");
 const connection_js_1 = require("../database/connection.js");
 const queries_js_1 = require("../database/queries.js");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const projects_js_1 = require("../runners/projects.js");
 const help_js_1 = require("../cli/help.js");
+const runners_parallel_js_1 = require("./runners-parallel.js");
+const runners_wakeup_js_1 = require("./runners-wakeup.js");
+const runners_list_js_1 = require("./runners-list.js");
+const runners_logs_js_1 = require("./runners-logs.js");
+const runners_management_js_1 = require("./runners-management.js");
 const HELP = (0, help_js_1.generateHelp)({
     command: 'runners',
     description: 'Manage background runner daemons for automated task execution',
@@ -73,6 +68,9 @@ Runners can be started manually or managed automatically via cron.`,
         { long: 'detach', description: 'Run in background (daemonize) - start subcommand' },
         { long: 'project', description: 'Project path to work on', values: '<path>' },
         { long: 'section', description: 'Focus on specific section only', values: '<id|name>' },
+        { long: 'parallel', description: 'Run independent sections across multiple clones' },
+        { long: 'max', description: 'Limit number of concurrent workstreams', values: '<n>' },
+        { long: 'dry-run', description: 'Analyze plan and exit without cloning or spawning' },
         { long: 'id', description: 'Stop specific runner by ID - stop subcommand', values: '<id>' },
         { long: 'all', description: 'Stop all runners - stop subcommand' },
         { long: 'tree', description: 'Show tree view with projects/runners/tasks - list subcommand' },
@@ -83,6 +81,9 @@ Runners can be started manually or managed automatically via cron.`,
     examples: [
         { command: 'steroids runners start', description: 'Start in foreground' },
         { command: 'steroids runners start --detach', description: 'Start in background' },
+        { command: 'steroids runners start --parallel', description: 'Analyze and run independent workstreams in parallel clones' },
+        { command: 'steroids runners start --parallel --max 2', description: 'Run up to 2 workstreams concurrently' },
+        { command: 'steroids runners start --parallel --dry-run', description: 'Show planned parallel workstreams and exit' },
         { command: 'steroids runners start --section "Phase 2"', description: 'Focus on specific section' },
         { command: 'steroids runners stop', description: 'Stop runner for current project' },
         { command: 'steroids runners stop --all', description: 'Stop all runners' },
@@ -119,7 +120,7 @@ async function runnersCommand(args, flags) {
     const subArgs = args.slice(1);
     switch (subcommand) {
         case 'start':
-            await runStart(subArgs);
+            await runStart(subArgs, flags);
             break;
         case 'stop':
             await runStop(subArgs);
@@ -128,16 +129,16 @@ async function runnersCommand(args, flags) {
             await runStatus(subArgs);
             break;
         case 'list':
-            await runList(subArgs, flags);
+            await (0, runners_list_js_1.runList)(subArgs, flags);
             break;
         case 'logs':
-            await runLogs(subArgs);
+            await (0, runners_logs_js_1.runLogs)(subArgs);
             break;
         case 'wakeup':
-            await runWakeup(subArgs, flags);
+            await (0, runners_wakeup_js_1.runWakeup)(subArgs, flags);
             break;
         case 'cron':
-            await runCron(subArgs);
+            await (0, runners_wakeup_js_1.runCron)(subArgs);
             break;
         default:
             console.error(`Unknown subcommand: ${subcommand}`);
@@ -145,7 +146,7 @@ async function runnersCommand(args, flags) {
             process.exit(1);
     }
 }
-async function runStart(args) {
+async function runStart(args, flags) {
     const { values } = (0, node_util_1.parseArgs)({
         args,
         options: {
@@ -154,6 +155,11 @@ async function runStart(args) {
             detach: { type: 'boolean', short: 'd', default: false },
             project: { type: 'string', short: 'p' },
             section: { type: 'string' },
+            parallel: { type: 'boolean', default: false },
+            max: { type: 'string' },
+            'section-ids': { type: 'string' },
+            branch: { type: 'string' },
+            'parallel-session-id': { type: 'string' },
         },
         allowPositionals: false,
     });
@@ -164,22 +170,38 @@ steroids runners start - Start runner daemon
 USAGE:
   steroids runners start [options]
 
-OPTIONS:
+  OPTIONS:
   --detach            Run in background
   --project <path>    Project path
   --section <id|name> Focus on a specific section only
+  --parallel          Analyze dependency graph and run independent workstreams in parallel clones
+  --max <n>           Limit number of parallel workstreams (overrides runners.parallel.maxClones)
   -j, --json          Output as JSON
   -h, --help          Show help
+  --dry-run           Print analysis plan and exit
 `);
         return;
     }
+    const sectionIdsOption = values['section-ids'];
+    const parallelSessionId = values['parallel-session-id'];
+    const asJson = values.json || flags.json;
+    if (values.parallel && values.section) {
+        const errorMsg = '--parallel cannot be combined with --section';
+        if (asJson) {
+            console.log(JSON.stringify({ success: false, error: errorMsg }));
+        }
+        else {
+            console.error(errorMsg);
+        }
+        process.exit(1);
+    }
     // Check if we can start
     // Default to cwd if --project not specified, to ensure proper per-project tracking
     // Always resolve to absolute path for consistent tracking across processes
     const projectPath = path.resolve(values.project ?? process.cwd());
     const check = (0, daemon_js_1.canStartDaemon)(projectPath);
     if (!check.canStart && !check.reason?.includes('zombie')) {
-        if (values.json) {
+        if (asJson) {
             console.log(JSON.stringify({
                 success: false,
                 error: check.reason,
@@ -194,9 +216,36 @@ OPTIONS:
         }
         process.exit(6);
     }
+    const runFromDetachedParent = values.detach && !values.parallel && !parallelSessionId && !sectionIdsOption;
+    const sectionIdsFromSpawn = typeof sectionIdsOption === 'string'
+        ? (0, runners_parallel_js_1.parseSectionIds)(sectionIdsOption)
+        : [];
+    // Internal parallel runner invocation used by this command when spawning workspace runners.
+    if (values.parallel
+        && sectionIdsOption !== undefined
+        && parallelSessionId
+        && values.branch) {
+        if (sectionIdsFromSpawn.length === 0) {
+            const errorMsg = 'Internal parallel runner received empty section ids';
+            if (asJson) {
+                console.log(JSON.stringify({ success: false, error: errorMsg }));
+            }
+            else {
+                console.error(errorMsg);
+            }
+            process.exit(1);
+        }
+        await (0, daemon_js_1.startDaemon)({
+            projectPath,
+            sectionIds: sectionIdsFromSpawn,
+            branchName: values.branch,
+            parallelSessionId,
+        });
+        return;
+    }
     // Resolve section if --section flag is provided
     let focusedSectionId;
-    if (values.section) {
+    if (!values.parallel && values.section) {
         const sectionInput = values.section;
         const { db, close } = (0, connection_js_1.openDatabase)(projectPath);
         try {
@@ -274,812 +323,92 @@ OPTIONS:
             close();
         }
     }
-    if (values.detach) {
+    if (runFromDetachedParent) {
         // Spawn detached process - always pass --project for proper tracking
         const spawnArgs = [process.argv[1], 'runners', 'start', '--project', projectPath];
         // Pass --section if specified
         if (values.section) {
             spawnArgs.push('--section', values.section);
         }
-        // Check config for daemon logging preference
-        const config = (0, loader_js_1.loadConfig)(projectPath);
-        const daemonLogsEnabled = config.runners?.daemonLogs !== false;
-        let logFile;
-        let logFd;
-        if (daemonLogsEnabled) {
-            // Create logs directory and log file for daemon output
-            const logsDir = path.join(os.homedir(), '.steroids', 'runners', 'logs');
-            fs.mkdirSync(logsDir, { recursive: true });
-            // Use timestamp for now, will rename after we have PID
-            const tempLogPath = path.join(logsDir, `daemon-${Date.now()}.log`);
-            logFd = fs.openSync(tempLogPath, 'a');
-            logFile = tempLogPath;
-        }
-        const child = (0, node_child_process_1.spawn)(process.execPath, spawnArgs, {
-            detached: true,
-            stdio: daemonLogsEnabled && logFd !== undefined
-                ? ['ignore', logFd, logFd]
-                : 'ignore',
+        const { pid, logFile: finalLogPath, } = (0, runners_parallel_js_1.spawnDetachedRunner)({
+            projectPath,
+            args: spawnArgs,
         });
-        child.unref();
-        // Clean up file descriptor and rename log file
-        if (logFd !== undefined) {
-            fs.closeSync(logFd);
-        }
-        let finalLogPath;
-        if (logFile && child.pid) {
-            const logsDir = path.dirname(logFile);
-            finalLogPath = path.join(logsDir, `daemon-${child.pid}.log`);
-            try {
-                fs.renameSync(logFile, finalLogPath);
-            }
-            catch {
-                finalLogPath = logFile; // Keep temp name if rename fails
-            }
-        }
-        if (values.json) {
+        if (asJson) {
             console.log(JSON.stringify({
                 success: true,
-                pid: child.pid,
+                pid,
                 detached: true,
                 logFile: finalLogPath,
             }));
         }
         else {
-            console.log(`Runner started in background (PID: ${child.pid})`);
+            console.log(`Runner started in background (PID: ${pid})`);
             if (finalLogPath) {
                 console.log(`  Log file: ${finalLogPath}`);
             }
         }
         return;
     }
-    // Start in foreground
-    await (0, daemon_js_1.startDaemon)({ projectPath, sectionId: focusedSectionId });
-}
-async function runStop(args) {
-    const { values } = (0, node_util_1.parseArgs)({
-        args,
-        options: {
-            help: { type: 'boolean', short: 'h', default: false },
-            json: { type: 'boolean', short: 'j', default: false },
-            id: { type: 'string' },
-            all: { type: 'boolean', default: false },
-        },
-        allowPositionals: false,
-    });
-    if (values.help) {
-        console.log(`
-steroids runners stop - Stop runner(s)
-
-USAGE:
-  steroids runners stop [options]
-
-OPTIONS:
-  --id <id>           Stop specific runner
-  --all               Stop all runners
-  -j, --json          Output as JSON
-  -h, --help          Show help
-`);
-        return;
-    }
-    // Capture stop context for logging
-    const stopContext = {
-        calledFrom: process.cwd(),
-        callerPid: process.pid,
-        timestamp: new Date().toISOString(),
-        user: process.env.USER || process.env.USERNAME || 'unknown',
-        args: {
-            id: values.id,
-            all: values.all,
-        },
-    };
-    const runners = (0, daemon_js_1.listRunners)();
-    let stopped = 0;
-    const stoppedRunners = [];
-    const runnersToStop = values.id
-        ? runners.filter((r) => r.id === values.id || r.id.startsWith(values.id))
-        : values.all
-            ? runners
-            : runners.filter((r) => r.pid === process.pid || r.pid !== null);
-    // Log stop action to daemon logs
-    const logsDir = path.join(os.homedir(), '.steroids', 'runners', 'logs');
-    const stopLogPath = path.join(logsDir, 'stop-audit.log');
-    fs.mkdirSync(logsDir, { recursive: true });
-    for (const runner of runnersToStop) {
-        if (runner.pid && (0, lock_js_1.isProcessAlive)(runner.pid)) {
-            try {
-                process.kill(runner.pid, 'SIGTERM');
-                stopped++;
-                stoppedRunners.push({
-                    id: runner.id,
-                    pid: runner.pid,
-                    project: runner.project_path,
-                });
-                // Log each stop to audit log
-                const logEntry = {
-                    ...stopContext,
-                    action: 'stop',
-                    runner: {
-                        id: runner.id,
-                        pid: runner.pid,
-                        project: runner.project_path,
-                    },
-                };
-                fs.appendFileSync(stopLogPath, JSON.stringify(logEntry) + '\n');
-            }
-            catch {
-                // Process already dead
-            }
-        }
-        (0, daemon_js_1.unregisterRunner)(runner.id);
-    }
-    if (values.json) {
-        console.log(JSON.stringify({
-            success: true,
-            stopped,
-            stoppedRunners,
-            context: stopContext,
-        }));
-    }
-    else {
-        console.log(`Stopped ${stopped} runner(s)`);
-        if (stopped > 0 && !values.all) {
-            console.log(`  Called from: ${stopContext.calledFrom}`);
-            console.log(`  Audit log: ${stopLogPath}`);
-        }
-    }
-}
-async function runStatus(args) {
-    const { values } = (0, node_util_1.parseArgs)({
-        args,
-        options: {
-            help: { type: 'boolean', short: 'h', default: false },
-            json: { type: 'boolean', short: 'j', default: false },
-        },
-        allowPositionals: false,
-    });
-    if (values.help) {
-        console.log(`
-steroids runners status - Show runner status
-
-USAGE:
-  steroids runners status [options]
-
-OPTIONS:
-  -j, --json          Output as JSON
-  -h, --help          Show help
-`);
-        return;
-    }
-    const lockStatus = (0, lock_js_1.checkLockStatus)();
-    const runners = (0, daemon_js_1.listRunners)();
-    const activeRunner = runners.find((r) => r.pid && (0, lock_js_1.isProcessAlive)(r.pid));
-    const status = {
-        locked: lockStatus.locked,
-        lockPid: lockStatus.pid,
-        isZombie: lockStatus.isZombie,
-        activeRunner: activeRunner
-            ? {
-                id: activeRunner.id,
-                pid: activeRunner.pid,
-                status: activeRunner.status,
-                project: activeRunner.project_path,
-                currentTask: activeRunner.current_task_id,
-                heartbeat: activeRunner.heartbeat_at,
-            }
-            : null,
-        totalRunners: runners.length,
-    };
-    if (values.json) {
-        console.log(JSON.stringify(status, null, 2));
-        return;
-    }
-    if (activeRunner) {
-        console.log(`Runner Status: ACTIVE`);
-        console.log(`  ID: ${activeRunner.id}`);
-        console.log(`  PID: ${activeRunner.pid}`);
-        console.log(`  Status: ${activeRunner.status}`);
-        if (activeRunner.project_path) {
-            console.log(`  Project: ${activeRunner.project_path}`);
-        }
-        if (activeRunner.current_task_id) {
-            console.log(`  Current Task: ${activeRunner.current_task_id}`);
-        }
-        console.log(`  Last Heartbeat: ${activeRunner.heartbeat_at}`);
-    }
-    else if (lockStatus.isZombie) {
-        console.log(`Runner Status: ZOMBIE`);
-        console.log(`  Lock exists but process (PID: ${lockStatus.pid}) is dead`);
-        console.log(`  Run 'steroids runners wakeup' to clean up`);
-    }
-    else {
-        console.log(`Runner Status: INACTIVE`);
-        console.log(`  No runner is currently active`);
-    }
-}
-async function runList(args, flags) {
-    const { values } = (0, node_util_1.parseArgs)({
-        args,
-        options: {
-            help: { type: 'boolean', short: 'h', default: false },
-            tree: { type: 'boolean', short: 't', default: false },
-        },
-        allowPositionals: false,
-    });
-    if (values.help || flags.help) {
-        console.log(`
-steroids runners list - List all runners
-
-USAGE:
-  steroids runners list [options]
-
-OPTIONS:
-  -t, --tree          Show tree view with tasks
-  -j, --json          Output as JSON (global flag)
-  -h, --help          Show help
-`);
-        return;
-    }
-    // Tree view mode
-    if (values.tree) {
-        await runListTree(flags.json);
-        return;
-    }
-    const runners = (0, daemon_js_1.listRunners)();
-    if (flags.json) {
-        // For JSON output, enrich with section names if available
-        const enrichedRunners = runners.map((runner) => {
-            if (!runner.section_id || !runner.project_path) {
-                return runner;
-            }
-            try {
-                const { db, close } = (0, connection_js_1.openDatabase)(runner.project_path);
-                try {
-                    const section = (0, queries_js_1.getSection)(db, runner.section_id);
-                    return { ...runner, section_name: section?.name };
-                }
-                finally {
-                    close();
-                }
-            }
-            catch {
-                return runner;
-            }
-        });
-        console.log(JSON.stringify({ runners: enrichedRunners }, null, 2));
-        return;
-    }
-    if (runners.length === 0) {
-        console.log('No runners registered');
-        return;
-    }
-    console.log('RUNNERS');
-    console.log('─'.repeat(120));
-    console.log('ID        STATUS      PID       PROJECT                           SECTION                           HEARTBEAT');
-    console.log('─'.repeat(120));
-    for (const runner of runners) {
-        const shortId = runner.id.substring(0, 8);
-        const status = runner.status.padEnd(10);
-        const pid = (runner.pid?.toString() ?? '-').padEnd(9);
-        const project = (runner.project_path ?? '-').substring(0, 30).padEnd(30);
-        // Fetch section name if available
-        let sectionDisplay = '-';
-        if (runner.section_id && runner.project_path) {
-            try {
-                const { db, close } = (0, connection_js_1.openDatabase)(runner.project_path);
-                try {
-                    const section = (0, queries_js_1.getSection)(db, runner.section_id);
-                    if (section) {
-                        sectionDisplay = section.name.substring(0, 30);
-                    }
+    if (values.parallel) {
+        const maxFromCli = typeof values.max === 'string' ? values.max.trim() : undefined;
+        let maxClones;
+        if (maxFromCli !== undefined) {
+            const parsedMax = Number.parseInt(maxFromCli, 10);
+            if (!Number.isInteger(parsedMax) || parsedMax <= 0) {
+                if (asJson) {
+                    console.log(JSON.stringify({ success: false, error: '--max must be a positive integer' }));
                 }
-                finally {
-                    close();
+                else {
+                    console.error('--max must be a positive integer');
                 }
+                process.exit(1);
             }
-            catch {
-                // If we can't fetch the section name, just show the ID prefix
-                sectionDisplay = runner.section_id.substring(0, 8);
-            }
-        }
-        const section = sectionDisplay.padEnd(30);
-        const heartbeat = runner.heartbeat_at.substring(11, 19);
-        const alive = runner.pid && (0, lock_js_1.isProcessAlive)(runner.pid) ? '' : ' (dead)';
-        console.log(`${shortId}  ${status}  ${pid}  ${project}    ${section}    ${heartbeat}${alive}`);
-    }
-    // Check if there are multiple projects
-    const uniqueProjects = new Set(runners.map(r => r.project_path).filter(Boolean));
-    if (uniqueProjects.size > 1) {
-        const currentProject = process.cwd();
-        console.log('');
-        console.log('─'.repeat(120));
-        console.log(`⚠️  MULTI-PROJECT WARNING: ${uniqueProjects.size} different projects have runners.`);
-        console.log(`   Your current project: ${currentProject}`);
-        console.log('   DO NOT modify files in other projects. Each runner works only on its own project.');
-        console.log('─'.repeat(120));
-    }
-}
-/**
- * Tree view of runners grouped by project with their current tasks
- */
-async function runListTree(json) {
-    const runners = (0, daemon_js_1.listRunners)();
-    const projects = (0, projects_js_1.getRegisteredProjects)(false);
-    const projectMap = new Map();
-    // Initialize with all registered projects
-    for (const project of projects) {
-        projectMap.set(project.path, {
-            path: project.path,
-            name: project.name || (0, node_path_1.basename)(project.path),
-            runners: [],
-            activeTasks: [],
-        });
-    }
-    // Add runners to their projects
-    for (const runner of runners) {
-        const projectPath = runner.project_path;
-        if (!projectPath)
-            continue;
-        if (!projectMap.has(projectPath)) {
-            projectMap.set(projectPath, {
-                path: projectPath,
-                name: (0, node_path_1.basename)(projectPath),
-                runners: [],
-                activeTasks: [],
-            });
+            maxClones = parsedMax;
         }
-        const info = projectMap.get(projectPath);
-        info.runners.push(runner);
-    }
-    // Fetch active tasks for each project
-    for (const [projectPath, info] of projectMap) {
-        const dbPath = `${projectPath}/.steroids/steroids.db`;
-        if (!(0, node_fs_1.existsSync)(dbPath))
-            continue;
+        let parallelPlan;
         try {
-            const { db, close } = (0, connection_js_1.openDatabase)(projectPath);
-            try {
-                const inProgress = (0, queries_js_1.listTasks)(db, { status: 'in_progress' });
-                const review = (0, queries_js_1.listTasks)(db, { status: 'review' });
-                info.activeTasks = [...inProgress, ...review];
-            }
-            finally {
-                close();
+            parallelPlan = (0, runners_parallel_js_1.buildParallelRunPlan)(projectPath, maxClones);
+        }
+        catch (error) {
+            const message = error instanceof runners_parallel_js_1.CyclicDependencyError
+                ? error.message
+                : error instanceof Error
+                    ? error.message
+                    : 'Unable to create parallel plan';
+            if (asJson) {
+                console.log(JSON.stringify({ success: false, error: message }));
             }
-        }
-        catch {
-            // Skip inaccessible projects
-        }
-    }
-    // JSON output
-    if (json) {
-        const output = Array.from(projectMap.values()).map((info) => ({
-            project: info.path,
-            name: info.name,
-            runners: info.runners.map((r) => ({
-                id: r.id,
-                status: r.status,
-                pid: r.pid,
-                currentTaskId: r.current_task_id,
-                alive: r.pid ? (0, lock_js_1.isProcessAlive)(r.pid) : false,
-            })),
-            activeTasks: info.activeTasks.map((t) => ({
-                id: t.id,
-                title: t.title,
-                status: t.status,
-            })),
-        }));
-        console.log(JSON.stringify({ projects: output }, null, 2));
-        return;
-    }
-    // Text tree view
-    const projectList = Array.from(projectMap.values());
-    const currentProject = process.cwd();
-    if (projectList.length === 0) {
-        console.log('No registered projects.');
-        return;
-    }
-    console.log('');
-    console.log('RUNNERS TREE');
-    console.log('═'.repeat(80));
-    for (let i = 0; i < projectList.length; i++) {
-        const info = projectList[i];
-        const isLast = i === projectList.length - 1;
-        const isCurrent = info.path === currentProject;
-        const currentMarker = isCurrent ? ' ← (current)' : '';
-        console.log('');
-        console.log(`📁 ${info.name}${currentMarker}`);
-        console.log(`   ${info.path}`);
-        if (info.runners.length === 0) {
-            console.log('   └─ (no runners)');
-        }
-        else {
-            for (let j = 0; j < info.runners.length; j++) {
-                const runner = info.runners[j];
-                const isLastRunner = j === info.runners.length - 1;
-                const runnerPrefix = isLastRunner ? '└─' : '├─';
-                const childPrefix = isLastRunner ? '   ' : '│  ';
-                const alive = runner.pid && (0, lock_js_1.isProcessAlive)(runner.pid);
-                const statusIcon = alive ? '🟢' : '🔴';
-                const statusText = alive ? runner.status : 'dead';
-                const pidText = runner.pid ? ` PID ${runner.pid}` : '';
-                console.log(`   ${runnerPrefix} ${statusIcon} Runner ${runner.id.substring(0, 8)} (${statusText}${pidText})`);
-                // Show section if focused
-                if (runner.section_id && runner.project_path) {
-                    try {
-                        const { db, close } = (0, connection_js_1.openDatabase)(runner.project_path);
-                        try {
-                            const section = (0, queries_js_1.getSection)(db, runner.section_id);
-                            if (section) {
-                                console.log(`   ${childPrefix}    Section: ${section.name}`);
-                            }
-                        }
-                        finally {
-                            close();
-                        }
-                    }
-                    catch {
-                        // Ignore section fetch errors
-                    }
-                }
-                // Show current task if available
-                if (runner.current_task_id && runner.project_path) {
-                    try {
-                        const { db, close } = (0, connection_js_1.openDatabase)(runner.project_path);
-                        try {
-                            const task = (0, queries_js_1.getTask)(db, runner.current_task_id);
-                            if (task) {
-                                const statusMarker = task.status === 'in_progress' ? '🔧' : '👁️';
-                                console.log(`   ${childPrefix}    ${statusMarker} ${task.title.substring(0, 50)}`);
-                                console.log(`   ${childPrefix}       [${task.status}] ${task.id.substring(0, 8)}`);
-                            }
-                        }
-                        finally {
-                            close();
-                        }
-                    }
-                    catch {
-                        console.log(`   ${childPrefix}    Task: ${runner.current_task_id.substring(0, 8)}`);
-                    }
-                }
-                else if (alive) {
-                    console.log(`   ${childPrefix}    (idle - no task)`);
-                }
-            }
-        }
-        // Show other active tasks not being worked on by runners
-        const runnerTaskIds = new Set(info.runners.map((r) => r.current_task_id).filter(Boolean));
-        const unassignedTasks = info.activeTasks.filter((t) => !runnerTaskIds.has(t.id));
-        if (unassignedTasks.length > 0) {
-            console.log('   │');
-            console.log('   └─ 📋 Queued active tasks:');
-            for (const task of unassignedTasks.slice(0, 5)) {
-                const statusIcon = task.status === 'in_progress' ? '🔧' : '👁️';
-                console.log(`      ${statusIcon} ${task.title.substring(0, 45)} [${task.status}]`);
-            }
-            if (unassignedTasks.length > 5) {
-                console.log(`      ... and ${unassignedTasks.length - 5} more`);
+            else {
+                console.error(message);
             }
+            process.exit(1);
         }
-    }
-    console.log('');
-    console.log('═'.repeat(80));
-    // Multi-project warning
-    const activeProjects = projectList.filter((p) => p.runners.length > 0);
-    if (activeProjects.length > 1) {
-        console.log('');
-        console.log('⚠️  MULTI-PROJECT: Multiple projects have active runners.');
-        console.log('   Each runner works ONLY on its own project.');
-    }
-}
-async function runLogs(args) {
-    const { values, positionals } = (0, node_util_1.parseArgs)({
-        args,
-        options: {
-            help: { type: 'boolean', short: 'h', default: false },
-            json: { type: 'boolean', short: 'j', default: false },
-            tail: { type: 'string', short: 'n', default: '50' },
-            follow: { type: 'boolean', short: 'f', default: false },
-            clear: { type: 'boolean', default: false },
-        },
-        allowPositionals: true,
-    });
-    if (values.help) {
-        console.log(`
-steroids runners logs - View daemon crash/output logs
-
-USAGE:
-  steroids runners logs [pid] [options]
-
-OPTIONS:
-  <pid>               Show logs for specific daemon PID
-  --tail <n>          Show last n lines (default: 50)
-  --follow            Follow log output (latest log)
-  --clear             Clear all daemon logs
-  -j, --json          Output as JSON
-  -h, --help          Show help
-
-LOG LOCATION:
-  Logs are stored in ~/.steroids/runners/logs/
-  Each daemon gets its own log file: daemon-<pid>.log
-
-  To disable daemon logging, set in config:
-    steroids config set runners.daemonLogs false
-
-EXAMPLES:
-  steroids runners logs           # List available log files
-  steroids runners logs 12345     # View logs for PID 12345
-  steroids runners logs --follow  # Follow the latest log
-  steroids runners logs --clear   # Remove all log files
-`);
-        return;
-    }
-    const logsDir = path.join(os.homedir(), '.steroids', 'runners', 'logs');
-    // Handle --clear
-    if (values.clear) {
-        if (!fs.existsSync(logsDir)) {
-            if (values.json) {
-                console.log(JSON.stringify({ success: true, cleared: 0 }));
+        if (flags.dryRun) {
+            if (asJson) {
+                console.log(JSON.stringify({ success: true, plan: parallelPlan }));
             }
             else {
-                console.log('No logs directory found');
+                (0, runners_parallel_js_1.printParallelPlan)(projectPath, parallelPlan);
             }
             return;
         }
-        const files = fs.readdirSync(logsDir).filter((f) => f.endsWith('.log'));
-        for (const file of files) {
-            fs.unlinkSync(path.join(logsDir, file));
-        }
-        if (values.json) {
-            console.log(JSON.stringify({ success: true, cleared: files.length }));
+        const sessionId = (0, runners_parallel_js_1.launchParallelSession)(parallelPlan, projectPath);
+        if (asJson) {
+            console.log(JSON.stringify({ success: true, sessionId }));
         }
         else {
-            console.log(`Cleared ${files.length} log file(s)`);
-        }
-        return;
-    }
-    // Ensure logs directory exists
-    if (!fs.existsSync(logsDir)) {
-        if (values.json) {
-            console.log(JSON.stringify({ logs: [], logsDir }));
-        }
-        else {
-            console.log('No daemon logs found');
-            console.log(`  Logs are stored in: ${logsDir}`);
-        }
-        return;
-    }
-    const logFiles = fs.readdirSync(logsDir)
-        .filter((f) => f.startsWith('daemon-') && f.endsWith('.log'))
-        .map((f) => {
-        const filePath = path.join(logsDir, f);
-        const stats = fs.statSync(filePath);
-        const pidMatch = f.match(/daemon-(\d+)\.log/);
-        return {
-            file: f,
-            path: filePath,
-            pid: pidMatch ? parseInt(pidMatch[1], 10) : null,
-            size: stats.size,
-            modified: stats.mtime,
-        };
-    })
-        .sort((a, b) => b.modified.getTime() - a.modified.getTime());
-    // If a PID is specified, show that log
-    if (positionals.length > 0) {
-        const pidArg = positionals[0];
-        const logFile = logFiles.find((l) => l.pid?.toString() === pidArg || l.file.includes(pidArg));
-        if (!logFile) {
-            console.error(`No log found for PID: ${pidArg}`);
-            process.exit(1);
-        }
-        const content = fs.readFileSync(logFile.path, 'utf-8');
-        const lines = content.split('\n');
-        const tailLines = parseInt(values.tail, 10) || 50;
-        const output = lines.slice(-tailLines).join('\n');
-        if (values.json) {
-            console.log(JSON.stringify({ pid: logFile.pid, path: logFile.path, content: output }));
-        }
-        else {
-            console.log(`=== Daemon log for PID ${logFile.pid} ===`);
-            console.log(`File: ${logFile.path}`);
-            console.log(`Modified: ${logFile.modified.toISOString()}`);
-            console.log('─'.repeat(60));
-            console.log(output);
-        }
-        return;
-    }
-    // If --follow, tail the most recent log
-    if (values.follow) {
-        if (logFiles.length === 0) {
-            console.error('No log files to follow');
-            process.exit(1);
+            console.log(`Started parallel session: ${sessionId}`);
         }
-        const latestLog = logFiles[0];
-        console.log(`Following: ${latestLog.path} (PID: ${latestLog.pid})`);
-        console.log('─'.repeat(60));
-        // Use spawn to tail -f
-        const tail = (0, node_child_process_1.spawn)('tail', ['-f', latestLog.path], { stdio: 'inherit' });
-        tail.on('error', (err) => {
-            console.error(`Error following log: ${err.message}`);
-            process.exit(1);
-        });
         return;
     }
-    // List all log files
-    if (values.json) {
-        console.log(JSON.stringify({ logs: logFiles, logsDir }, null, 2));
-        return;
-    }
-    if (logFiles.length === 0) {
-        console.log('No daemon logs found');
-        console.log(`  Logs are stored in: ${logsDir}`);
-        return;
-    }
-    console.log('DAEMON LOGS');
-    console.log('─'.repeat(80));
-    console.log('PID         SIZE      MODIFIED                 FILE');
-    console.log('─'.repeat(80));
-    for (const log of logFiles) {
-        const pid = (log.pid?.toString() ?? 'unknown').padEnd(10);
-        const size = formatBytes(log.size).padEnd(9);
-        const modified = log.modified.toISOString().substring(0, 19).padEnd(22);
-        console.log(`${pid}  ${size}  ${modified}  ${log.file}`);
-    }
-    console.log('');
-    console.log(`Logs directory: ${logsDir}`);
-    console.log(`Use 'steroids runners logs <pid>' to view a specific log`);
-}
-function formatBytes(bytes) {
-    if (bytes === 0)
-        return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+    // Start in foreground
+    await (0, daemon_js_1.startDaemon)({ projectPath, sectionId: focusedSectionId });
 }
-async function runWakeup(args, flags) {
-    // Hard timeout: wakeup is a short-lived process spawned by launchd every 60s.
-    // If ANY operation hangs (TCC dialog blocking file access, locked DB, etc.),
-    // this ensures the process exits instead of becoming a zombie.
-    const WAKEUP_TIMEOUT_MS = 30_000;
-    setTimeout(() => process.exit(0), WAKEUP_TIMEOUT_MS).unref();
-    const { values } = (0, node_util_1.parseArgs)({
-        args,
-        options: {
-            help: { type: 'boolean', short: 'h', default: false },
-            json: { type: 'boolean', short: 'j', default: false },
-            quiet: { type: 'boolean', short: 'q', default: false },
-        },
-        allowPositionals: false,
-    });
-    if (values.help) {
-        console.log(`
-steroids runners wakeup - Check and restart stale runners
-
-USAGE:
-  steroids runners wakeup [options]
-
-OPTIONS:
-  --quiet             Suppress output (for cron)
-  --dry-run           Check without acting
-  -j, --json          Output as JSON
-  -h, --help          Show help
-`);
-        return;
-    }
-    const results = await (0, wakeup_js_1.wakeup)({
-        quiet: values.quiet || flags.quiet || values.json || flags.json,
-        dryRun: flags.dryRun,
-    });
-    if (values.json || flags.json) {
-        console.log(JSON.stringify({ results }, null, 2));
-        return;
-    }
-    if (!values.quiet && !flags.quiet) {
-        // Summarize results
-        const started = results.filter(r => r.action === 'started').length;
-        const cleaned = results.filter(r => r.action === 'cleaned').length;
-        const wouldStart = results.filter(r => r.action === 'would_start').length;
-        if (started > 0) {
-            console.log(`Started ${started} runner(s)`);
-        }
-        if (cleaned > 0) {
-            console.log(`Cleaned ${cleaned} stale runner(s)`);
-        }
-        if (wouldStart > 0) {
-            console.log(`Would start ${wouldStart} runner(s) (dry-run)`);
-        }
-        if (started === 0 && cleaned === 0 && wouldStart === 0) {
-            console.log('No action needed');
-        }
-        // Show per-project details
-        for (const result of results) {
-            if (result.projectPath) {
-                const status = result.action === 'started' ? '✓' :
-                    result.action === 'would_start' ? '~' : '-';
-                console.log(`  ${status} ${result.projectPath}: ${result.reason}`);
-            }
-        }
-    }
-    // Force exit — wakeup is a short-lived process spawned by launchd every 60s.
-    // Without this, lingering DB handles (better-sqlite3 native bindings) keep
-    // the Node.js event loop alive indefinitely, causing zombie process accumulation.
-    process.exit(0);
+async function runStop(args) {
+    return (0, runners_management_js_1.runStop)(args);
 }
-async function runCron(args) {
-    if (args.length === 0 || args[0] === '-h' || args[0] === '--help') {
-        console.log(`
-steroids runners cron - Manage cron job
-
-USAGE:
-  steroids runners cron <subcommand>
-
-SUBCOMMANDS:
-  install             Add cron job (every minute)
-  uninstall           Remove cron job
-  status              Check cron status
-
-OPTIONS:
-  -j, --json          Output as JSON
-  -h, --help          Show help
-`);
-        return;
-    }
-    const subcommand = args[0];
-    const subArgs = args.slice(1);
-    const { values } = (0, node_util_1.parseArgs)({
-        args: subArgs,
-        options: {
-            json: { type: 'boolean', short: 'j', default: false },
-        },
-        allowPositionals: false,
-    });
-    switch (subcommand) {
-        case 'install': {
-            const result = (0, cron_js_1.cronInstall)();
-            if (values.json) {
-                console.log(JSON.stringify(result, null, 2));
-            }
-            else {
-                console.log(result.message);
-                if (result.error) {
-                    console.error(result.error);
-                }
-            }
-            break;
-        }
-        case 'uninstall': {
-            const result = (0, cron_js_1.cronUninstall)();
-            if (values.json) {
-                console.log(JSON.stringify(result, null, 2));
-            }
-            else {
-                console.log(result.message);
-            }
-            break;
-        }
-        case 'status': {
-            const status = (0, cron_js_1.cronStatus)();
-            if (values.json) {
-                console.log(JSON.stringify(status, null, 2));
-            }
-            else {
-                if (status.installed) {
-                    console.log('Cron job: INSTALLED');
-                    console.log(`  Entry: ${status.entry}`);
-                }
-                else {
-                    console.log('Cron job: NOT INSTALLED');
-                    if (status.error) {
-                        console.log(`  ${status.error}`);
-                    }
-                }
-            }
-            break;
-        }
-        default:
-            console.error(`Unknown cron subcommand: ${subcommand}`);
-            process.exit(1);
-    }
+async function runStatus(args) {
+    return (0, runners_management_js_1.runStatus)(args);
 }
 //# sourceMappingURL=runners.js.map