@juspay/neurolink 1.10.0 → 1.11.1

package/dist/lib/mcp/ecosystem.js

@@ -0,0 +1,161 @@
+/**
+ * MCP Ecosystem Integration - Bridge Between Research Blueprint and NeuroLink
+ * Provides unified interface for plugin management and execution
+ */
+import { pluginManager } from "./plugin-manager.js";
+import { SecurityManager } from "./security-manager.js";
+import { mcpLogger } from "./logging.js";
+import { tool } from "ai";
+import { z } from "zod";
+/**
+ * MCP Ecosystem - Main Interface for Plugin Operations
+ */
+export class MCPEcosystem {
+    static instance;
+    securityManager;
+    initialized = false;
+    constructor() {
+        this.securityManager = new SecurityManager("moderate");
+    }
+    static getInstance() {
+        if (!MCPEcosystem.instance) {
+            MCPEcosystem.instance = new MCPEcosystem();
+        }
+        return MCPEcosystem.instance;
+    }
+    /**
+     * Initialize the MCP ecosystem
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        mcpLogger.info("[MCPEcosystem] Initializing MCP ecosystem...");
+        await pluginManager.initialize();
+        this.initialized = true;
+        const stats = pluginManager.getDiscoveryStats();
+        mcpLogger.info("[MCPEcosystem] MCP ecosystem initialized", stats);
+    }
+    /**
+     * List all available MCPs
+     */
+    async list() {
+        await this.ensureInitialized();
+        return pluginManager.listDiscovered();
+    }
+    /**
+     * Get metadata for a specific MCP
+     */
+    async getMetadata(name) {
+        await this.ensureInitialized();
+        return pluginManager.getMetadata(name);
+    }
+    /**
+     * Create and execute an MCP instance
+     */
+    async execute(name, config, args, context) {
+        await this.ensureInitialized();
+        const functionTag = "MCPEcosystem.execute";
+        try {
+            // Get MCP metadata for permissions
+            const metadata = await this.getMetadata(name);
+            if (!metadata) {
+                throw new Error(`MCP ${name} not found`);
+            }
+            // Create execution context
+            const executionContext = this.securityManager.createExecutionContext(context?.sessionId || `mcp-${Date.now()}`, context?.userId || "mcp-user", metadata.permissions, config?.basePath);
+            // Create MCP instance
+            const mcpInstance = await pluginManager.createInstance(name, config);
+            // Execute the MCP
+            mcpLogger.debug(`[${functionTag}] Executing ${name}`, { args });
+            const result = await mcpInstance.execute(executionContext, args);
+            mcpLogger.debug(`[${functionTag}] ${name} execution completed`, {
+                success: true,
+                resultType: typeof result,
+            });
+            return result;
+        }
+        catch (error) {
+            mcpLogger.error(`[${functionTag}] ${name} execution failed:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Execute filesystem operations using FileSystemMCP
+     */
+    async filesystem(operation) {
+        return this.execute("@neurolink-mcp/filesystem", { basePath: operation.basePath || process.cwd() }, {
+            operation: operation.action,
+            path: operation.path,
+            content: operation.content,
+        });
+    }
+    /**
+     * Get ecosystem statistics
+     */
+    async getStats() {
+        const available = await this.list();
+        return {
+            initialized: this.initialized,
+            pluginsDiscovered: available.length,
+            pluginsBySource: pluginManager.getDiscoveryStats(),
+            availablePlugins: available.map((p) => p.name),
+        };
+    }
+    /**
+     * Create an MCP instance for direct use
+     */
+    async createInstance(name, config) {
+        await this.ensureInitialized();
+        const metadata = await this.getMetadata(name);
+        if (!metadata) {
+            throw new Error(`MCP ${name} not found`);
+        }
+        return pluginManager.createInstance(name, config);
+    }
+    /**
+     * Create execution context for manual MCP usage
+     */
+    createExecutionContext(sessionId, userId, permissions, basePath) {
+        return this.securityManager.createExecutionContext(sessionId, userId, permissions, basePath);
+    }
+    /**
+     * Ensure ecosystem is initialized
+     */
+    async ensureInitialized() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+    }
+    /**
+     * Get all tools formatted for AI providers
+     */
+    async getToolsForAI() {
+        await this.ensureInitialized();
+        const plugins = await this.list();
+        const tools = {};
+        for (const plugin of plugins) {
+            // This is a simplified representation. A real implementation
+            // would parse the plugin's metadata to get tool definitions.
+            if (plugin.name.includes("filesystem")) {
+                tools["filesystem_list"] = tool({
+                    description: "List files in a directory",
+                    parameters: z.object({
+                        path: z.string().describe("The path to list files from"),
+                    }),
+                    execute: async ({ path }) => this.filesystem({ action: "listFiles", path }),
+                });
+            }
+        }
+        return tools;
+    }
+    /**
+     * Dispose of all resources
+     */
+    async dispose() {
+        await pluginManager.dispose();
+        this.initialized = false;
+    }
+}
+// Export singleton instance
+export const mcpEcosystem = MCPEcosystem.getInstance();

package/dist/lib/mcp/external-client.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 { EventEmitter } from "events";
+import type { NeuroLinkMCPTool, NeuroLinkExecutionContext, ToolResult } from "./factory.js";
+/**
+ * External MCP Server Configuration
+ */
+export interface ExternalMCPServerConfig {
+    name: string;
+    command: string;
+    args: string[];
+    transport: "stdio";
+    env?: Record<string, string>;
+    timeout?: number;
+    retryAttempts?: number;
+}
+/**
+ * External MCP Client for stdio transport
+ */
+export declare class ExternalMCPClient extends EventEmitter {
+    private config;
+    private process;
+    private isConnected;
+    private messageId;
+    private pendingRequests;
+    private tools;
+    private buffer;
+    constructor(config: ExternalMCPServerConfig);
+    /**
+     * Connect to the external MCP server
+     */
+    connect(): Promise<void>;
+    /**
+     * Initialize MCP session
+     */
+    private initialize;
+    /**
+     * Discover available tools from the server
+     */
+    private discoverTools;
+    /**
+     * Execute a tool on the external server
+     */
+    executeTool(toolName: string, params: any, context: NeuroLinkExecutionContext): Promise<ToolResult>;
+    /**
+     * Get available tools as NeuroLink MCP tools
+     */
+    getNeuroLinkTools(): Record<string, NeuroLinkMCPTool>;
+    /**
+     * Send a request to the MCP server
+     */
+    private sendRequest;
+    /**
+     * Handle incoming messages from the server
+     */
+    private handleMessage;
+    /**
+     * Process a parsed MCP message
+     */
+    private processMessage;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if connected
+     */
+    isConnectedToServer(): boolean;
+    /**
+     * Get server information
+     */
+    getServerInfo(): {
+        name: string;
+        command: string;
+        args: string[];
+        transport: "stdio";
+        isConnected: boolean;
+        toolCount: number;
+        tools: string[];
+    };
+}
+/**
+ * Create an external MCP client
+ */
+export declare function createExternalMCPClient(config: ExternalMCPServerConfig): ExternalMCPClient;

package/dist/lib/mcp/external-client.js

@@ -0,0 +1,323 @@
+/**
+ * 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 } 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 },
+            });
+            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", {});
+            if (response.tools && Array.isArray(response.tools)) {
+                this.tools.clear();
+                for (const tool of response.tools) {
+                    this.tools.set(tool.name, {
+                        name: tool.name,
+                        description: tool.description,
+                        inputSchema: tool.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 result = {
+                success: !response.isError,
+                data: response.content || response.result || response,
+                metadata: {
+                    toolName,
+                    serverId: this.config.name,
+                    serverTitle: this.config.name,
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
+            if (response.isError) {
+                result.error = response.content?.[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();
+        // Close process
+        if (this.process) {
+            this.process.kill("SIGTERM");
+            // Force kill after timeout
+            setTimeout(() => {
+                if (this.process && !this.process.killed) {
+                    this.process.kill("SIGKILL");
+                }
+            }, 5000);
+            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/lib/mcp/external-manager.d.ts

@@ -0,0 +1,112 @@
+/**
+ * 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;
+    server: NeuroLinkMCPServer;
+    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: any, 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 {};