kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/start.js

@@ -2,85 +2,37 @@
  * V3 CLI Start Command
  * System startup for Claude Flow orchestration
  */
-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 };
-    }
-};
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
 // Default configuration
-var DEFAULT_PORT = 3000;
-var DEFAULT_TOPOLOGY = 'hierarchical-mesh';
-var DEFAULT_MAX_AGENTS = 15;
+const DEFAULT_PORT = 3000;
+const DEFAULT_TOPOLOGY = 'hierarchical-mesh';
+const DEFAULT_MAX_AGENTS = 15;
 // Check if project is initialized
 function isInitialized(cwd) {
-    var configPath = path.join(cwd, '.claude-flow', 'config.yaml');
+    const configPath = path.join(cwd, '.claude-flow', 'config.yaml');
     return fs.existsSync(configPath);
 }
 // Simple YAML parser for config (basic implementation)
 function parseSimpleYaml(content) {
-    var result = {};
-    var lines = content.split('\n');
-    var stack = [
+    const result = {};
+    const lines = content.split('\n');
+    const stack = [
         { indent: -1, obj: result }
     ];
-    for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
-        var line = lines_1[_i];
+    for (const line of lines) {
         // Skip comments and empty lines
         if (line.trim().startsWith('#') || line.trim() === '')
             continue;
-        var match = line.match(/^(\s*)(\w+):\s*(.*)$/);
+        const match = line.match(/^(\s*)(\w+):\s*(.*)$/);
         if (!match)
             continue;
-        var indent = match[1].length;
-        var key = match[2];
-        var value = match[3].trim();
+        const indent = match[1].length;
+        const key = match[2];
+        let value = match[3].trim();
         // Parse value
         if (value === '' || value === undefined) {
             value = {};
@@ -104,10 +56,10 @@ function parseSimpleYaml(content) {
         while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
             stack.pop();
         }
-        var parent = stack[stack.length - 1].obj;
+        const parent = stack[stack.length - 1].obj;
         if (typeof value === 'object' && value !== null) {
             parent[key] = value;
-            stack.push({ indent: indent, obj: value, key: key });
+            stack.push({ indent, obj: value, key });
         }
         else {
             parent[key] = value;
@@ -117,179 +69,166 @@ function parseSimpleYaml(content) {
 }
 // Load configuration
 function loadConfig(cwd) {
-    var configPath = path.join(cwd, '.claude-flow', 'config.yaml');
+    const configPath = path.join(cwd, '.claude-flow', 'config.yaml');
     if (!fs.existsSync(configPath))
         return null;
     try {
-        var content = fs.readFileSync(configPath, 'utf-8');
+        const content = fs.readFileSync(configPath, 'utf-8');
         return parseSimpleYaml(content);
     }
-    catch (_a) {
+    catch {
         return null;
     }
 }
 // Main start action
-var startAction = function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-    var daemon, port, topology, skipMcp, cwd, config, swarmConfig, mcpConfig, finalTopology, maxAgents, autoStartMcp, mcpPort, spinner, swarmResult, mcpResult, error_1, healthResult, daemonPidPath_1, keepAlive_1, result, error_2;
-    var _a, _b, _c, _d, _e, _f;
-    return __generator(this, function (_g) {
-        switch (_g.label) {
-            case 0:
-                daemon = ctx.flags.daemon;
-                port = ctx.flags.port || DEFAULT_PORT;
-                topology = ctx.flags.topology || DEFAULT_TOPOLOGY;
-                skipMcp = ctx.flags['skip-mcp'];
-                cwd = ctx.cwd;
-                // Check initialization
-                if (!isInitialized(cwd)) {
-                    output.printError('RuFlo is not initialized in this directory');
-                    output.printInfo('Run "ruflo init" first to initialize');
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                }
-                config = loadConfig(cwd);
-                swarmConfig = (config === null || config === void 0 ? void 0 : config.swarm) || {};
-                mcpConfig = (config === null || config === void 0 ? void 0 : config.mcp) || {};
-                finalTopology = topology || swarmConfig.topology || DEFAULT_TOPOLOGY;
-                maxAgents = swarmConfig.maxAgents || DEFAULT_MAX_AGENTS;
-                autoStartMcp = mcpConfig.autoStart !== false && !skipMcp;
-                mcpPort = port || mcpConfig.serverPort || DEFAULT_PORT;
-                output.writeln();
-                output.writeln(output.bold('Starting RuFlo V3'));
-                output.writeln();
-                spinner = output.createSpinner({ text: 'Initializing system...' });
-                _g.label = 1;
-            case 1:
-                _g.trys.push([1, 8, , 9]);
-                // Step 1: Initialize swarm
-                spinner.start();
-                spinner.setText('Initializing V3 swarm...');
-                return [4 /*yield*/, callMCPTool('swarm_init', {
-                        topology: finalTopology,
-                        maxAgents: maxAgents,
-                        autoScaling: swarmConfig.autoScale !== false,
-                        v3Mode: true
-                    })];
-            case 2:
-                swarmResult = _g.sent();
-                spinner.succeed("Swarm initialized (" + finalTopology + ")");
-                mcpResult = null;
-                if (!autoStartMcp) return [3 /*break*/, 6];
-                spinner.setText('Starting MCP server...');
-                spinner.start();
-                _g.label = 3;
-            case 3:
-                _g.trys.push([3, 5, , 6]);
-                return [4 /*yield*/, callMCPTool('mcp_start', {
-                        port: mcpPort,
-                        transport: mcpConfig.transportType || 'stdio',
-                        tools: mcpConfig.tools || ['agent', 'swarm', 'memory', 'task']
-                    })];
-            case 4:
-                mcpResult = _g.sent();
-                spinner.succeed("MCP server started on port " + mcpPort);
-                return [3 /*break*/, 6];
-            case 5:
-                error_1 = _g.sent();
+const startAction = async (ctx) => {
+    const daemon = ctx.flags.daemon;
+    const port = ctx.flags.port || DEFAULT_PORT;
+    const topology = ctx.flags.topology || DEFAULT_TOPOLOGY;
+    const skipMcp = ctx.flags['skip-mcp'];
+    const cwd = ctx.cwd;
+    // Check initialization
+    if (!isInitialized(cwd)) {
+        output.printError('RuFlo is not initialized in this directory');
+        output.printInfo('Run "ruflo init" first to initialize');
+        return { success: false, exitCode: 1 };
+    }
+    // Load configuration
+    const config = loadConfig(cwd);
+    const swarmConfig = config?.swarm || {};
+    const mcpConfig = config?.mcp || {};
+    const finalTopology = topology || swarmConfig.topology || DEFAULT_TOPOLOGY;
+    const maxAgents = swarmConfig.maxAgents || DEFAULT_MAX_AGENTS;
+    const autoStartMcp = mcpConfig.autoStart !== false && !skipMcp;
+    const mcpPort = port || mcpConfig.serverPort || DEFAULT_PORT;
+    output.writeln();
+    output.writeln(output.bold('Starting RuFlo V3'));
+    output.writeln();
+    const spinner = output.createSpinner({ text: 'Initializing system...' });
+    try {
+        // Step 1: Initialize swarm
+        spinner.start();
+        spinner.setText('Initializing V3 swarm...');
+        const swarmResult = await callMCPTool('swarm_init', {
+            topology: finalTopology,
+            maxAgents,
+            autoScaling: swarmConfig.autoScale !== false,
+            v3Mode: true
+        });
+        spinner.succeed(`Swarm initialized (${finalTopology})`);
+        // Step 2: Start MCP server if configured
+        let mcpResult = null;
+        if (autoStartMcp) {
+            spinner.setText('Starting MCP server...');
+            spinner.start();
+            try {
+                mcpResult = await callMCPTool('mcp_start', {
+                    port: mcpPort,
+                    transport: mcpConfig.transportType || 'stdio',
+                    tools: mcpConfig.tools || ['agent', 'swarm', 'memory', 'task']
+                });
+                spinner.succeed(`MCP server started on port ${mcpPort}`);
+            }
+            catch (error) {
                 spinner.fail('MCP server failed to start');
-                output.printWarning(error_1 instanceof MCPClientError
-                    ? error_1.message
-                    : String(error_1));
-                return [3 /*break*/, 6];
-            case 6:
-                // Step 3: Run health check
-                spinner.setText('Running health checks...');
-                spinner.start();
-                return [4 /*yield*/, callMCPTool('swarm_health', {
-                        swarmId: swarmResult.swarmId
-                    })];
-            case 7:
-                healthResult = _g.sent();
-                if (healthResult.status === 'healthy') {
-                    spinner.succeed('Health checks passed');
-                }
-                else {
-                    spinner.fail("Health check: " + healthResult.status);
-                }
-                // Success output
-                output.writeln();
-                output.printSuccess('RuFlo V3 is running!');
-                output.writeln();
-                // Status display
-                output.printBox([
-                    "Swarm ID:  " + swarmResult.swarmId,
-                    "Topology:  " + finalTopology,
-                    "Max Agents: " + maxAgents,
-                    "MCP Server: " + (autoStartMcp ? "localhost:" + mcpPort : 'disabled'),
-                    "Mode:      " + (daemon ? 'Daemon' : 'Foreground'),
-                    "Health:    " + healthResult.status
-                ].join('\n'), 'System Status');
-                output.writeln();
-                output.writeln(output.bold('Quick Commands:'));
-                output.printList([
-                    output.highlight('claude-flow status') + " - View system status",
-                    output.highlight('claude-flow agent spawn -t coder') + " - Spawn an agent",
-                    output.highlight('claude-flow swarm status') + " - View swarm details",
-                    output.highlight('claude-flow stop') + " - Stop the system"
-                ]);
-                // Daemon mode
-                if (daemon) {
-                    output.writeln();
-                    output.printInfo('Running in daemon mode. Use "claude-flow stop" to stop.');
-                    daemonPidPath_1 = path.join(cwd, '.claude-flow', 'daemon.pid');
-                    fs.writeFileSync(daemonPidPath_1, String(process.pid));
-                    // Detach from parent process for true daemon behavior
-                    if (process.platform !== 'win32') {
-                        // Unix-like systems: create new session
-                        try {
-                            (_b = (_a = process.stdin).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
-                            (_d = (_c = process.stdout).unref) === null || _d === void 0 ? void 0 : _d.call(_c);
-                            (_f = (_e = process.stderr).unref) === null || _f === void 0 ? void 0 : _f.call(_e);
-                        }
-                        catch (_h) {
-                            // Ignore errors if streams can't be unref'd
-                        }
-                    }
-                    keepAlive_1 = setInterval(function () {
-                        // Heartbeat - check if we should still be running
-                        if (!fs.existsSync(daemonPidPath_1)) {
-                            clearInterval(keepAlive_1);
-                            process.exit(0);
-                        }
-                    }, 5000);
-                    keepAlive_1.unref(); // Don't prevent process from exiting if no other work
-                }
-                result = {
-                    swarmId: swarmResult.swarmId,
-                    topology: finalTopology,
-                    maxAgents: maxAgents,
-                    mcp: mcpResult ? {
-                        port: mcpPort,
-                        transport: mcpConfig.transportType || 'stdio'
-                    } : null,
-                    health: healthResult.status,
-                    daemon: daemon,
-                    startedAt: new Date().toISOString()
-                };
-                if (ctx.flags.format === 'json') {
-                    output.printJson(result);
+                output.printWarning(error instanceof MCPClientError
+                    ? error.message
+                    : String(error));
+                // Continue without MCP
+            }
+        }
+        // Step 3: Run health check
+        spinner.setText('Running health checks...');
+        spinner.start();
+        const healthResult = await callMCPTool('swarm_health', {
+            swarmId: swarmResult.swarmId
+        });
+        if (healthResult.status === 'healthy') {
+            spinner.succeed('Health checks passed');
+        }
+        else {
+            spinner.fail(`Health check: ${healthResult.status}`);
+        }
+        // Success output
+        output.writeln();
+        output.printSuccess('RuFlo V3 is running!');
+        output.writeln();
+        // Status display
+        output.printBox([
+            `Swarm ID:  ${swarmResult.swarmId}`,
+            `Topology:  ${finalTopology}`,
+            `Max Agents: ${maxAgents}`,
+            `MCP Server: ${autoStartMcp ? `localhost:${mcpPort}` : 'disabled'}`,
+            `Mode:      ${daemon ? 'Daemon' : 'Foreground'}`,
+            `Health:    ${healthResult.status}`
+        ].join('\n'), 'System Status');
+        output.writeln();
+        output.writeln(output.bold('Quick Commands:'));
+        output.printList([
+            `${output.highlight('claude-flow status')} - View system status`,
+            `${output.highlight('claude-flow agent spawn -t coder')} - Spawn an agent`,
+            `${output.highlight('claude-flow swarm status')} - View swarm details`,
+            `${output.highlight('claude-flow stop')} - Stop the system`
+        ]);
+        // Daemon mode
+        if (daemon) {
+            output.writeln();
+            output.printInfo('Running in daemon mode. Use "claude-flow stop" to stop.');
+            // Store PID for daemon management
+            const daemonPidPath = path.join(cwd, '.claude-flow', 'daemon.pid');
+            fs.writeFileSync(daemonPidPath, String(process.pid));
+            // Detach from parent process for true daemon behavior
+            if (process.platform !== 'win32') {
+                // Unix-like systems: create new session
+                try {
+                    process.stdin.unref?.();
+                    process.stdout.unref?.();
+                    process.stderr.unref?.();
                 }
-                return [2 /*return*/, { success: true, data: result }];
-            case 8:
-                error_2 = _g.sent();
-                spinner.fail('Startup failed');
-                if (error_2 instanceof MCPClientError) {
-                    output.printError("Failed to start: " + error_2.message);
+                catch {
+                    // Ignore errors if streams can't be unref'd
                 }
-                else {
-                    output.printError("Unexpected error: " + String(error_2));
+            }
+            // Keep process alive in daemon mode
+            const keepAlive = setInterval(() => {
+                // Heartbeat - check if we should still be running
+                if (!fs.existsSync(daemonPidPath)) {
+                    clearInterval(keepAlive);
+                    process.exit(0);
                 }
-                return [2 /*return*/, { success: false, exitCode: 1 }];
-            case 9: return [2 /*return*/];
+            }, 5000);
+            keepAlive.unref(); // Don't prevent process from exiting if no other work
+        }
+        const result = {
+            swarmId: swarmResult.swarmId,
+            topology: finalTopology,
+            maxAgents,
+            mcp: mcpResult ? {
+                port: mcpPort,
+                transport: mcpConfig.transportType || 'stdio'
+            } : null,
+            health: healthResult.status,
+            daemon,
+            startedAt: new Date().toISOString()
+        };
+        if (ctx.flags.format === 'json') {
+            output.printJson(result);
         }
-    });
-}); };
+        return { success: true, data: result };
+    }
+    catch (error) {
+        spinner.fail('Startup failed');
+        if (error instanceof MCPClientError) {
+            output.printError(`Failed to start: ${error.message}`);
+        }
+        else {
+            output.printError(`Unexpected error: ${String(error)}`);
+        }
+        return { success: false, exitCode: 1 };
+    }
+};
 // Stop subcommand
-var stopCommand = {
+const stopCommand = {
     name: 'stop',
     description: 'Stop the RuFlo system',
     options: [
@@ -298,100 +237,78 @@ var stopCommand = {
             short: 'f',
             description: 'Force stop without graceful shutdown',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'timeout',
             description: 'Shutdown timeout in seconds',
             type: 'number',
-            "default": 30
+            default: 30
         }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var force, timeout, confirmed, spinner, _a, _b, daemonPidPath, error_3;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    force = ctx.flags.force;
-                    timeout = ctx.flags.timeout;
-                    output.writeln();
-                    output.writeln(output.bold('Stopping RuFlo'));
-                    output.writeln();
-                    if (!(!force && ctx.interactive)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, confirm({
-                            message: 'Are you sure you want to stop RuFlo?',
-                            "default": false
-                        })];
-                case 1:
-                    confirmed = _c.sent();
-                    if (!confirmed) {
-                        output.printInfo('Operation cancelled');
-                        return [2 /*return*/, { success: true }];
-                    }
-                    _c.label = 2;
-                case 2:
-                    spinner = output.createSpinner({ text: 'Stopping system...' });
-                    spinner.start();
-                    _c.label = 3;
-                case 3:
-                    _c.trys.push([3, 12, , 13]);
-                    // Stop MCP server
-                    spinner.setText('Stopping MCP server...');
-                    _c.label = 4;
-                case 4:
-                    _c.trys.push([4, 6, , 7]);
-                    return [4 /*yield*/, callMCPTool('mcp_stop', { graceful: !force, timeout: timeout })];
-                case 5:
-                    _c.sent();
-                    spinner.succeed('MCP server stopped');
-                    return [3 /*break*/, 7];
-                case 6:
-                    _a = _c.sent();
-                    spinner.fail('MCP server was not running');
-                    return [3 /*break*/, 7];
-                case 7:
-                    // Stop swarm
-                    spinner.setText('Stopping swarm...');
-                    spinner.start();
-                    _c.label = 8;
-                case 8:
-                    _c.trys.push([8, 10, , 11]);
-                    return [4 /*yield*/, callMCPTool('swarm_stop', {
-                            graceful: !force,
-                            timeout: timeout,
-                            saveState: true
-                        })];
-                case 9:
-                    _c.sent();
-                    spinner.succeed('Swarm stopped');
-                    return [3 /*break*/, 11];
-                case 10:
-                    _b = _c.sent();
-                    spinner.fail('Swarm was not running');
-                    return [3 /*break*/, 11];
-                case 11:
-                    daemonPidPath = path.join(ctx.cwd, '.claude-flow', 'daemon.pid');
-                    if (fs.existsSync(daemonPidPath)) {
-                        fs.unlinkSync(daemonPidPath);
-                    }
-                    output.writeln();
-                    output.printSuccess('RuFlo stopped successfully');
-                    return [2 /*return*/, {
-                            success: true,
-                            data: { stopped: true, force: force, stoppedAt: new Date().toISOString() }
-                        }];
-                case 12:
-                    error_3 = _c.sent();
-                    spinner.fail('Stop failed');
-                    output.printError("Failed to stop: " + (error_3 instanceof Error ? error_3.message : String(error_3)));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 13: return [2 /*return*/];
+    action: async (ctx) => {
+        const force = ctx.flags.force;
+        const timeout = ctx.flags.timeout;
+        output.writeln();
+        output.writeln(output.bold('Stopping RuFlo'));
+        output.writeln();
+        if (!force && ctx.interactive) {
+            const confirmed = await confirm({
+                message: 'Are you sure you want to stop RuFlo?',
+                default: false
+            });
+            if (!confirmed) {
+                output.printInfo('Operation cancelled');
+                return { success: true };
             }
-        });
-    }); }
+        }
+        const spinner = output.createSpinner({ text: 'Stopping system...' });
+        spinner.start();
+        try {
+            // Stop MCP server
+            spinner.setText('Stopping MCP server...');
+            try {
+                await callMCPTool('mcp_stop', { graceful: !force, timeout });
+                spinner.succeed('MCP server stopped');
+            }
+            catch {
+                spinner.fail('MCP server was not running');
+            }
+            // Stop swarm
+            spinner.setText('Stopping swarm...');
+            spinner.start();
+            try {
+                await callMCPTool('swarm_stop', {
+                    graceful: !force,
+                    timeout,
+                    saveState: true
+                });
+                spinner.succeed('Swarm stopped');
+            }
+            catch {
+                spinner.fail('Swarm was not running');
+            }
+            // Clean up daemon PID
+            const daemonPidPath = path.join(ctx.cwd, '.claude-flow', 'daemon.pid');
+            if (fs.existsSync(daemonPidPath)) {
+                fs.unlinkSync(daemonPidPath);
+            }
+            output.writeln();
+            output.printSuccess('RuFlo stopped successfully');
+            return {
+                success: true,
+                data: { stopped: true, force, stoppedAt: new Date().toISOString() }
+            };
+        }
+        catch (error) {
+            spinner.fail('Stop failed');
+            output.printError(`Failed to stop: ${error instanceof Error ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Restart subcommand
-var restartCommand = {
+const restartCommand = {
     name: 'restart',
     description: 'Restart the RuFlo system',
     options: [
@@ -400,74 +317,60 @@ var restartCommand = {
             short: 'f',
             description: 'Force restart',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var stopCtx, stopResult, startResult;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    output.writeln();
-                    output.writeln(output.bold('Restarting RuFlo'));
-                    output.writeln();
-                    stopCtx = __assign(__assign({}, ctx), { flags: __assign({}, ctx.flags) });
-                    return [4 /*yield*/, stopCommand.action(stopCtx)];
-                case 1:
-                    stopResult = _a.sent();
-                    if (stopResult && !stopResult.success) {
-                        output.printWarning('Stop failed, attempting to start anyway...');
-                    }
-                    // Wait briefly
-                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
-                case 2:
-                    // Wait briefly
-                    _a.sent();
-                    return [4 /*yield*/, startAction(ctx)];
-                case 3:
-                    startResult = _a.sent();
-                    return [2 /*return*/, {
-                            success: startResult.success,
-                            data: {
-                                restarted: startResult.success,
-                                restartedAt: new Date().toISOString()
-                            }
-                        }];
+    action: async (ctx) => {
+        output.writeln();
+        output.writeln(output.bold('Restarting RuFlo'));
+        output.writeln();
+        // Stop first
+        const stopCtx = { ...ctx, flags: { ...ctx.flags } };
+        const stopResult = await stopCommand.action(stopCtx);
+        if (stopResult && !stopResult.success) {
+            output.printWarning('Stop failed, attempting to start anyway...');
+        }
+        // Wait briefly
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        // Start again
+        const startResult = await startAction(ctx);
+        return {
+            success: startResult.success,
+            data: {
+                restarted: startResult.success,
+                restartedAt: new Date().toISOString()
             }
-        });
-    }); }
+        };
+    }
 };
 // Quick start subcommand
-var quickCommand = {
+const quickCommand = {
     name: 'quick',
     aliases: ['q'],
     description: 'Quick start with default settings',
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var initCommand, initCtx;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!!isInitialized(ctx.cwd)) return [3 /*break*/, 3];
-                    output.printInfo('Project not initialized, running init first...');
-                    output.writeln();
-                    return [4 /*yield*/, import('./init.js')];
-                case 1:
-                    initCommand = (_a.sent()).initCommand;
-                    initCtx = __assign(__assign({}, ctx), { flags: __assign(__assign({}, ctx.flags), { minimal: true }) });
-                    return [4 /*yield*/, initCommand.action(initCtx)];
-                case 2:
-                    _a.sent();
-                    output.writeln();
-                    _a.label = 3;
-                case 3: 
-                // Start with defaults
-                return [2 /*return*/, startAction(__assign(__assign({}, ctx), { flags: __assign(__assign({}, ctx.flags), { topology: 'mesh' }) }))];
-            }
+    action: async (ctx) => {
+        // Initialize if needed
+        if (!isInitialized(ctx.cwd)) {
+            output.printInfo('Project not initialized, running init first...');
+            output.writeln();
+            // Call init with minimal settings
+            const { initCommand } = await import('./init.js');
+            const initCtx = {
+                ...ctx,
+                flags: { ...ctx.flags, minimal: true }
+            };
+            await initCommand.action(initCtx);
+            output.writeln();
+        }
+        // Start with defaults
+        return startAction({
+            ...ctx,
+            flags: { ...ctx.flags, topology: 'mesh' }
         });
-    }); }
+    }
 };
 // Main start command
-export var startCommand = {
+export const startCommand = {
     name: 'start',
     description: 'Start the RuFlo orchestration system',
     subcommands: [stopCommand, restartCommand, quickCommand],
@@ -477,14 +380,14 @@ export var startCommand = {
             short: 'd',
             description: 'Run as daemon in background',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'port',
             short: 'p',
             description: 'MCP server port',
             type: 'number',
-            "default": DEFAULT_PORT
+            default: DEFAULT_PORT
         },
         {
             name: 'topology',
@@ -497,7 +400,7 @@ export var startCommand = {
             name: 'skip-mcp',
             description: 'Skip starting MCP server',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
     examples: [