kynjal-cli 4.0.0 → 4.0.2

package/dist/src/mcp-server.js

@@ -16,68 +16,6 @@
  * @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';
@@ -86,12 +24,12 @@ import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 // ESM-compatible __dirname
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 /**
  * Default configuration
  */
-var DEFAULT_OPTIONS = {
+const DEFAULT_OPTIONS = {
     transport: 'stdio',
     host: 'localhost',
     port: 3000,
@@ -99,736 +37,540 @@ var 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
  */
-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;
+export class MCPServerManager extends EventEmitter {
+    options;
+    process;
+    server;
+    startTime;
+    healthCheckInterval;
+    constructor(options = {}) {
+        super();
+        this.options = { ...DEFAULT_OPTIONS, ...options };
     }
     /**
      * Start the MCP server
      */
-    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*/];
-                }
+    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,
             });
-        });
-    };
+            return finalStatus;
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
     /**
      * Stop the MCP server
      */
-    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*/];
+    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');
+                }
+                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
      */
-    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];
-                }
-            });
-        });
-    };
+    async getStatus() {
+        // Check PID file
+        const pid = await this.readPidFile();
+        if (!pid) {
+            // No PID file found. Detect if we are running in stdio mode
+            // (e.g., launched by Claude Code via `claude mcp add`).
+            const isStdio = !process.stdin.isTTY;
+            const envTransport = process.env.CLAUDE_FLOW_MCP_TRANSPORT;
+            if (isStdio || envTransport === 'stdio' || this.options.transport === 'stdio') {
+                return {
+                    running: true,
+                    pid: process.pid,
+                    transport: 'stdio',
+                    startedAt: this.startTime?.toISOString(),
+                    uptime: this.startTime
+                        ? Math.floor((Date.now() - this.startTime.getTime()) / 1000)
+                        : undefined,
+                };
+            }
+            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;
+    }
     /**
      * Check server health
      */
-    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*/];
-                }
-            });
-        });
-    };
+    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',
+            };
+        }
+    }
     /**
      * Restart the server
      */
-    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()];
-                }
-            });
-        });
-    };
+    async restart() {
+        await this.stop();
+        return await this.start();
+    }
     /**
      * Start stdio server in-process
      * Handles stdin/stdout directly like V2 implementation
      */
-    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*/];
+    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: 'ruflo',
+                    version: VERSION,
+                    capabilities: {
+                        tools: { listChanged: true },
+                        resources: { subscribe: true, listChanged: true },
+                    },
+                },
+            },
+        }));
+        // Handle stdin messages (S-5: bounded buffer to prevent OOM)
+        const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB
+        let buffer = '';
+        process.stdin.on('data', async (chunk) => {
+            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;
+            }
+            // 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));
+                    }
                 }
-            });
+            }
+        });
+        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
      */
-    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*/, {
+    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: 'ruflo', 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 {
                             jsonrpc: '2.0',
                             id: message.id,
-                            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*/, {
+                            error: { code: -32601, message: `Tool not found: ${toolName}` },
+                        };
+                    }
+                    try {
+                        const result = await callMCPTool(toolName, toolParams, { sessionId });
+                        return {
                             jsonrpc: '2.0',
                             id: message.id,
-                            result: {}
-                        }];
-                    case 11: return [2 /*return*/, {
+                            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
+                        };
+                    }
+                    catch (error) {
+                        return {
                             jsonrpc: '2.0',
                             id: message.id,
-                            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*/];
-                }
-            });
-        });
-    };
+                            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',
+                },
+            };
+        }
+    }
     /**
      * Start HTTP server in-process
      */
-    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*/];
-                }
-            });
-        });
-    };
+    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: '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);
+        await mcpServer.start();
+        // Store reference for stopping
+        this._mcpServer = mcpServer;
+    }
     /**
      * Wait for server to be ready
      */
-    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');
-                }
-            });
-        });
-    };
+    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');
+    }
     /**
      * Wait for process to exit
      */
-    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();
-                        });
-                    })];
+    async waitForExit(timeout) {
+        if (!this.process)
+            return;
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                resolve();
+            }, timeout);
+            this.process.once('exit', () => {
+                clearTimeout(timer);
+                resolve();
             });
         });
-    };
+    }
     /**
      * Start health monitoring
      */
-    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*/];
+    startHealthMonitoring() {
+        this.healthCheckInterval = setInterval(async () => {
+            try {
+                const health = await this.checkHealth();
+                this.emit('health', health);
+                if (!health.healthy) {
+                    this.emit('unhealthy', health);
                 }
-            });
-        }); }, 30000);
+            }
+            catch (error) {
+                this.emit('health-error', error);
+            }
+        }, 30000);
         this.healthCheckInterval.unref();
-    };
+    }
     /**
      * Write PID file
      */
-    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*/];
-                }
-            });
-        });
-    };
+    async writePidFile() {
+        const pid = this.process?.pid || process.pid;
+        await fs.promises.writeFile(this.options.pidFile, String(pid), 'utf8');
+    }
     /**
      * Read PID file
      */
-    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*/];
-                }
-            });
-        });
-    };
+    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;
+        }
+    }
     /**
      * Remove PID file
      */
-    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*/];
-                }
-            });
-        });
-    };
+    async removePidFile() {
+        try {
+            await fs.promises.unlink(this.options.pidFile);
+        }
+        catch {
+            // Ignore errors
+        }
+    }
     /**
      * Check if process is running
      */
-    MCPServerManager.prototype.isProcessRunning = function (pid) {
+    isProcessRunning(pid) {
         try {
             process.kill(pid, 0);
             return true;
         }
-        catch (_a) {
+        catch {
             return false;
         }
-    };
+    }
     /**
      * Make HTTP request
      */
-    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();
-                    })];
+    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'));
             });
+            req.end();
         });
-    };
+    }
     /**
      * Sleep utility
      */
-    MCPServerManager.prototype.sleep = function (ms) {
-        return new Promise(function (resolve) { return setTimeout(resolve, ms); });
-    };
-    return MCPServerManager;
-}(EventEmitter));
-export { MCPServerManager };
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
 /**
  * Create MCP server manager
  */
@@ -838,8 +580,8 @@ export function createMCPServerManager(options) {
 /**
  * Singleton server manager instance
  */
-var serverManager = null;
-var currentTransport = undefined;
+let serverManager = null;
+let currentTransport = undefined;
 /**
  * Get or create server manager singleton
  *
@@ -847,7 +589,7 @@ var currentTransport = undefined;
  * Previously, once created with stdio (default), HTTP options were ignored
  */
 export function getServerManager(options) {
-    var requestedTransport = options === null || options === void 0 ? void 0 : options.transport;
+    const requestedTransport = options?.transport;
     // Recreate if transport type changes (fixes HTTP transport not working)
     if (serverManager && requestedTransport && requestedTransport !== currentTransport) {
         serverManager = new MCPServerManager(options);
@@ -855,60 +597,31 @@ export function getServerManager(options) {
     }
     if (!serverManager) {
         serverManager = new MCPServerManager(options);
-        currentTransport = options === null || options === void 0 ? void 0 : options.transport;
+        currentTransport = options?.transport;
     }
     return serverManager;
 }
 /**
  * Quick start MCP server
  */
-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()];
-            }
-        });
-    });
+export async function startMCPServer(options) {
+    const manager = getServerManager(options);
+    return await manager.start();
 }
 /**
  * Quick stop MCP server
  */
-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*/];
-            }
-        });
-    });
+export async function stopMCPServer(force = false) {
+    if (serverManager) {
+        await serverManager.stop(force);
+    }
 }
 /**
  * Get MCP server status
  */
-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 async function getMCPServerStatus() {
+    const manager = getServerManager();
+    return await manager.getStatus();
 }
 export default MCPServerManager;
 //# sourceMappingURL=mcp-server.js.map