kynjal-cli 3.1.3 → 4.0.0

package/dist/src/commands/mcp.js

@@ -5,12 +5,48 @@
  * @module @claude-flow/cli/commands/mcp
  * @version 3.0.0
  */
+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 { getServerManager, getMCPServerStatus, } from '../mcp-server.js';
 import { listMCPTools, callMCPTool, hasTool } from '../mcp-client.js';
 // MCP tools categories
-const TOOL_CATEGORIES = [
+var TOOL_CATEGORIES = [
     { value: 'coordination', label: 'Coordination', hint: 'Swarm and agent coordination tools' },
     { value: 'monitoring', label: 'Monitoring', hint: 'Status and metrics monitoring' },
     { value: 'memory', label: 'Memory', hint: 'Memory and neural features' },
@@ -22,19 +58,19 @@ const TOOL_CATEGORIES = [
  */
 function formatUptime(seconds) {
     if (seconds < 60) {
-        return `${seconds}s`;
+        return seconds + "s";
     }
     if (seconds < 3600) {
-        const mins = Math.floor(seconds / 60);
-        const secs = seconds % 60;
-        return `${mins}m ${secs}s`;
+        var mins_1 = Math.floor(seconds / 60);
+        var secs = seconds % 60;
+        return mins_1 + "m " + secs + "s";
     }
-    const hours = Math.floor(seconds / 3600);
-    const mins = Math.floor((seconds % 3600) / 60);
-    return `${hours}h ${mins}m`;
+    var hours = Math.floor(seconds / 3600);
+    var mins = Math.floor((seconds % 3600) / 60);
+    return hours + "h " + mins + "m";
 }
 // Start MCP server
-const startCommand = {
+var startCommand = {
     name: 'start',
     description: 'Start MCP server',
     options: [
@@ -43,42 +79,42 @@ const startCommand = {
             short: 'p',
             description: 'Server port',
             type: 'number',
-            default: 3000
+            "default": 3000
         },
         {
             name: 'host',
             short: 'h',
             description: 'Server host',
             type: 'string',
-            default: 'localhost'
+            "default": 'localhost'
         },
         {
             name: 'transport',
             short: 't',
             description: 'Transport type (stdio, http, websocket)',
             type: 'string',
-            default: 'stdio',
+            "default": 'stdio',
             choices: ['stdio', 'http', 'websocket']
         },
         {
             name: 'tools',
             description: 'Tools to enable (comma-separated or "all")',
             type: 'string',
-            default: 'all'
+            "default": 'all'
         },
         {
             name: 'daemon',
             short: 'd',
             description: 'Run as background daemon',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'force',
             short: 'f',
             description: 'Force restart (kill existing server first)',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
     examples: [
@@ -87,113 +123,130 @@ const startCommand = {
         { command: 'claude-flow mcp start -d', description: 'Start as daemon' },
         { command: 'claude-flow mcp start -f', description: 'Force restart (kill existing)' }
     ],
-    action: async (ctx) => {
-        const port = ctx.flags.port ?? 3000;
-        const host = ctx.flags.host ?? 'localhost';
-        const transport = ctx.flags.transport ?? 'stdio';
-        const tools = ctx.flags.tools || 'all';
-        const daemon = ctx.flags.daemon ?? false;
-        const force = ctx.flags.force ?? false;
-        output.writeln();
-        output.printInfo('Starting MCP Server...');
-        output.writeln();
-        // Check if already running
-        const existingStatus = await getMCPServerStatus();
-        if (existingStatus.running) {
-            // For stdio transport, always force restart since we can't health check it
-            // For other transports, check health unless --force is specified
-            const shouldForceRestart = force || transport === 'stdio';
-            if (!shouldForceRestart) {
-                // Verify the server is actually healthy/responsive
-                const manager = getServerManager();
-                const health = await manager.checkHealth();
-                if (health.healthy) {
-                    output.printWarning(`MCP Server already running (PID: ${existingStatus.pid})`);
-                    output.writeln(output.dim('Use "claude-flow mcp stop" to stop the server first, or use --force'));
-                    return { success: false, exitCode: 1 };
-                }
-            }
-            // Force restart or unresponsive - auto-recover
-            output.printWarning(`MCP Server (PID: ${existingStatus.pid}) - restarting...`);
-            try {
-                // Force kill the existing process
-                if (existingStatus.pid) {
-                    try {
-                        process.kill(existingStatus.pid, 'SIGKILL');
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var port, host, transport, tools, daemon, force, existingStatus, isSelfDetected, shouldForceRestart, manager, health, manager, _a, options, manager, status, error_1;
+        var _b, _c, _d, _e, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    port = (_b = ctx.flags.port) !== null && _b !== void 0 ? _b : 3000;
+                    host = (_c = ctx.flags.host) !== null && _c !== void 0 ? _c : 'localhost';
+                    transport = (_d = ctx.flags.transport) !== null && _d !== void 0 ? _d : 'stdio';
+                    tools = ctx.flags.tools || 'all';
+                    daemon = (_e = ctx.flags.daemon) !== null && _e !== void 0 ? _e : false;
+                    force = (_f = ctx.flags.force) !== null && _f !== void 0 ? _f : false;
+                    output.writeln();
+                    output.printInfo('Starting MCP Server...');
+                    output.writeln();
+                    return [4 /*yield*/, getMCPServerStatus()];
+                case 1:
+                    existingStatus = _g.sent();
+                    isSelfDetected = existingStatus.pid === process.pid;
+                    if (!(existingStatus.running && !isSelfDetected)) return [3 /*break*/, 7];
+                    shouldForceRestart = force || transport === 'stdio';
+                    if (!!shouldForceRestart) return [3 /*break*/, 3];
+                    manager = getServerManager();
+                    return [4 /*yield*/, manager.checkHealth()];
+                case 2:
+                    health = _g.sent();
+                    if (health.healthy) {
+                        output.printWarning("MCP Server already running (PID: " + existingStatus.pid + ")");
+                        output.writeln(output.dim('Use "claude-flow mcp stop" to stop the server first, or use --force'));
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
                     }
-                    catch {
-                        // Process may already be dead
+                    _g.label = 3;
+                case 3:
+                    // Force restart or unresponsive - auto-recover
+                    output.printWarning("MCP Server (PID: " + existingStatus.pid + ") - restarting...");
+                    _g.label = 4;
+                case 4:
+                    _g.trys.push([4, 6, , 7]);
+                    // Force kill the existing process
+                    if (existingStatus.pid) {
+                        try {
+                            process.kill(existingStatus.pid, 'SIGKILL');
+                        }
+                        catch (_h) {
+                            // Process may already be dead
+                        }
                     }
-                }
-                const manager = getServerManager();
-                await manager.stop();
-                output.writeln(output.dim('  Cleaned up existing server'));
-            }
-            catch {
-                // Continue anyway - the stop/cleanup may partially fail
-            }
-        }
-        const options = {
-            transport,
-            host,
-            port,
-            tools: !tools || tools === 'all' ? 'all' : tools.split(','),
-            daemonize: daemon,
-        };
-        try {
-            output.writeln(output.dim('  Initializing server...'));
-            const manager = getServerManager(options);
-            // Setup event handlers for progress display
-            manager.on('starting', () => {
-                output.writeln(output.dim('  Loading tool registry...'));
-            });
-            manager.on('started', (data) => {
-                output.writeln(output.dim(`  Server started in ${data.startupTime?.toFixed(2) || 0}ms`));
-            });
-            manager.on('log', (log) => {
-                if (ctx.flags.verbose) {
-                    output.writeln(output.dim(`  [${log.level}] ${log.msg}`));
-                }
-            });
-            // Start the server
-            const status = await manager.start();
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 15 },
-                    { key: 'value', header: 'Value', width: 30 }
-                ],
-                data: [
-                    { property: 'Server PID', value: status.pid || process.pid },
-                    { property: 'Transport', value: transport },
-                    { property: 'Host', value: host },
-                    { property: 'Port', value: port },
-                    { property: 'Tools', value: !tools || tools === 'all' ? '27 enabled' : `${tools.split(',').length} enabled` },
-                    { property: 'Status', value: output.success('Running') }
-                ]
-            });
-            output.writeln();
-            output.printSuccess('MCP Server started');
-            if (transport === 'http') {
-                output.writeln(output.dim(`  Health: http://${host}:${port}/health`));
-                output.writeln(output.dim(`  RPC: http://${host}:${port}/rpc`));
-            }
-            else if (transport === 'websocket') {
-                output.writeln(output.dim(`  WebSocket: ws://${host}:${port}/ws`));
-            }
-            if (daemon) {
-                output.writeln(output.dim('  Running in background mode'));
+                    manager = getServerManager();
+                    return [4 /*yield*/, manager.stop()];
+                case 5:
+                    _g.sent();
+                    output.writeln(output.dim('  Cleaned up existing server'));
+                    return [3 /*break*/, 7];
+                case 6:
+                    _a = _g.sent();
+                    return [3 /*break*/, 7];
+                case 7:
+                    options = {
+                        transport: transport,
+                        host: host,
+                        port: port,
+                        tools: !tools || tools === 'all' ? 'all' : tools.split(','),
+                        daemonize: daemon
+                    };
+                    _g.label = 8;
+                case 8:
+                    _g.trys.push([8, 10, , 11]);
+                    output.writeln(output.dim('  Initializing server...'));
+                    manager = getServerManager(options);
+                    // Setup event handlers for progress display
+                    manager.on('starting', function () {
+                        output.writeln(output.dim('  Loading tool registry...'));
+                    });
+                    manager.on('started', function (data) {
+                        var _a;
+                        output.writeln(output.dim("  Server started in " + (((_a = data.startupTime) === null || _a === void 0 ? void 0 : _a.toFixed(2)) || 0) + "ms"));
+                    });
+                    manager.on('log', function (log) {
+                        if (ctx.flags.verbose) {
+                            output.writeln(output.dim("  [" + log.level + "] " + log.msg));
+                        }
+                    });
+                    return [4 /*yield*/, manager.start()];
+                case 9:
+                    status = _g.sent();
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'property', header: 'Property', width: 15 },
+                            { key: 'value', header: 'Value', width: 30 }
+                        ],
+                        data: [
+                            { property: 'Server PID', value: status.pid || process.pid },
+                            { property: 'Transport', value: transport },
+                            { property: 'Host', value: host },
+                            { property: 'Port', value: port },
+                            { property: 'Tools', value: !tools || tools === 'all' ? '27 enabled' : tools.split(',').length + " enabled" },
+                            { property: 'Status', value: output.success('Running') }
+                        ]
+                    });
+                    output.writeln();
+                    output.printSuccess('MCP Server started');
+                    if (transport === 'http') {
+                        output.writeln(output.dim("  Health: http://" + host + ":" + port + "/health"));
+                        output.writeln(output.dim("  RPC: http://" + host + ":" + port + "/rpc"));
+                    }
+                    else if (transport === 'websocket') {
+                        output.writeln(output.dim("  WebSocket: ws://" + host + ":" + port + "/ws"));
+                    }
+                    if (daemon) {
+                        output.writeln(output.dim('  Running in background mode'));
+                    }
+                    return [2 /*return*/, { success: true, data: status }];
+                case 10:
+                    error_1 = _g.sent();
+                    output.printError("Failed to start MCP server: " + error_1.message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 11: return [2 /*return*/];
             }
-            return { success: true, data: status };
-        }
-        catch (error) {
-            output.printError(`Failed to start MCP server: ${error.message}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Stop MCP server
-const stopCommand = {
+var stopCommand = {
     name: 'stop',
     description: 'Stop MCP server',
     options: [
@@ -202,119 +255,157 @@ const stopCommand = {
             short: 'f',
             description: 'Force stop without graceful shutdown',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const force = ctx.flags.force;
-        // Check if server is running
-        const status = await getMCPServerStatus();
-        if (!status.running) {
-            output.printInfo('MCP Server is not running');
-            return { success: true };
-        }
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({
-                message: `Stop MCP server (PID: ${status.pid})?`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        output.printInfo('Stopping MCP Server...');
-        try {
-            const manager = getServerManager();
-            if (!force) {
-                output.writeln(output.dim('  Completing pending requests...'));
-                output.writeln(output.dim('  Closing connections...'));
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var force, status, confirmed, manager, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    force = ctx.flags.force;
+                    return [4 /*yield*/, getMCPServerStatus()];
+                case 1:
+                    status = _a.sent();
+                    if (!status.running) {
+                        output.printInfo('MCP Server is not running');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    if (!(!force && ctx.interactive)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, confirm({
+                            message: "Stop MCP server (PID: " + status.pid + ")?",
+                            "default": false
+                        })];
+                case 2:
+                    confirmed = _a.sent();
+                    if (!confirmed) {
+                        output.printInfo('Operation cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    _a.label = 3;
+                case 3:
+                    output.printInfo('Stopping MCP Server...');
+                    _a.label = 4;
+                case 4:
+                    _a.trys.push([4, 6, , 7]);
+                    manager = getServerManager();
+                    if (!force) {
+                        output.writeln(output.dim('  Completing pending requests...'));
+                        output.writeln(output.dim('  Closing connections...'));
+                    }
+                    return [4 /*yield*/, manager.stop(force)];
+                case 5:
+                    _a.sent();
+                    output.writeln(output.dim('  Releasing resources...'));
+                    output.printSuccess('MCP Server stopped');
+                    return [2 /*return*/, { success: true, data: { stopped: true, force: force } }];
+                case 6:
+                    error_2 = _a.sent();
+                    output.printError("Failed to stop MCP server: " + error_2.message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 7: return [2 /*return*/];
             }
-            await manager.stop(force);
-            output.writeln(output.dim('  Releasing resources...'));
-            output.printSuccess('MCP Server stopped');
-            return { success: true, data: { stopped: true, force } };
-        }
-        catch (error) {
-            output.printError(`Failed to stop MCP server: ${error.message}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // MCP status
-const statusCommand = {
+var statusCommand = {
     name: 'status',
     description: 'Show MCP server status',
-    action: async (ctx) => {
-        try {
-            const status = await getMCPServerStatus();
-            if (ctx.flags.format === 'json') {
-                output.printJson(status);
-                return { success: true, data: status };
-            }
-            output.writeln();
-            output.writeln(output.bold('MCP Server Status'));
-            output.writeln();
-            if (!status.running) {
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 20 },
-                        { key: 'value', header: 'Value', width: 20, align: 'right' }
-                    ],
-                    data: [
-                        { metric: 'Status', value: output.error('Stopped') }
-                    ]
-                });
-                output.writeln();
-                output.writeln(output.dim('Run "claude-flow mcp start" to start the server'));
-                return { success: true, data: status };
-            }
-            const displayData = [
-                { metric: 'Status', value: output.success('Running') },
-                { metric: 'PID', value: status.pid },
-                { metric: 'Transport', value: status.transport },
-                { metric: 'Host', value: status.host },
-                { metric: 'Port', value: status.port },
-            ];
-            if (status.uptime !== undefined) {
-                displayData.push({ metric: 'Uptime', value: formatUptime(status.uptime) });
-            }
-            if (status.startedAt) {
-                displayData.push({ metric: 'Started At', value: status.startedAt });
-            }
-            if (status.health) {
-                displayData.push({
-                    metric: 'Health',
-                    value: status.health.healthy
-                        ? output.success('Healthy')
-                        : output.error(status.health.error || 'Unhealthy')
-                });
-                if (status.health.metrics) {
-                    for (const [key, value] of Object.entries(status.health.metrics)) {
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var status, isStdio, envTransport, displayData, _i, _a, _b, key, value, error_3;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, getMCPServerStatus()];
+                case 1:
+                    status = _c.sent();
+                    // If PID-based check says not running, detect stdio mode
+                    if (!status.running) {
+                        isStdio = !process.stdin.isTTY;
+                        envTransport = process.env.CLAUDE_FLOW_MCP_TRANSPORT;
+                        if (isStdio || envTransport === 'stdio') {
+                            status = {
+                                running: true,
+                                pid: process.pid,
+                                transport: 'stdio'
+                            };
+                        }
+                    }
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(status);
+                        return [2 /*return*/, { success: true, data: status }];
+                    }
+                    output.writeln();
+                    output.writeln(output.bold('MCP Server Status'));
+                    output.writeln();
+                    if (!status.running) {
+                        output.printTable({
+                            columns: [
+                                { key: 'metric', header: 'Metric', width: 20 },
+                                { key: 'value', header: 'Value', width: 20, align: 'right' }
+                            ],
+                            data: [
+                                { metric: 'Status', value: output.error('Stopped') }
+                            ]
+                        });
+                        output.writeln();
+                        output.writeln(output.dim('Run "claude-flow mcp start" to start the server'));
+                        return [2 /*return*/, { success: true, data: status }];
+                    }
+                    displayData = [
+                        { metric: 'Status', value: output.success('Running') },
+                        { metric: 'PID', value: status.pid },
+                        { metric: 'Transport', value: status.transport },
+                    ];
+                    // Only show host/port for non-stdio transports
+                    if (status.transport !== 'stdio') {
+                        displayData.push({ metric: 'Host', value: status.host });
+                        displayData.push({ metric: 'Port', value: status.port });
+                    }
+                    if (status.uptime !== undefined) {
+                        displayData.push({ metric: 'Uptime', value: formatUptime(status.uptime) });
+                    }
+                    if (status.startedAt) {
+                        displayData.push({ metric: 'Started At', value: status.startedAt });
+                    }
+                    if (status.health) {
                         displayData.push({
-                            metric: `  ${key}`,
-                            value: String(value)
+                            metric: 'Health',
+                            value: status.health.healthy
+                                ? output.success('Healthy')
+                                : output.error(status.health.error || 'Unhealthy')
                         });
+                        if (status.health.metrics) {
+                            for (_i = 0, _a = Object.entries(status.health.metrics); _i < _a.length; _i++) {
+                                _b = _a[_i], key = _b[0], value = _b[1];
+                                displayData.push({
+                                    metric: "  " + key,
+                                    value: String(value)
+                                });
+                            }
+                        }
                     }
-                }
+                    output.printTable({
+                        columns: [
+                            { key: 'metric', header: 'Metric', width: 20 },
+                            { key: 'value', header: 'Value', width: 25, align: 'right' }
+                        ],
+                        data: displayData
+                    });
+                    return [2 /*return*/, { success: true, data: status }];
+                case 2:
+                    error_3 = _c.sent();
+                    output.printError("Failed to get status: " + error_3.message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 3: return [2 /*return*/];
             }
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 20 },
-                    { key: 'value', header: 'Value', width: 25, align: 'right' }
-                ],
-                data: displayData
-            });
-            return { success: true, data: status };
-        }
-        catch (error) {
-            output.printError(`Failed to get status: ${error.message}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // List tools
-const toolsCommand = {
+var toolsCommand = {
     name: 'tools',
     description: 'List available MCP tools',
     options: [
@@ -323,98 +414,98 @@ const toolsCommand = {
             short: 'c',
             description: 'Filter by category',
             type: 'string',
-            choices: TOOL_CATEGORIES.map(c => c.value)
+            choices: TOOL_CATEGORIES.map(function (c) { return c.value; })
         },
         {
             name: 'enabled',
             description: 'Show only enabled tools',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const category = ctx.flags.category;
-        // Use local tool registry
-        let tools;
-        // Get tools from local registry
-        const registeredTools = listMCPTools(category);
-        if (registeredTools.length > 0) {
-            tools = registeredTools.map(tool => ({
-                name: tool.name,
-                category: tool.category || 'uncategorized',
-                description: tool.description,
-                enabled: true
-            }));
-        }
-        else {
-            // Fallback to static tool list
-            tools = [
-                // Agent tools
-                { name: 'agent_spawn', category: 'agent', description: 'Spawn a new agent', enabled: true },
-                { name: 'agent_list', category: 'agent', description: 'List all agents', enabled: true },
-                { name: 'agent_terminate', category: 'agent', description: 'Terminate an agent', enabled: true },
-                { name: 'agent_status', category: 'agent', description: 'Get agent status', enabled: true },
-                // Swarm tools
-                { name: 'swarm_init', category: 'swarm', description: 'Initialize swarm topology', enabled: true },
-                { name: 'swarm_status', category: 'swarm', description: 'Get swarm status', enabled: true },
-                { name: 'swarm_scale', category: 'swarm', description: 'Scale swarm size', enabled: true },
-                // Memory tools
-                { name: 'memory_store', category: 'memory', description: 'Store in memory', enabled: true },
-                { name: 'memory_search', category: 'memory', description: 'Search memory', enabled: true },
-                { name: 'memory_list', category: 'memory', description: 'List memory entries', enabled: true },
-                // Config tools
-                { name: 'config_load', category: 'config', description: 'Load configuration', enabled: true },
-                { name: 'config_save', category: 'config', description: 'Save configuration', enabled: true },
-                { name: 'config_validate', category: 'config', description: 'Validate configuration', enabled: true },
-                // Hooks tools
-                { name: 'hooks_pre-edit', category: 'hooks', description: 'Pre-edit hook', enabled: true },
-                { name: 'hooks_post-edit', category: 'hooks', description: 'Post-edit hook', enabled: true },
-                { name: 'hooks_pre-command', category: 'hooks', description: 'Pre-command hook', enabled: true },
-                { name: 'hooks_post-command', category: 'hooks', description: 'Post-command hook', enabled: true },
-                { name: 'hooks_route', category: 'hooks', description: 'Route task to agent', enabled: true },
-                { name: 'hooks_explain', category: 'hooks', description: 'Explain routing', enabled: true },
-                { name: 'hooks_pretrain', category: 'hooks', description: 'Pretrain from repo', enabled: true },
-                { name: 'hooks_metrics', category: 'hooks', description: 'Learning metrics', enabled: true },
-                { name: 'hooks_list', category: 'hooks', description: 'List hooks', enabled: true },
-                // System tools
-                { name: 'system_info', category: 'system', description: 'System information', enabled: true },
-                { name: 'system_health', category: 'system', description: 'Health status', enabled: true },
-                { name: 'system_metrics', category: 'system', description: 'Server metrics', enabled: true },
-            ].filter(t => !category || t.category === category);
-        }
-        if (ctx.flags.format === 'json') {
-            output.printJson(tools);
-            return { success: true, data: tools };
-        }
-        output.writeln();
-        output.writeln(output.bold('Available MCP Tools'));
-        output.writeln();
-        // Group by category
-        const grouped = tools.reduce((acc, tool) => {
-            if (!acc[tool.category])
-                acc[tool.category] = [];
-            acc[tool.category].push(tool);
-            return acc;
-        }, {});
-        for (const [cat, catTools] of Object.entries(grouped)) {
-            output.writeln(output.highlight(cat.charAt(0).toUpperCase() + cat.slice(1)));
-            output.printTable({
-                columns: [
-                    { key: 'name', header: 'Tool', width: 25 },
-                    { key: 'description', header: 'Description', width: 35 },
-                    { key: 'enabled', header: 'Status', width: 10, format: (v) => v ? output.success('Enabled') : output.dim('Disabled') }
-                ],
-                data: catTools,
-                border: false
-            });
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var category, tools, registeredTools, grouped, _i, _a, _b, cat, catTools;
+        return __generator(this, function (_c) {
+            category = ctx.flags.category;
+            registeredTools = listMCPTools(category);
+            if (registeredTools.length > 0) {
+                tools = registeredTools.map(function (tool) { return ({
+                    name: tool.name,
+                    category: tool.category || 'uncategorized',
+                    description: tool.description,
+                    enabled: true
+                }); });
+            }
+            else {
+                // Fallback to static tool list
+                tools = [
+                    // Agent tools
+                    { name: 'agent_spawn', category: 'agent', description: 'Spawn a new agent', enabled: true },
+                    { name: 'agent_list', category: 'agent', description: 'List all agents', enabled: true },
+                    { name: 'agent_terminate', category: 'agent', description: 'Terminate an agent', enabled: true },
+                    { name: 'agent_status', category: 'agent', description: 'Get agent status', enabled: true },
+                    // Swarm tools
+                    { name: 'swarm_init', category: 'swarm', description: 'Initialize swarm topology', enabled: true },
+                    { name: 'swarm_status', category: 'swarm', description: 'Get swarm status', enabled: true },
+                    { name: 'swarm_scale', category: 'swarm', description: 'Scale swarm size', enabled: true },
+                    // Memory tools
+                    { name: 'memory_store', category: 'memory', description: 'Store in memory', enabled: true },
+                    { name: 'memory_search', category: 'memory', description: 'Search memory', enabled: true },
+                    { name: 'memory_list', category: 'memory', description: 'List memory entries', enabled: true },
+                    // Config tools
+                    { name: 'config_load', category: 'config', description: 'Load configuration', enabled: true },
+                    { name: 'config_save', category: 'config', description: 'Save configuration', enabled: true },
+                    { name: 'config_validate', category: 'config', description: 'Validate configuration', enabled: true },
+                    // Hooks tools
+                    { name: 'hooks_pre-edit', category: 'hooks', description: 'Pre-edit hook', enabled: true },
+                    { name: 'hooks_post-edit', category: 'hooks', description: 'Post-edit hook', enabled: true },
+                    { name: 'hooks_pre-command', category: 'hooks', description: 'Pre-command hook', enabled: true },
+                    { name: 'hooks_post-command', category: 'hooks', description: 'Post-command hook', enabled: true },
+                    { name: 'hooks_route', category: 'hooks', description: 'Route task to agent', enabled: true },
+                    { name: 'hooks_explain', category: 'hooks', description: 'Explain routing', enabled: true },
+                    { name: 'hooks_pretrain', category: 'hooks', description: 'Pretrain from repo', enabled: true },
+                    { name: 'hooks_metrics', category: 'hooks', description: 'Learning metrics', enabled: true },
+                    { name: 'hooks_list', category: 'hooks', description: 'List hooks', enabled: true },
+                    // System tools
+                    { name: 'system_info', category: 'system', description: 'System information', enabled: true },
+                    { name: 'system_health', category: 'system', description: 'Health status', enabled: true },
+                    { name: 'system_metrics', category: 'system', description: 'Server metrics', enabled: true },
+                ].filter(function (t) { return !category || t.category === category; });
+            }
+            if (ctx.flags.format === 'json') {
+                output.printJson(tools);
+                return [2 /*return*/, { success: true, data: tools }];
+            }
             output.writeln();
-        }
-        output.printInfo(`Total: ${tools.length} tools`);
-        return { success: true, data: tools };
-    }
+            output.writeln(output.bold('Available MCP Tools'));
+            output.writeln();
+            grouped = tools.reduce(function (acc, tool) {
+                if (!acc[tool.category])
+                    acc[tool.category] = [];
+                acc[tool.category].push(tool);
+                return acc;
+            }, {});
+            for (_i = 0, _a = Object.entries(grouped); _i < _a.length; _i++) {
+                _b = _a[_i], cat = _b[0], catTools = _b[1];
+                output.writeln(output.highlight(cat.charAt(0).toUpperCase() + cat.slice(1)));
+                output.printTable({
+                    columns: [
+                        { key: 'name', header: 'Tool', width: 25 },
+                        { key: 'description', header: 'Description', width: 35 },
+                        { key: 'enabled', header: 'Status', width: 10, format: function (v) { return v ? output.success('Enabled') : output.dim('Disabled'); } }
+                    ],
+                    data: catTools,
+                    border: false
+                });
+                output.writeln();
+            }
+            output.printInfo("Total: " + tools.length + " tools");
+            return [2 /*return*/, { success: true, data: tools }];
+        });
+    }); }
 };
 // Enable/disable tools
-const toggleCommand = {
+var toggleCommand = {
     name: 'toggle',
     description: 'Enable or disable MCP tools',
     options: [
@@ -431,28 +522,31 @@ const toggleCommand = {
             type: 'string'
         }
     ],
-    action: async (ctx) => {
-        const toEnable = ctx.flags.enable;
-        const toDisable = ctx.flags.disable;
-        if (toEnable) {
-            const tools = toEnable.split(',');
-            output.printInfo(`Enabling tools: ${tools.join(', ')}`);
-            output.printSuccess(`Enabled ${tools.length} tools`);
-        }
-        if (toDisable) {
-            const tools = toDisable.split(',');
-            output.printInfo(`Disabling tools: ${tools.join(', ')}`);
-            output.printSuccess(`Disabled ${tools.length} tools`);
-        }
-        if (!toEnable && !toDisable) {
-            output.printError('Use --enable or --disable with comma-separated tool names');
-            return { success: false, exitCode: 1 };
-        }
-        return { success: true };
-    }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var toEnable, toDisable, tools, tools;
+        return __generator(this, function (_a) {
+            toEnable = ctx.flags.enable;
+            toDisable = ctx.flags.disable;
+            if (toEnable) {
+                tools = toEnable.split(',');
+                output.printInfo("Enabling tools: " + tools.join(', '));
+                output.printSuccess("Enabled " + tools.length + " tools");
+            }
+            if (toDisable) {
+                tools = toDisable.split(',');
+                output.printInfo("Disabling tools: " + tools.join(', '));
+                output.printSuccess("Disabled " + tools.length + " tools");
+            }
+            if (!toEnable && !toDisable) {
+                output.printError('Use --enable or --disable with comma-separated tool names');
+                return [2 /*return*/, { success: false, exitCode: 1 }];
+            }
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 // Execute tool
-const execCommand = {
+var execCommand = {
     name: 'exec',
     description: 'Execute an MCP tool',
     options: [
@@ -473,100 +567,121 @@ const execCommand = {
     examples: [
         { command: 'claude-flow mcp exec -t swarm_init -p \'{"topology":"mesh"}\'', description: 'Execute tool' }
     ],
-    action: async (ctx) => {
-        const tool = ctx.flags.tool || ctx.args[0];
-        const paramsStr = ctx.flags.params;
-        if (!tool) {
-            output.printError('Tool name is required. Use --tool or -t');
-            return { success: false, exitCode: 1 };
-        }
-        let params = {};
-        if (paramsStr) {
-            try {
-                params = JSON.parse(paramsStr);
-            }
-            catch (e) {
-                output.printError('Invalid JSON parameters');
-                return { success: false, exitCode: 1 };
-            }
-        }
-        output.printInfo(`Executing tool: ${tool}`);
-        if (Object.keys(params).length > 0) {
-            output.writeln(output.dim(`  Parameters: ${JSON.stringify(params)}`));
-        }
-        try {
-            // Execute through local MCP tool registry
-            if (!hasTool(tool)) {
-                output.printError(`Tool not found: ${tool}`);
-                return { success: false, exitCode: 1 };
-            }
-            const startTime = performance.now();
-            const result = await callMCPTool(tool, params, {
-                sessionId: `cli-${Date.now().toString(36)}`,
-                requestId: `exec-${Date.now()}`,
-            });
-            const duration = performance.now() - startTime;
-            output.writeln();
-            output.printSuccess(`Tool executed in ${duration.toFixed(2)}ms`);
-            if (ctx.flags.format === 'json') {
-                output.printJson({ tool, params, result, duration });
-            }
-            else {
-                output.writeln();
-                output.writeln(output.bold('Result:'));
-                output.printJson(result);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var tool, paramsStr, params, startTime, result, duration, error_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tool = ctx.flags.tool || ctx.args[0];
+                    paramsStr = ctx.flags.params;
+                    if (!tool) {
+                        output.printError('Tool name is required. Use --tool or -t');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    params = {};
+                    if (paramsStr) {
+                        try {
+                            params = JSON.parse(paramsStr);
+                        }
+                        catch (e) {
+                            output.printError('Invalid JSON parameters');
+                            return [2 /*return*/, { success: false, exitCode: 1 }];
+                        }
+                    }
+                    output.printInfo("Executing tool: " + tool);
+                    if (Object.keys(params).length > 0) {
+                        output.writeln(output.dim("  Parameters: " + JSON.stringify(params)));
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    // Execute through local MCP tool registry
+                    if (!hasTool(tool)) {
+                        output.printError("Tool not found: " + tool);
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    startTime = performance.now();
+                    return [4 /*yield*/, callMCPTool(tool, params, {
+                            sessionId: "cli-" + Date.now().toString(36),
+                            requestId: "exec-" + Date.now()
+                        })];
+                case 2:
+                    result = _a.sent();
+                    duration = performance.now() - startTime;
+                    output.writeln();
+                    output.printSuccess("Tool executed in " + duration.toFixed(2) + "ms");
+                    if (ctx.flags.format === 'json') {
+                        output.printJson({ tool: tool, params: params, result: result, duration: duration });
+                    }
+                    else {
+                        output.writeln();
+                        output.writeln(output.bold('Result:'));
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: { tool: tool, params: params, result: result, duration: duration } }];
+                case 3:
+                    error_4 = _a.sent();
+                    output.printError("Tool execution failed: " + error_4.message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: true, data: { tool, params, result, duration } };
-        }
-        catch (error) {
-            output.printError(`Tool execution failed: ${error.message}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Health check command
-const healthCommand = {
+var healthCommand = {
     name: 'health',
     description: 'Check MCP server health',
-    action: async (ctx) => {
-        try {
-            const status = await getMCPServerStatus();
-            if (!status.running) {
-                output.printError('MCP Server is not running');
-                return { success: false, exitCode: 1 };
-            }
-            const manager = getServerManager();
-            const health = await manager.checkHealth();
-            if (ctx.flags.format === 'json') {
-                output.printJson(health);
-                return { success: true, data: health };
-            }
-            output.writeln();
-            output.writeln(output.bold('MCP Server Health'));
-            output.writeln();
-            if (health.healthy) {
-                output.printSuccess('Server is healthy');
-            }
-            else {
-                output.printError(`Server is unhealthy: ${health.error || 'Unknown error'}`);
-            }
-            if (health.metrics) {
-                output.writeln();
-                output.writeln(output.bold('Metrics:'));
-                for (const [key, value] of Object.entries(health.metrics)) {
-                    output.writeln(`  ${key}: ${value}`);
-                }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var status, manager, health, _i, _a, _b, key, value, error_5;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 3, , 4]);
+                    return [4 /*yield*/, getMCPServerStatus()];
+                case 1:
+                    status = _c.sent();
+                    if (!status.running) {
+                        output.printError('MCP Server is not running');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    manager = getServerManager();
+                    return [4 /*yield*/, manager.checkHealth()];
+                case 2:
+                    health = _c.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(health);
+                        return [2 /*return*/, { success: true, data: health }];
+                    }
+                    output.writeln();
+                    output.writeln(output.bold('MCP Server Health'));
+                    output.writeln();
+                    if (health.healthy) {
+                        output.printSuccess('Server is healthy');
+                    }
+                    else {
+                        output.printError("Server is unhealthy: " + (health.error || 'Unknown error'));
+                    }
+                    if (health.metrics) {
+                        output.writeln();
+                        output.writeln(output.bold('Metrics:'));
+                        for (_i = 0, _a = Object.entries(health.metrics); _i < _a.length; _i++) {
+                            _b = _a[_i], key = _b[0], value = _b[1];
+                            output.writeln("  " + key + ": " + value);
+                        }
+                    }
+                    return [2 /*return*/, { success: health.healthy, data: health }];
+                case 3:
+                    error_5 = _c.sent();
+                    output.printError("Health check failed: " + error_5.message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: health.healthy, data: health };
-        }
-        catch (error) {
-            output.printError(`Health check failed: ${error.message}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Logs command
-const logsCommand = {
+var logsCommand = {
     name: 'logs',
     description: 'Show MCP server logs',
     options: [
@@ -575,14 +690,14 @@ const logsCommand = {
             short: 'n',
             description: 'Number of lines',
             type: 'number',
-            default: 20
+            "default": 20
         },
         {
             name: 'follow',
             short: 'f',
             description: 'Follow log output',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'level',
@@ -591,40 +706,43 @@ const logsCommand = {
             choices: ['debug', 'info', 'warn', 'error']
         }
     ],
-    action: async (ctx) => {
-        const lines = ctx.flags.lines;
-        // Default logs (loaded from actual log file when available)
-        const logs = [
-            { time: new Date().toISOString(), level: 'info', message: 'MCP Server started on stdio' },
-            { time: new Date().toISOString(), level: 'info', message: 'Registered 27 tools' },
-            { time: new Date().toISOString(), level: 'debug', message: 'Received request: tools/list' },
-            { time: new Date().toISOString(), level: 'info', message: 'Session initialized' },
-        ].slice(-lines);
-        output.writeln();
-        output.writeln(output.bold('MCP Server Logs'));
-        output.writeln();
-        for (const log of logs) {
-            let levelStr;
-            switch (log.level) {
-                case 'error':
-                    levelStr = output.error(log.level.toUpperCase().padEnd(5));
-                    break;
-                case 'warn':
-                    levelStr = output.warning(log.level.toUpperCase().padEnd(5));
-                    break;
-                case 'debug':
-                    levelStr = output.dim(log.level.toUpperCase().padEnd(5));
-                    break;
-                default:
-                    levelStr = output.info(log.level.toUpperCase().padEnd(5));
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var lines, logs, _i, logs_1, log, levelStr;
+        return __generator(this, function (_a) {
+            lines = ctx.flags.lines;
+            logs = [
+                { time: new Date().toISOString(), level: 'info', message: 'MCP Server started on stdio' },
+                { time: new Date().toISOString(), level: 'info', message: 'Registered 27 tools' },
+                { time: new Date().toISOString(), level: 'debug', message: 'Received request: tools/list' },
+                { time: new Date().toISOString(), level: 'info', message: 'Session initialized' },
+            ].slice(-lines);
+            output.writeln();
+            output.writeln(output.bold('MCP Server Logs'));
+            output.writeln();
+            for (_i = 0, logs_1 = logs; _i < logs_1.length; _i++) {
+                log = logs_1[_i];
+                levelStr = void 0;
+                switch (log.level) {
+                    case 'error':
+                        levelStr = output.error(log.level.toUpperCase().padEnd(5));
+                        break;
+                    case 'warn':
+                        levelStr = output.warning(log.level.toUpperCase().padEnd(5));
+                        break;
+                    case 'debug':
+                        levelStr = output.dim(log.level.toUpperCase().padEnd(5));
+                        break;
+                    default:
+                        levelStr = output.info(log.level.toUpperCase().padEnd(5));
+                }
+                output.writeln(output.dim(log.time) + " " + levelStr + " " + log.message);
             }
-            output.writeln(`${output.dim(log.time)} ${levelStr} ${log.message}`);
-        }
-        return { success: true, data: logs };
-    }
+            return [2 /*return*/, { success: true, data: logs }];
+        });
+    }); }
 };
 // Restart command
-const restartCommand = {
+var restartCommand = {
     name: 'restart',
     description: 'Restart MCP server',
     options: [
@@ -633,27 +751,37 @@ const restartCommand = {
             short: 'f',
             description: 'Force restart without graceful shutdown',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const force = ctx.flags.force;
-        output.printInfo('Restarting MCP Server...');
-        try {
-            const manager = getServerManager();
-            const status = await manager.restart();
-            output.printSuccess('MCP Server restarted');
-            output.writeln(output.dim(`  PID: ${status.pid}`));
-            return { success: true, data: status };
-        }
-        catch (error) {
-            output.printError(`Failed to restart: ${error.message}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var force, manager, status, error_6;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    force = ctx.flags.force;
+                    output.printInfo('Restarting MCP Server...');
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    manager = getServerManager();
+                    return [4 /*yield*/, manager.restart()];
+                case 2:
+                    status = _a.sent();
+                    output.printSuccess('MCP Server restarted');
+                    output.writeln(output.dim("  PID: " + status.pid));
+                    return [2 /*return*/, { success: true, data: status }];
+                case 3:
+                    error_6 = _a.sent();
+                    output.printError("Failed to restart: " + error_6.message);
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); }
 };
 // Main MCP command
-export const mcpCommand = {
+export var mcpCommand = {
     name: 'mcp',
     description: 'MCP server management',
     subcommands: [
@@ -675,26 +803,28 @@ export const mcpCommand = {
         { command: 'claude-flow mcp tools', description: 'List tools' },
         { command: 'claude-flow mcp stop', description: 'Stop the server' }
     ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('MCP Server Management'));
-        output.writeln();
-        output.writeln('Usage: claude-flow mcp <subcommand> [options]');
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('start')}    - Start MCP server`,
-            `${output.highlight('stop')}     - Stop MCP server`,
-            `${output.highlight('status')}   - Show server status`,
-            `${output.highlight('health')}   - Check server health`,
-            `${output.highlight('restart')}  - Restart MCP server`,
-            `${output.highlight('tools')}    - List available tools`,
-            `${output.highlight('toggle')}   - Enable/disable tools`,
-            `${output.highlight('exec')}     - Execute a tool`,
-            `${output.highlight('logs')}     - Show server logs`
-        ]);
-        return { success: true };
-    }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            output.writeln();
+            output.writeln(output.bold('MCP Server Management'));
+            output.writeln();
+            output.writeln('Usage: claude-flow mcp <subcommand> [options]');
+            output.writeln();
+            output.writeln('Subcommands:');
+            output.printList([
+                output.highlight('start') + "    - Start MCP server",
+                output.highlight('stop') + "     - Stop MCP server",
+                output.highlight('status') + "   - Show server status",
+                output.highlight('health') + "   - Check server health",
+                output.highlight('restart') + "  - Restart MCP server",
+                output.highlight('tools') + "    - List available tools",
+                output.highlight('toggle') + "   - Enable/disable tools",
+                output.highlight('exec') + "     - Execute a tool",
+                output.highlight('logs') + "     - Show server logs"
+            ]);
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 export default mcpCommand;
 //# sourceMappingURL=mcp.js.map