@juspay/neurolink 6.1.0 → 6.2.1

package/dist/mcp/external-client.js

@@ -1,331 +0,0 @@
-/**
- * NeuroLink External MCP Client
- * Connects to external MCP servers via stdio transport following MCP specification
- * Bridges external tools into NeuroLink's factory pattern ecosystem
- */
-import { spawn, ChildProcess } from "child_process";
-import { EventEmitter } from "events";
-import { mcpLogger as logger } from "./logging.js";
-/**
- * External MCP Client for stdio transport
- */
-export class ExternalMCPClient extends EventEmitter {
-    config;
-    process = null;
-    isConnected = false;
-    messageId = 0;
-    pendingRequests = new Map();
-    tools = new Map();
-    buffer = "";
-    constructor(config) {
-        super();
-        this.config = {
-            timeout: 30000,
-            retryAttempts: 3,
-            ...config,
-        };
-    }
-    /**
-     * Connect to the external MCP server
-     */
-    async connect() {
-        if (this.isConnected) {
-            logger.debug(`[External MCP] Already connected to ${this.config.name}`);
-            return;
-        }
-        try {
-            logger.info(`[External MCP] Connecting to ${this.config.name}...`);
-            // Spawn the MCP server process
-            this.process = spawn(this.config.command, this.config.args, {
-                stdio: ["pipe", "pipe", "pipe"],
-                env: { ...process.env, ...this.config.env },
-            });
-            // 🔧 FIX: Register for cleanup
-            process.once("beforeExit", () => this.disconnect());
-            process.once("SIGINT", () => this.disconnect());
-            process.once("SIGTERM", () => this.disconnect());
-            if (!this.process.stdout || !this.process.stdin || !this.process.stderr) {
-                throw new Error("Failed to create stdio pipes");
-            }
-            // Setup stdout handler for receiving messages
-            this.process.stdout.on("data", (data) => {
-                this.handleMessage(data.toString());
-            });
-            // Setup stderr handler for debugging
-            this.process.stderr.on("data", (data) => {
-                logger.debug(`[External MCP] ${this.config.name} stderr:`, data.toString().trim());
-            });
-            // Handle process exit
-            this.process.on("exit", (code, signal) => {
-                logger.warn(`[External MCP] ${this.config.name} process exited`, {
-                    code,
-                    signal,
-                });
-                this.isConnected = false;
-                this.emit("disconnected", { code, signal });
-            });
-            // Handle process errors
-            this.process.on("error", (error) => {
-                logger.error(`[External MCP] ${this.config.name} process error:`, error);
-                this.emit("error", error);
-            });
-            // Initialize MCP session
-            await this.initialize();
-            // Discover available tools
-            await this.discoverTools();
-            this.isConnected = true;
-            logger.info(`[External MCP] Connected to ${this.config.name} with ${this.tools.size} tools`);
-            this.emit("connected");
-        }
-        catch (error) {
-            logger.error(`[External MCP] Failed to connect to ${this.config.name}:`, error);
-            await this.disconnect();
-            throw error;
-        }
-    }
-    /**
-     * Initialize MCP session
-     */
-    async initialize() {
-        const initResponse = await this.sendRequest("initialize", {
-            protocolVersion: "2024-11-05",
-            capabilities: {
-                tools: {},
-            },
-            clientInfo: {
-                name: "neurolink-mcp-client",
-                version: "1.0.0",
-            },
-        });
-        logger.debug(`[External MCP] ${this.config.name} initialized:`, initResponse);
-    }
-    /**
-     * Discover available tools from the server
-     */
-    async discoverTools() {
-        try {
-            const response = await this.sendRequest("tools/list", {});
-            const responseObj = response;
-            if (responseObj.tools && Array.isArray(responseObj.tools)) {
-                this.tools.clear();
-                for (const tool of responseObj.tools) {
-                    const toolObj = tool;
-                    this.tools.set(toolObj.name || "unknown", {
-                        name: toolObj.name || "unknown",
-                        description: toolObj.description || "",
-                        inputSchema: toolObj.inputSchema,
-                    });
-                }
-                logger.debug(`[External MCP] Discovered ${this.tools.size} tools from ${this.config.name}`);
-            }
-        }
-        catch (error) {
-            logger.warn(`[External MCP] Failed to discover tools from ${this.config.name}:`, error);
-        }
-    }
-    /**
-     * Execute a tool on the external server
-     */
-    async executeTool(toolName, params, context) {
-        if (!this.isConnected) {
-            throw new Error(`Not connected to MCP server: ${this.config.name}`);
-        }
-        const startTime = Date.now();
-        try {
-            logger.debug(`[External MCP] Executing tool ${toolName} on ${this.config.name}`);
-            const response = await this.sendRequest("tools/call", {
-                name: toolName,
-                arguments: params,
-            });
-            const executionTime = Date.now() - startTime;
-            // Transform MCP response to NeuroLink format
-            const responseObj = response;
-            const result = {
-                success: !responseObj.isError,
-                data: responseObj.text || responseObj.result || response,
-                metadata: {
-                    toolName,
-                    serverId: this.config.name,
-                    serverTitle: this.config.name,
-                    sessionId: context.sessionId,
-                    timestamp: Date.now(),
-                    executionTime,
-                },
-            };
-            if (responseObj.isError) {
-                const textArray = responseObj.text;
-                result.error = textArray?.[0]?.text || "Tool execution failed";
-            }
-            logger.debug(`[External MCP] Tool ${toolName} executed in ${executionTime}ms`);
-            return result;
-        }
-        catch (error) {
-            const executionTime = Date.now() - startTime;
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error(`[External MCP] Tool execution failed: ${toolName}`, error);
-            return {
-                success: false,
-                error: errorMessage,
-                metadata: {
-                    toolName,
-                    serverId: this.config.name,
-                    serverTitle: this.config.name,
-                    sessionId: context.sessionId,
-                    timestamp: Date.now(),
-                    executionTime,
-                },
-            };
-        }
-    }
-    /**
-     * Get available tools as NeuroLink MCP tools
-     */
-    getNeuroLinkTools() {
-        const neurolinkTools = {};
-        for (const [name, toolInfo] of this.tools) {
-            neurolinkTools[name] = {
-                name,
-                description: toolInfo.description || `External tool from ${this.config.name}`,
-                category: "external",
-                isImplemented: true,
-                execute: async (params, context) => {
-                    return this.executeTool(name, params, context);
-                },
-                inputSchema: toolInfo.inputSchema,
-                metadata: {
-                    serverId: this.config.name,
-                    serverTitle: this.config.name,
-                    external: true,
-                    transport: "stdio",
-                },
-            };
-        }
-        return neurolinkTools;
-    }
-    /**
-     * Send a request to the MCP server
-     */
-    async sendRequest(method, params) {
-        return new Promise((resolve, reject) => {
-            if (!this.process?.stdin) {
-                reject(new Error("Process not available"));
-                return;
-            }
-            const id = ++this.messageId;
-            const message = {
-                jsonrpc: "2.0",
-                id,
-                method,
-                params,
-            };
-            // Setup timeout
-            const timeout = setTimeout(() => {
-                this.pendingRequests.delete(id);
-                reject(new Error(`Request timeout: ${method}`));
-            }, this.config.timeout);
-            // Store request for response handling
-            this.pendingRequests.set(id, { resolve, reject, timeout });
-            // Send message
-            const messageStr = JSON.stringify(message) + "\n";
-            this.process.stdin.write(messageStr);
-            logger.debug(`[External MCP] Sent request ${id}: ${method}`);
-        });
-    }
-    /**
-     * Handle incoming messages from the server
-     */
-    handleMessage(data) {
-        this.buffer += data;
-        let lineEnd;
-        while ((lineEnd = this.buffer.indexOf("\n")) !== -1) {
-            const line = this.buffer.slice(0, lineEnd);
-            this.buffer = this.buffer.slice(lineEnd + 1);
-            if (line.trim()) {
-                try {
-                    const message = JSON.parse(line);
-                    this.processMessage(message);
-                }
-                catch (error) {
-                    logger.warn(`[External MCP] Failed to parse message from ${this.config.name}:`, line);
-                }
-            }
-        }
-    }
-    /**
-     * Process a parsed MCP message
-     */
-    processMessage(message) {
-        if (message.id !== undefined && this.pendingRequests.has(message.id)) {
-            // Response to our request
-            const pending = this.pendingRequests.get(message.id);
-            this.pendingRequests.delete(message.id);
-            clearTimeout(pending.timeout);
-            if (message.error) {
-                pending.reject(new Error(message.error.message));
-            }
-            else {
-                pending.resolve(message.result);
-            }
-        }
-        else if (message.method) {
-            // Notification or request from server
-            logger.debug(`[External MCP] Received notification: ${message.method}`);
-            this.emit("notification", message);
-        }
-    }
-    /**
-     * Disconnect from the server
-     */
-    async disconnect() {
-        if (!this.isConnected && !this.process) {
-            return;
-        }
-        logger.info(`[External MCP] Disconnecting from ${this.config.name}`);
-        // Clear pending requests
-        for (const pending of this.pendingRequests.values()) {
-            clearTimeout(pending.timeout);
-            pending.reject(new Error("Connection closed"));
-        }
-        this.pendingRequests.clear();
-        // 🔧 FIX: Enhanced process cleanup
-        if (this.process) {
-            this.process.kill("SIGTERM");
-            // Force kill after timeout
-            setTimeout(() => {
-                if (this.process && !this.process.killed) {
-                    this.process.kill("SIGKILL");
-                }
-            }, 1000); // Reduced from 5000ms to 1000ms
-            this.process = null;
-        }
-        this.isConnected = false;
-        this.tools.clear();
-        this.emit("disconnected");
-    }
-    /**
-     * Check if connected
-     */
-    isConnectedToServer() {
-        return this.isConnected && this.process !== null;
-    }
-    /**
-     * Get server information
-     */
-    getServerInfo() {
-        return {
-            name: this.config.name,
-            command: this.config.command,
-            args: this.config.args,
-            transport: this.config.transport,
-            isConnected: this.isConnected,
-            toolCount: this.tools.size,
-            tools: Array.from(this.tools.keys()),
-        };
-    }
-}
-/**
- * Create an external MCP client
- */
-export function createExternalMCPClient(config) {
-    return new ExternalMCPClient(config);
-}

package/dist/mcp/external-manager.d.ts

@@ -1,112 +0,0 @@
-/**
- * NeuroLink External MCP Manager
- * Manages external MCP servers and bridges them into the NeuroLink factory ecosystem
- * Reads .mcp-config.json and spawns external clients
- */
-import { ExternalMCPClient } from "./external-client.js";
-import type { NeuroLinkMCPServer, NeuroLinkExecutionContext, ToolResult } from "./factory.js";
-import { MCPToolRegistry } from "./tool-registry.js";
-/**
- * External server connection info
- */
-interface ExternalServerInfo {
-    name: string;
-    client: ExternalMCPClient | null;
-    server: NeuroLinkMCPServer | null;
-    status: "connecting" | "connected" | "disconnected" | "error";
-    lastError?: string;
-    toolCount: number;
-    retryCount: number;
-}
-/**
- * External MCP Manager
- * Bridges external MCP servers into NeuroLink's factory pattern ecosystem
- */
-export declare class ExternalMCPManager {
-    private servers;
-    private registry;
-    private configPath;
-    private config;
-    private isInitialized;
-    constructor(configPath?: string, registry?: MCPToolRegistry);
-    /**
-     * Initialize the external MCP manager
-     * Reads config and connects to all external servers
-     */
-    initialize(): Promise<void>;
-    /**
-     * Load MCP configuration from file
-     */
-    private loadConfig;
-    /**
-     * Connect to a specific external server
-     */
-    connectToServer(serverName: string): Promise<ExternalServerInfo | null>;
-    /**
-     * Register tools from an external server with the NeuroLink registry
-     */
-    private registerServerTools;
-    /**
-     * Get all connected external servers
-     */
-    getConnectedServers(): ExternalServerInfo[];
-    /**
-     * Get server status
-     */
-    getServerStatus(serverName: string): ExternalServerInfo | undefined;
-    /**
-     * Get all server statuses
-     */
-    getAllServerStatuses(): Record<string, ExternalServerInfo>;
-    /**
-     * Execute a tool on any connected server
-     */
-    executeTool(toolName: string, params: unknown, context: NeuroLinkExecutionContext): Promise<ToolResult>;
-    /**
-     * List all available tools from external servers
-     */
-    listExternalTools(): Promise<import("./tool-registry.js").ToolInfo[]>;
-    /**
-     * Get registry instance
-     */
-    getRegistry(): MCPToolRegistry;
-    /**
-     * Disconnect from a specific server
-     */
-    disconnectServer(serverName: string): Promise<boolean>;
-    /**
-     * Disconnect from all servers
-     */
-    disconnectAll(): Promise<void>;
-    /**
-     * Refresh connections - reload config and reconnect
-     */
-    refresh(): Promise<void>;
-    /**
-     * Get comprehensive status
-     */
-    getStatus(): {
-        isInitialized: boolean;
-        configPath: string;
-        totalServers: number;
-        connected: number;
-        connecting: number;
-        disconnected: number;
-        errors: number;
-        totalTools: number;
-        servers: Record<string, ExternalServerInfo>;
-    };
-}
-/**
- * Default external MCP manager instance
- */
-export declare const defaultExternalMCPManager: ExternalMCPManager;
-/**
- * Initialize external MCP servers with default manager
- */
-export declare function initializeExternalMCP(configPath?: string): Promise<void>;
-/**
- * Get the default external MCP manager
- */
-export declare function getExternalMCPManager(): ExternalMCPManager;
-export {};