kynjal-cli 3.1.3 → 4.0.0

package/dist/src/mcp-server.js

@@ -16,6 +16,68 @@
  * @module @claude-flow/cli/mcp-server
  * @version 3.0.0
  */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 { EventEmitter } from 'events';
 import { randomUUID } from 'crypto';
 import * as path from 'path';
@@ -24,12 +86,12 @@ import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 // ESM-compatible __dirname
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
 /**
  * Default configuration
  */
-const DEFAULT_OPTIONS = {
+var DEFAULT_OPTIONS = {
     transport: 'stdio',
     host: 'localhost',
     port: 3000,
@@ -37,514 +99,736 @@ const DEFAULT_OPTIONS = {
     logFile: path.join(os.tmpdir(), 'claude-flow-mcp.log'),
     tools: 'all',
     daemonize: false,
-    timeout: 30000,
+    timeout: 30000
 };
 /**
  * MCP Server Manager
  *
  * Manages the lifecycle of the MCP server process
  */
-export class MCPServerManager extends EventEmitter {
-    options;
-    process;
-    server;
-    startTime;
-    healthCheckInterval;
-    constructor(options = {}) {
-        super();
-        this.options = { ...DEFAULT_OPTIONS, ...options };
+var MCPServerManager = /** @class */ (function (_super) {
+    __extends(MCPServerManager, _super);
+    function MCPServerManager(options) {
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this) || this;
+        _this.options = __assign(__assign({}, DEFAULT_OPTIONS), options);
+        return _this;
     }
     /**
      * Start the MCP server
      */
-    async start() {
-        // Check if already running
-        const status = await this.getStatus();
-        if (status.running) {
-            throw new Error(`MCP Server already running (PID: ${status.pid})`);
-        }
-        const startTime = performance.now();
-        this.startTime = new Date();
-        this.emit('starting', { options: this.options });
-        try {
-            if (this.options.transport === 'stdio') {
-                // For stdio transport, spawn the server process
-                await this.startStdioServer();
-            }
-            else {
-                // For HTTP/WebSocket, start in-process server
-                await this.startHttpServer();
-            }
-            const duration = performance.now() - startTime;
-            // Write PID file
-            await this.writePidFile();
-            // Start health check monitoring
-            this.startHealthMonitoring();
-            const finalStatus = await this.getStatus();
-            this.emit('started', {
-                ...finalStatus,
-                startupTime: duration,
+    MCPServerManager.prototype.start = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var status, startTime, duration, finalStatus, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getStatus()];
+                    case 1:
+                        status = _a.sent();
+                        if (status.running) {
+                            throw new Error("MCP Server already running (PID: " + status.pid + ")");
+                        }
+                        startTime = performance.now();
+                        this.startTime = new Date();
+                        this.emit('starting', { options: this.options });
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 9, , 10]);
+                        if (!(this.options.transport === 'stdio')) return [3 /*break*/, 4];
+                        // For stdio transport, spawn the server process
+                        return [4 /*yield*/, this.startStdioServer()];
+                    case 3:
+                        // For stdio transport, spawn the server process
+                        _a.sent();
+                        return [3 /*break*/, 6];
+                    case 4: 
+                    // For HTTP/WebSocket, start in-process server
+                    return [4 /*yield*/, this.startHttpServer()];
+                    case 5:
+                        // For HTTP/WebSocket, start in-process server
+                        _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        duration = performance.now() - startTime;
+                        // Write PID file
+                        return [4 /*yield*/, this.writePidFile()];
+                    case 7:
+                        // Write PID file
+                        _a.sent();
+                        // Start health check monitoring
+                        this.startHealthMonitoring();
+                        return [4 /*yield*/, this.getStatus()];
+                    case 8:
+                        finalStatus = _a.sent();
+                        this.emit('started', __assign(__assign({}, finalStatus), { startupTime: duration }));
+                        return [2 /*return*/, finalStatus];
+                    case 9:
+                        error_1 = _a.sent();
+                        this.emit('error', error_1);
+                        throw error_1;
+                    case 10: return [2 /*return*/];
+                }
             });
-            return finalStatus;
-        }
-        catch (error) {
-            this.emit('error', error);
-            throw error;
-        }
-    }
+        });
+    };
     /**
      * Stop the MCP server
      */
-    async stop(force = false) {
-        const status = await this.getStatus();
-        if (!status.running) {
-            return;
-        }
-        this.emit('stopping', { force });
-        try {
-            // Stop health monitoring
-            if (this.healthCheckInterval) {
-                clearInterval(this.healthCheckInterval);
-                this.healthCheckInterval = undefined;
-            }
-            if (this.process) {
-                // Graceful shutdown
-                if (!force) {
-                    this.process.kill('SIGTERM');
-                    await this.waitForExit(5000);
-                }
-                // Force kill if still running
-                if (this.process && !this.process.killed) {
-                    this.process.kill('SIGKILL');
+    MCPServerManager.prototype.stop = function (force) {
+        if (force === void 0) { force = false; }
+        return __awaiter(this, void 0, Promise, function () {
+            var status, error_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getStatus()];
+                    case 1:
+                        status = _a.sent();
+                        if (!status.running) {
+                            return [2 /*return*/];
+                        }
+                        this.emit('stopping', { force: force });
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 9, , 10]);
+                        // Stop health monitoring
+                        if (this.healthCheckInterval) {
+                            clearInterval(this.healthCheckInterval);
+                            this.healthCheckInterval = undefined;
+                        }
+                        if (!this.process) return [3 /*break*/, 5];
+                        if (!!force) return [3 /*break*/, 4];
+                        this.process.kill('SIGTERM');
+                        return [4 /*yield*/, this.waitForExit(5000)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        // Force kill if still running
+                        if (this.process && !this.process.killed) {
+                            this.process.kill('SIGKILL');
+                        }
+                        this.process = undefined;
+                        _a.label = 5;
+                    case 5:
+                        if (!this.server) return [3 /*break*/, 7];
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                _this.server.close(function () { return resolve(); });
+                            })];
+                    case 6:
+                        _a.sent();
+                        this.server = undefined;
+                        _a.label = 7;
+                    case 7: 
+                    // Remove PID file
+                    return [4 /*yield*/, this.removePidFile()];
+                    case 8:
+                        // Remove PID file
+                        _a.sent();
+                        this.startTime = undefined;
+                        this.emit('stopped');
+                        return [3 /*break*/, 10];
+                    case 9:
+                        error_2 = _a.sent();
+                        this.emit('error', error_2);
+                        throw error_2;
+                    case 10: return [2 /*return*/];
                 }
-                this.process = undefined;
-            }
-            if (this.server) {
-                await new Promise((resolve) => {
-                    this.server.close(() => resolve());
-                });
-                this.server = undefined;
-            }
-            // Remove PID file
-            await this.removePidFile();
-            this.startTime = undefined;
-            this.emit('stopped');
-        }
-        catch (error) {
-            this.emit('error', error);
-            throw error;
-        }
-    }
+            });
+        });
+    };
     /**
      * Get server status
      */
-    async getStatus() {
-        // Check PID file
-        const pid = await this.readPidFile();
-        if (!pid) {
-            return { running: false };
-        }
-        // Check if process is running
-        const isRunning = this.isProcessRunning(pid);
-        if (!isRunning) {
-            // Clean up stale PID file
-            await this.removePidFile();
-            return { running: false };
-        }
-        // Build status
-        const status = {
-            running: true,
-            pid,
-            transport: this.options.transport,
-            host: this.options.host,
-            port: this.options.port,
-            startedAt: this.startTime?.toISOString(),
-            uptime: this.startTime
-                ? Math.floor((Date.now() - this.startTime.getTime()) / 1000)
-                : undefined,
-        };
-        // Get health status for HTTP transport
-        if (this.options.transport !== 'stdio') {
-            status.health = await this.checkHealth();
-        }
-        return status;
-    }
+    MCPServerManager.prototype.getStatus = function () {
+        var _a, _b;
+        return __awaiter(this, void 0, Promise, function () {
+            var pid, isStdio, envTransport, isRunning, status, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.readPidFile()];
+                    case 1:
+                        pid = _d.sent();
+                        if (!pid) {
+                            isStdio = !process.stdin.isTTY;
+                            envTransport = process.env.CLAUDE_FLOW_MCP_TRANSPORT;
+                            if (isStdio || envTransport === 'stdio' || this.options.transport === 'stdio') {
+                                return [2 /*return*/, {
+                                        running: true,
+                                        pid: process.pid,
+                                        transport: 'stdio',
+                                        startedAt: (_a = this.startTime) === null || _a === void 0 ? void 0 : _a.toISOString(),
+                                        uptime: this.startTime
+                                            ? Math.floor((Date.now() - this.startTime.getTime()) / 1000)
+                                            : undefined
+                                    }];
+                            }
+                            return [2 /*return*/, { running: false }];
+                        }
+                        isRunning = this.isProcessRunning(pid);
+                        if (!!isRunning) return [3 /*break*/, 3];
+                        // Clean up stale PID file
+                        return [4 /*yield*/, this.removePidFile()];
+                    case 2:
+                        // Clean up stale PID file
+                        _d.sent();
+                        return [2 /*return*/, { running: false }];
+                    case 3:
+                        status = {
+                            running: true,
+                            pid: pid,
+                            transport: this.options.transport,
+                            host: this.options.host,
+                            port: this.options.port,
+                            startedAt: (_b = this.startTime) === null || _b === void 0 ? void 0 : _b.toISOString(),
+                            uptime: this.startTime
+                                ? Math.floor((Date.now() - this.startTime.getTime()) / 1000)
+                                : undefined
+                        };
+                        if (!(this.options.transport !== 'stdio')) return [3 /*break*/, 5];
+                        _c = status;
+                        return [4 /*yield*/, this.checkHealth()];
+                    case 4:
+                        _c.health = _d.sent();
+                        _d.label = 5;
+                    case 5: return [2 /*return*/, status];
+                }
+            });
+        });
+    };
     /**
      * Check server health
      */
-    async checkHealth() {
-        if (this.options.transport === 'stdio') {
-            // For stdio, check if process is running
-            const pid = await this.readPidFile();
-            if (pid === null) {
-                return { healthy: false, error: 'No PID file found' };
-            }
-            if (!this.isProcessRunning(pid)) {
-                // Clean up stale PID file
-                await this.removePidFile();
-                return { healthy: false, error: 'Process not running (cleaned up stale PID)' };
-            }
-            return { healthy: true };
-        }
-        // For HTTP/WebSocket, make health check request
-        try {
-            const response = await this.httpRequest(`http://${this.options.host}:${this.options.port}/health`, 'GET', this.options.timeout);
-            return {
-                healthy: response.status === 'ok',
-                metrics: {
-                    connections: response.connections || 0,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                healthy: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-        }
-    }
+    MCPServerManager.prototype.checkHealth = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var pid, response, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.options.transport === 'stdio')) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.readPidFile()];
+                    case 1:
+                        pid = _a.sent();
+                        if (pid === null) {
+                            return [2 /*return*/, { healthy: false, error: 'No PID file found' }];
+                        }
+                        if (!!this.isProcessRunning(pid)) return [3 /*break*/, 3];
+                        // Clean up stale PID file
+                        return [4 /*yield*/, this.removePidFile()];
+                    case 2:
+                        // Clean up stale PID file
+                        _a.sent();
+                        return [2 /*return*/, { healthy: false, error: 'Process not running (cleaned up stale PID)' }];
+                    case 3: return [2 /*return*/, { healthy: true }];
+                    case 4:
+                        _a.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, this.httpRequest("http://" + this.options.host + ":" + this.options.port + "/health", 'GET', this.options.timeout)];
+                    case 5:
+                        response = _a.sent();
+                        return [2 /*return*/, {
+                                healthy: response.status === 'ok',
+                                metrics: {
+                                    connections: response.connections || 0
+                                }
+                            }];
+                    case 6:
+                        error_3 = _a.sent();
+                        return [2 /*return*/, {
+                                healthy: false,
+                                error: error_3 instanceof Error ? error_3.message : 'Unknown error'
+                            }];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Restart the server
      */
-    async restart() {
-        await this.stop();
-        return await this.start();
-    }
+    MCPServerManager.prototype.restart = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.stop()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.start()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Start stdio server in-process
      * Handles stdin/stdout directly like V2 implementation
      */
-    async startStdioServer() {
-        // Import the tool registry
-        const { listMCPTools, callMCPTool, hasTool } = await import('./mcp-client.js');
-        const VERSION = '3.0.0';
-        const sessionId = `mcp-${Date.now()}-${randomUUID().slice(0, 8)}`;
-        // Log to stderr to not corrupt stdout
-        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Starting in stdio mode`);
-        console.error(JSON.stringify({
-            arch: process.arch,
-            mode: 'mcp-stdio',
-            nodeVersion: process.version,
-            pid: process.pid,
-            platform: process.platform,
-            protocol: 'stdio',
-            sessionId,
-            version: VERSION,
-        }));
-        // Send server initialization notification
-        console.log(JSON.stringify({
-            jsonrpc: '2.0',
-            method: 'server.initialized',
-            params: {
-                serverInfo: {
-                    name: 'kynjalflow',
-                    version: VERSION,
-                    capabilities: {
-                        tools: { listChanged: true },
-                        resources: { subscribe: true, listChanged: true },
-                    },
-                },
-            },
-        }));
-        // Handle stdin messages
-        let buffer = '';
-        process.stdin.on('data', async (chunk) => {
-            buffer += chunk.toString();
-            // Process complete JSON messages
-            let lines = buffer.split('\n');
-            buffer = lines.pop() || ''; // Keep incomplete line in buffer
-            for (const line of lines) {
-                if (line.trim()) {
-                    try {
-                        const message = JSON.parse(line);
-                        const response = await this.handleMCPMessage(message, sessionId);
-                        if (response) {
-                            console.log(JSON.stringify(response));
-                        }
-                    }
-                    catch (error) {
-                        console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to parse message:`, error instanceof Error ? error.message : String(error));
-                    }
+    MCPServerManager.prototype.startStdioServer = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _a, listMCPTools, callMCPTool, hasTool, VERSION, sessionId, MAX_BUFFER_SIZE, buffer;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, import('./mcp-client.js')];
+                    case 1:
+                        _a = _b.sent(), listMCPTools = _a.listMCPTools, callMCPTool = _a.callMCPTool, hasTool = _a.hasTool;
+                        VERSION = '3.0.0';
+                        sessionId = "mcp-" + Date.now() + "-" + randomUUID().slice(0, 8);
+                        // Log to stderr to not corrupt stdout
+                        console.error("[" + new Date().toISOString() + "] INFO [claude-flow-mcp] (" + sessionId + ") Starting in stdio mode");
+                        console.error(JSON.stringify({
+                            arch: process.arch,
+                            mode: 'mcp-stdio',
+                            nodeVersion: process.version,
+                            pid: process.pid,
+                            platform: process.platform,
+                            protocol: 'stdio',
+                            sessionId: sessionId,
+                            version: VERSION
+                        }));
+                        // Send server initialization notification
+                        console.log(JSON.stringify({
+                            jsonrpc: '2.0',
+                            method: 'server.initialized',
+                            params: {
+                                serverInfo: {
+                                    name: 'ruflo',
+                                    version: VERSION,
+                                    capabilities: {
+                                        tools: { listChanged: true },
+                                        resources: { subscribe: true, listChanged: true }
+                                    }
+                                }
+                            }
+                        }));
+                        MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+                        buffer = '';
+                        process.stdin.on('data', function (chunk) { return __awaiter(_this, void 0, void 0, function () {
+                            var lines, _i, lines_1, line, message, response, error_4;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        buffer += chunk.toString();
+                                        if (buffer.length > MAX_BUFFER_SIZE) {
+                                            console.error("[" + new Date().toISOString() + "] ERROR [claude-flow-mcp] Buffer exceeded " + MAX_BUFFER_SIZE + " bytes, rejecting");
+                                            buffer = '';
+                                            console.log(JSON.stringify({
+                                                jsonrpc: '2.0',
+                                                error: { code: -32600, message: 'Request too large' }
+                                            }));
+                                            return [2 /*return*/];
+                                        }
+                                        lines = buffer.split('\n');
+                                        buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                                        _i = 0, lines_1 = lines;
+                                        _a.label = 1;
+                                    case 1:
+                                        if (!(_i < lines_1.length)) return [3 /*break*/, 6];
+                                        line = lines_1[_i];
+                                        if (!line.trim()) return [3 /*break*/, 5];
+                                        _a.label = 2;
+                                    case 2:
+                                        _a.trys.push([2, 4, , 5]);
+                                        message = JSON.parse(line);
+                                        return [4 /*yield*/, this.handleMCPMessage(message, sessionId)];
+                                    case 3:
+                                        response = _a.sent();
+                                        if (response) {
+                                            console.log(JSON.stringify(response));
+                                        }
+                                        return [3 /*break*/, 5];
+                                    case 4:
+                                        error_4 = _a.sent();
+                                        console.error("[" + new Date().toISOString() + "] ERROR [claude-flow-mcp] Failed to parse message:", error_4 instanceof Error ? error_4.message : String(error_4));
+                                        return [3 /*break*/, 5];
+                                    case 5:
+                                        _i++;
+                                        return [3 /*break*/, 1];
+                                    case 6: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        process.stdin.on('end', function () {
+                            console.error("[" + new Date().toISOString() + "] INFO [claude-flow-mcp] (" + sessionId + ") stdin closed, shutting down...");
+                            process.exit(0);
+                        });
+                        // Handle process termination
+                        process.on('SIGINT', function () {
+                            console.error("[" + new Date().toISOString() + "] INFO [claude-flow-mcp] (" + sessionId + ") Received SIGINT, shutting down...");
+                            process.exit(0);
+                        });
+                        process.on('SIGTERM', function () {
+                            console.error("[" + new Date().toISOString() + "] INFO [claude-flow-mcp] (" + sessionId + ") Received SIGTERM, shutting down...");
+                            process.exit(0);
+                        });
+                        // Mark as ready immediately for stdio
+                        this.emit('ready');
+                        return [2 /*return*/];
                 }
-            }
-        });
-        process.stdin.on('end', () => {
-            console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) stdin closed, shutting down...`);
-            process.exit(0);
-        });
-        // Handle process termination
-        process.on('SIGINT', () => {
-            console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Received SIGINT, shutting down...`);
-            process.exit(0);
-        });
-        process.on('SIGTERM', () => {
-            console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Received SIGTERM, shutting down...`);
-            process.exit(0);
+            });
         });
-        // Mark as ready immediately for stdio
-        this.emit('ready');
-    }
+    };
     /**
      * Handle incoming MCP message
      */
-    async handleMCPMessage(message, sessionId) {
-        const { listMCPTools, callMCPTool, hasTool } = await import('./mcp-client.js');
-        if (!message.method) {
-            return {
-                jsonrpc: '2.0',
-                id: message.id,
-                error: { code: -32600, message: 'Invalid Request: missing method' },
-            };
-        }
-        const params = (message.params || {});
-        try {
-            switch (message.method) {
-                case 'initialize':
-                    return {
-                        jsonrpc: '2.0',
-                        id: message.id,
-                        result: {
-                            protocolVersion: '2024-11-05',
-                            serverInfo: { name: 'kynjalflow', version: '3.0.0' },
-                            capabilities: {
-                                tools: { listChanged: true },
-                                resources: { subscribe: true, listChanged: true },
-                            },
-                        },
-                    };
-                case 'tools/list':
-                    const tools = listMCPTools();
-                    return {
-                        jsonrpc: '2.0',
-                        id: message.id,
-                        result: {
-                            tools: tools.map(tool => ({
-                                name: tool.name,
-                                description: tool.description,
-                                inputSchema: tool.inputSchema,
-                            })),
-                        },
-                    };
-                case 'tools/call':
-                    const toolName = params.name;
-                    const toolParams = (params.arguments || {});
-                    if (!hasTool(toolName)) {
-                        return {
+    MCPServerManager.prototype.handleMCPMessage = function (message, sessionId) {
+        return __awaiter(this, void 0, Promise, function () {
+            var _a, listMCPTools, callMCPTool, hasTool, params, _b, tools, toolName, toolParams, result, error_5, error_6;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, import('./mcp-client.js')];
+                    case 1:
+                        _a = _c.sent(), listMCPTools = _a.listMCPTools, callMCPTool = _a.callMCPTool, hasTool = _a.hasTool;
+                        if (!message.method) {
+                            return [2 /*return*/, {
+                                    jsonrpc: '2.0',
+                                    id: message.id,
+                                    error: { code: -32600, message: 'Invalid Request: missing method' }
+                                }];
+                        }
+                        params = (message.params || {});
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, 13, , 14]);
+                        _b = message.method;
+                        switch (_b) {
+                            case 'initialize': return [3 /*break*/, 3];
+                            case 'tools/list': return [3 /*break*/, 4];
+                            case 'tools/call': return [3 /*break*/, 5];
+                            case 'notifications/initialized': return [3 /*break*/, 9];
+                            case 'ping': return [3 /*break*/, 10];
+                        }
+                        return [3 /*break*/, 11];
+                    case 3: return [2 /*return*/, {
                             jsonrpc: '2.0',
                             id: message.id,
-                            error: { code: -32601, message: `Tool not found: ${toolName}` },
-                        };
-                    }
-                    try {
-                        const result = await callMCPTool(toolName, toolParams, { sessionId });
-                        return {
+                            result: {
+                                protocolVersion: '2024-11-05',
+                                serverInfo: { name: 'ruflo', version: '3.0.0' },
+                                capabilities: {
+                                    tools: { listChanged: true },
+                                    resources: { subscribe: true, listChanged: true }
+                                }
+                            }
+                        }];
+                    case 4:
+                        tools = listMCPTools();
+                        return [2 /*return*/, {
+                                jsonrpc: '2.0',
+                                id: message.id,
+                                result: {
+                                    tools: tools.map(function (tool) { return ({
+                                        name: tool.name,
+                                        description: tool.description,
+                                        inputSchema: tool.inputSchema
+                                    }); })
+                                }
+                            }];
+                    case 5:
+                        toolName = params.name;
+                        toolParams = (params.arguments || {});
+                        if (!hasTool(toolName)) {
+                            return [2 /*return*/, {
+                                    jsonrpc: '2.0',
+                                    id: message.id,
+                                    error: { code: -32601, message: "Tool not found: " + toolName }
+                                }];
+                        }
+                        _c.label = 6;
+                    case 6:
+                        _c.trys.push([6, 8, , 9]);
+                        return [4 /*yield*/, callMCPTool(toolName, toolParams, { sessionId: sessionId })];
+                    case 7:
+                        result = _c.sent();
+                        return [2 /*return*/, {
+                                jsonrpc: '2.0',
+                                id: message.id,
+                                result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] }
+                            }];
+                    case 8:
+                        error_5 = _c.sent();
+                        return [2 /*return*/, {
+                                jsonrpc: '2.0',
+                                id: message.id,
+                                error: {
+                                    code: -32603,
+                                    message: error_5 instanceof Error ? error_5.message : 'Tool execution failed'
+                                }
+                            }];
+                    case 9:
+                        // Client notification - no response needed
+                        console.error("[" + new Date().toISOString() + "] INFO [claude-flow-mcp] (" + sessionId + ") Client initialized");
+                        return [2 /*return*/, null];
+                    case 10: return [2 /*return*/, {
                             jsonrpc: '2.0',
                             id: message.id,
-                            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
-                        };
-                    }
-                    catch (error) {
-                        return {
+                            result: {}
+                        }];
+                    case 11: return [2 /*return*/, {
                             jsonrpc: '2.0',
                             id: message.id,
-                            error: {
-                                code: -32603,
-                                message: error instanceof Error ? error.message : 'Tool execution failed',
-                            },
-                        };
-                    }
-                case 'notifications/initialized':
-                    // Client notification - no response needed
-                    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Client initialized`);
-                    return null;
-                case 'ping':
-                    return {
-                        jsonrpc: '2.0',
-                        id: message.id,
-                        result: {},
-                    };
-                default:
-                    return {
-                        jsonrpc: '2.0',
-                        id: message.id,
-                        error: { code: -32601, message: `Method not found: ${message.method}` },
-                    };
-            }
-        }
-        catch (error) {
-            console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Error handling ${message.method}:`, error);
-            return {
-                jsonrpc: '2.0',
-                id: message.id,
-                error: {
-                    code: -32603,
-                    message: error instanceof Error ? error.message : 'Internal error',
-                },
-            };
-        }
-    }
+                            error: { code: -32601, message: "Method not found: " + message.method }
+                        }];
+                    case 12: return [3 /*break*/, 14];
+                    case 13:
+                        error_6 = _c.sent();
+                        console.error("[" + new Date().toISOString() + "] ERROR [claude-flow-mcp] Error handling " + message.method + ":", error_6);
+                        return [2 /*return*/, {
+                                jsonrpc: '2.0',
+                                id: message.id,
+                                error: {
+                                    code: -32603,
+                                    message: error_6 instanceof Error ? error_6.message : 'Internal error'
+                                }
+                            }];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Start HTTP server in-process
      */
-    async startHttpServer() {
-        // Dynamically import the MCP server package
-        // FIX for issue #942: Use proper package import instead of broken relative path
-        const { createMCPServer } = await import('@claude-flow/mcp');
-        const logger = {
-            debug: (msg, data) => this.emit('log', { level: 'debug', msg, data }),
-            info: (msg, data) => this.emit('log', { level: 'info', msg, data }),
-            warn: (msg, data) => this.emit('log', { level: 'warn', msg, data }),
-            error: (msg, data) => this.emit('log', { level: 'error', msg, data }),
-        };
-        const mcpServer = createMCPServer({
-            name: 'KynjalFlow MCP Server V3',
-            version: '3.0.0',
-            transport: this.options.transport,
-            host: this.options.host,
-            port: this.options.port,
-            enableMetrics: true,
-            enableCaching: true,
-        }, logger);
-        await mcpServer.start();
-        // Store reference for stopping
-        this._mcpServer = mcpServer;
-    }
+    MCPServerManager.prototype.startHttpServer = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var createMCPServer, logger, mcpServer;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, import('@claude-flow/mcp')];
+                    case 1:
+                        createMCPServer = (_a.sent()).createMCPServer;
+                        logger = {
+                            debug: function (msg, data) { return _this.emit('log', { level: 'debug', msg: msg, data: data }); },
+                            info: function (msg, data) { return _this.emit('log', { level: 'info', msg: msg, data: data }); },
+                            warn: function (msg, data) { return _this.emit('log', { level: 'warn', msg: msg, data: data }); },
+                            error: function (msg, data) { return _this.emit('log', { level: 'error', msg: msg, data: data }); }
+                        };
+                        mcpServer = createMCPServer({
+                            name: 'Claude-Flow MCP Server V3',
+                            version: '3.0.0',
+                            transport: this.options.transport,
+                            host: this.options.host,
+                            port: this.options.port,
+                            enableMetrics: true,
+                            enableCaching: true
+                        }, logger);
+                        return [4 /*yield*/, mcpServer.start()];
+                    case 2:
+                        _a.sent();
+                        // Store reference for stopping
+                        this._mcpServer = mcpServer;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Wait for server to be ready
      */
-    async waitForReady(timeout = 10000) {
-        // For stdio transport, we're ready immediately (in-process)
-        if (this.options.transport === 'stdio') {
-            return;
-        }
-        const startTime = Date.now();
-        while (Date.now() - startTime < timeout) {
-            const health = await this.checkHealth();
-            if (health.healthy) {
-                return;
-            }
-            await this.sleep(100);
-        }
-        throw new Error('Server failed to start within timeout');
-    }
+    MCPServerManager.prototype.waitForReady = function (timeout) {
+        if (timeout === void 0) { timeout = 10000; }
+        return __awaiter(this, void 0, Promise, function () {
+            var startTime, health;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // For stdio transport, we're ready immediately (in-process)
+                        if (this.options.transport === 'stdio') {
+                            return [2 /*return*/];
+                        }
+                        startTime = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        if (!(Date.now() - startTime < timeout)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.checkHealth()];
+                    case 2:
+                        health = _a.sent();
+                        if (health.healthy) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.sleep(100)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 4: throw new Error('Server failed to start within timeout');
+                }
+            });
+        });
+    };
     /**
      * Wait for process to exit
      */
-    async waitForExit(timeout) {
-        if (!this.process)
-            return;
-        return new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                resolve();
-            }, timeout);
-            this.process.once('exit', () => {
-                clearTimeout(timer);
-                resolve();
+    MCPServerManager.prototype.waitForExit = function (timeout) {
+        return __awaiter(this, void 0, Promise, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!this.process)
+                    return [2 /*return*/];
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var timer = setTimeout(function () {
+                            resolve();
+                        }, timeout);
+                        _this.process.once('exit', function () {
+                            clearTimeout(timer);
+                            resolve();
+                        });
+                    })];
             });
         });
-    }
+    };
     /**
      * Start health monitoring
      */
-    startHealthMonitoring() {
-        this.healthCheckInterval = setInterval(async () => {
-            try {
-                const health = await this.checkHealth();
-                this.emit('health', health);
-                if (!health.healthy) {
-                    this.emit('unhealthy', health);
+    MCPServerManager.prototype.startHealthMonitoring = function () {
+        var _this = this;
+        this.healthCheckInterval = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var health, error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.checkHealth()];
+                    case 1:
+                        health = _a.sent();
+                        this.emit('health', health);
+                        if (!health.healthy) {
+                            this.emit('unhealthy', health);
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_7 = _a.sent();
+                        this.emit('health-error', error_7);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
                 }
-            }
-            catch (error) {
-                this.emit('health-error', error);
-            }
-        }, 30000);
-    }
+            });
+        }); }, 30000);
+        this.healthCheckInterval.unref();
+    };
     /**
      * Write PID file
      */
-    async writePidFile() {
-        const pid = this.process?.pid || process.pid;
-        await fs.promises.writeFile(this.options.pidFile, String(pid), 'utf8');
-    }
+    MCPServerManager.prototype.writePidFile = function () {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var pid;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        pid = ((_a = this.process) === null || _a === void 0 ? void 0 : _a.pid) || process.pid;
+                        return [4 /*yield*/, fs.promises.writeFile(this.options.pidFile, String(pid), 'utf8')];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Read PID file
      */
-    async readPidFile() {
-        try {
-            const content = await fs.promises.readFile(this.options.pidFile, 'utf8');
-            const pid = parseInt(content.trim(), 10);
-            return isNaN(pid) ? null : pid;
-        }
-        catch {
-            return null;
-        }
-    }
+    MCPServerManager.prototype.readPidFile = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var content, pid, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fs.promises.readFile(this.options.pidFile, 'utf8')];
+                    case 1:
+                        content = _b.sent();
+                        pid = parseInt(content.trim(), 10);
+                        return [2 /*return*/, isNaN(pid) ? null : pid];
+                    case 2:
+                        _a = _b.sent();
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Remove PID file
      */
-    async removePidFile() {
-        try {
-            await fs.promises.unlink(this.options.pidFile);
-        }
-        catch {
-            // Ignore errors
-        }
-    }
+    MCPServerManager.prototype.removePidFile = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fs.promises.unlink(this.options.pidFile)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Check if process is running
      */
-    isProcessRunning(pid) {
+    MCPServerManager.prototype.isProcessRunning = function (pid) {
         try {
             process.kill(pid, 0);
             return true;
         }
-        catch {
+        catch (_a) {
             return false;
         }
-    }
+    };
     /**
      * Make HTTP request
      */
-    async httpRequest(url, method, timeout) {
-        return new Promise((resolve, reject) => {
-            const urlObj = new URL(url);
-            const http = require('http');
-            const req = http.request({
-                hostname: urlObj.hostname,
-                port: urlObj.port,
-                path: urlObj.pathname,
-                method,
-                timeout,
-            }, (res) => {
-                let data = '';
-                res.on('data', (chunk) => {
-                    data += chunk;
-                });
-                res.on('end', () => {
-                    try {
-                        resolve(JSON.parse(data));
-                    }
-                    catch {
-                        resolve({ status: res.statusCode === 200 ? 'ok' : 'error' });
-                    }
-                });
-            });
-            req.on('error', reject);
-            req.on('timeout', () => {
-                req.destroy();
-                reject(new Error('Request timeout'));
+    MCPServerManager.prototype.httpRequest = function (url, method, timeout) {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var urlObj = new URL(url);
+                        var http = require('http');
+                        var req = http.request({
+                            hostname: urlObj.hostname,
+                            port: urlObj.port,
+                            path: urlObj.pathname,
+                            method: method,
+                            timeout: timeout
+                        }, function (res) {
+                            var data = '';
+                            res.on('data', function (chunk) {
+                                data += chunk;
+                            });
+                            res.on('end', function () {
+                                try {
+                                    resolve(JSON.parse(data));
+                                }
+                                catch (_a) {
+                                    resolve({ status: res.statusCode === 200 ? 'ok' : 'error' });
+                                }
+                            });
+                        });
+                        req.on('error', reject);
+                        req.on('timeout', function () {
+                            req.destroy();
+                            reject(new Error('Request timeout'));
+                        });
+                        req.end();
+                    })];
             });
-            req.end();
         });
-    }
+    };
     /**
      * Sleep utility
      */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-}
+    MCPServerManager.prototype.sleep = function (ms) {
+        return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+    };
+    return MCPServerManager;
+}(EventEmitter));
+export { MCPServerManager };
 /**
  * Create MCP server manager
  */
@@ -554,8 +838,8 @@ export function createMCPServerManager(options) {
 /**
  * Singleton server manager instance
  */
-let serverManager = null;
-let currentTransport = undefined;
+var serverManager = null;
+var currentTransport = undefined;
 /**
  * Get or create server manager singleton
  *
@@ -563,7 +847,7 @@ let currentTransport = undefined;
  * Previously, once created with stdio (default), HTTP options were ignored
  */
 export function getServerManager(options) {
-    const requestedTransport = options?.transport;
+    var requestedTransport = options === null || options === void 0 ? void 0 : options.transport;
     // Recreate if transport type changes (fixes HTTP transport not working)
     if (serverManager && requestedTransport && requestedTransport !== currentTransport) {
         serverManager = new MCPServerManager(options);
@@ -571,31 +855,60 @@ export function getServerManager(options) {
     }
     if (!serverManager) {
         serverManager = new MCPServerManager(options);
-        currentTransport = options?.transport;
+        currentTransport = options === null || options === void 0 ? void 0 : options.transport;
     }
     return serverManager;
 }
 /**
  * Quick start MCP server
  */
-export async function startMCPServer(options) {
-    const manager = getServerManager(options);
-    return await manager.start();
+export function startMCPServer(options) {
+    return __awaiter(this, void 0, Promise, function () {
+        var manager;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    manager = getServerManager(options);
+                    return [4 /*yield*/, manager.start()];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
 }
 /**
  * Quick stop MCP server
  */
-export async function stopMCPServer(force = false) {
-    if (serverManager) {
-        await serverManager.stop(force);
-    }
+export function stopMCPServer(force) {
+    if (force === void 0) { force = false; }
+    return __awaiter(this, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!serverManager) return [3 /*break*/, 2];
+                    return [4 /*yield*/, serverManager.stop(force)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
+            }
+        });
+    });
 }
 /**
  * Get MCP server status
  */
-export async function getMCPServerStatus() {
-    const manager = getServerManager();
-    return await manager.getStatus();
+export function getMCPServerStatus() {
+    return __awaiter(this, void 0, Promise, function () {
+        var manager;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    manager = getServerManager();
+                    return [4 /*yield*/, manager.getStatus()];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
 }
 export default MCPServerManager;
 //# sourceMappingURL=mcp-server.js.map