@juspay/neurolink 1.10.0 → 1.11.0

package/dist/mcp/logging.js

@@ -1,183 +1,95 @@
 /**
- * NeuroLink MCP Logging System
- * Provides configurable logging with different verbosity levels
+ * MCP Logging Utility
+ * Centralized logging for the MCP ecosystem
  */
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["SILENT"] = 0] = "SILENT";
-    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
-    LogLevel[LogLevel["WARN"] = 2] = "WARN";
-    LogLevel[LogLevel["INFO"] = 3] = "INFO";
-    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
-})(LogLevel || (LogLevel = {}));
-/**
- * Configurable logger for MCP operations
- */
-export class MCPLogger {
-    config;
-    constructor(config = {}) {
-        // Determine log level from environment or default to SILENT
-        const envLogLevel = process.env.NEUROLINK_MCP_LOG_LEVEL?.toUpperCase();
-        let defaultLevel = LogLevel.SILENT;
-        switch (envLogLevel) {
-            case "SILENT":
-                defaultLevel = LogLevel.SILENT;
-                break;
-            case "ERROR":
-                defaultLevel = LogLevel.ERROR;
+class MCPLogger {
+    logLevel = "info";
+    logs = [];
+    maxLogs = 1000;
+    constructor() {
+        // Set log level from environment
+        const envLevel = process.env.MCP_LOG_LEVEL?.toLowerCase();
+        if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+            this.logLevel = envLevel;
+        }
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    shouldLog(level) {
+        const levels = ["debug", "info", "warn", "error"];
+        return levels.indexOf(level) >= levels.indexOf(this.logLevel);
+    }
+    log(level, message, data) {
+        if (!this.shouldLog(level)) {
+            return;
+        }
+        const entry = {
+            level,
+            message,
+            timestamp: new Date(),
+            data,
+        };
+        // Store log entry
+        this.logs.push(entry);
+        // Trim old logs
+        if (this.logs.length > this.maxLogs) {
+            this.logs = this.logs.slice(-this.maxLogs);
+        }
+        // Console output
+        const timestamp = entry.timestamp.toISOString();
+        const prefix = `[${timestamp}] [MCP:${level.toUpperCase()}]`;
+        switch (level) {
+            case "debug":
+                console.debug(prefix, message, data ? data : "");
                 break;
-            case "WARN":
-                defaultLevel = LogLevel.WARN;
+            case "info":
+                console.info(prefix, message, data ? data : "");
                 break;
-            case "INFO":
-                defaultLevel = LogLevel.INFO;
+            case "warn":
+                console.warn(prefix, message, data ? data : "");
                 break;
-            case "DEBUG":
-                defaultLevel = LogLevel.DEBUG;
+            case "error":
+                console.error(prefix, message, data ? data : "");
                 break;
         }
-        this.config = {
-            level: defaultLevel,
-            prefix: "",
-            colors: true,
-            timestamp: false,
-            ...config,
-        };
     }
-    /**
-     * Set log level
-     */
-    setLevel(level) {
-        this.config.level = level;
+    debug(message, data) {
+        this.log("debug", message, data);
     }
-    /**
-     * Get current log level
-     */
-    getLevel() {
-        return this.config.level;
+    info(message, data) {
+        this.log("info", message, data);
     }
-    /**
-     * Log an error message
-     */
-    error(message, ...args) {
-        if (this.config.level >= LogLevel.ERROR) {
-            this.log("ERROR", message, ...args);
-        }
+    warn(message, data) {
+        this.log("warn", message, data);
     }
-    /**
-     * Log a warning message
-     */
-    warn(message, ...args) {
-        if (this.config.level >= LogLevel.WARN) {
-            this.log("WARN", message, ...args);
-        }
+    error(message, data) {
+        this.log("error", message, data);
     }
-    /**
-     * Log an info message
-     */
-    info(message, ...args) {
-        if (this.config.level >= LogLevel.INFO) {
-            this.log("INFO", message, ...args);
+    getLogs(level) {
+        if (level) {
+            return this.logs.filter((log) => log.level === level);
         }
+        return [...this.logs];
     }
-    /**
-     * Log a debug message
-     */
-    debug(message, ...args) {
-        if (this.config.level >= LogLevel.DEBUG) {
-            this.log("DEBUG", message, ...args);
-        }
-    }
-    /**
-     * Internal logging method
-     */
-    log(level, message, ...args) {
-        let output = "";
-        // Add timestamp if enabled
-        if (this.config.timestamp) {
-            output += `[${new Date().toISOString()}] `;
-        }
-        // Add prefix if configured
-        if (this.config.prefix) {
-            output += `[${this.config.prefix}] `;
-        }
-        // Add log level
-        if (this.config.colors) {
-            switch (level) {
-                case "ERROR":
-                    output += `\x1b[31m[${level}]\x1b[0m `;
-                    break;
-                case "WARN":
-                    output += `\x1b[33m[${level}]\x1b[0m `;
-                    break;
-                case "INFO":
-                    output += `\x1b[36m[${level}]\x1b[0m `;
-                    break;
-                case "DEBUG":
-                    output += `\x1b[90m[${level}]\x1b[0m `;
-                    break;
-                default:
-                    output += `[${level}] `;
-            }
-        }
-        else {
-            output += `[${level}] `;
-        }
-        // Add message
-        output += message;
-        // Use appropriate console method
-        switch (level) {
-            case "ERROR":
-                console.error(output, ...args);
-                break;
-            case "WARN":
-                console.warn(output, ...args);
-                break;
-            default:
-                console.log(output, ...args);
-        }
+    clearLogs() {
+        this.logs = [];
     }
 }
-/**
- * Create logger instances for different MCP components
- */
-export const createLogger = (component) => {
-    return new MCPLogger({
-        prefix: component,
-    });
-};
-/**
- * Default loggers for common MCP components
- */
-export const mcpLogger = createLogger("MCP");
-export const autoDiscoveryLogger = createLogger("MCPAutoDiscovery");
-export const registryLogger = createLogger("MCPRegistry");
-export const unifiedRegistryLogger = createLogger("UnifiedMCPRegistry");
-/**
- * Utility function to set global MCP log level
- */
+// Export singleton instance
+export const mcpLogger = new MCPLogger();
+// Additional logger instances for different modules
+export const autoDiscoveryLogger = mcpLogger;
+export const registryLogger = mcpLogger;
+export const unifiedRegistryLogger = mcpLogger;
+// Global log level setter
 export function setGlobalMCPLogLevel(level) {
-    mcpLogger.setLevel(level);
-    autoDiscoveryLogger.setLevel(level);
-    registryLogger.setLevel(level);
-    unifiedRegistryLogger.setLevel(level);
-}
-/**
- * Utility function to parse log level from string
- */
-export function parseLogLevel(level) {
-    switch (level.toUpperCase()) {
-        case "SILENT":
-            return LogLevel.SILENT;
-        case "ERROR":
-            return LogLevel.ERROR;
-        case "WARN":
-            return LogLevel.WARN;
-        case "INFO":
-            return LogLevel.INFO;
-        case "DEBUG":
-            return LogLevel.DEBUG;
-        default:
-            return LogLevel.WARN;
-    }
+    mcpLogger.setLogLevel(level);
 }
+// Export LogLevel enum for runtime use
+export const LogLevels = {
+    debug: "debug",
+    info: "info",
+    warn: "warn",
+    error: "error",
+};

package/dist/mcp/neurolink-mcp-client.js

@@ -218,11 +218,39 @@ Response (JSON array only):`;
             // Create execution context
             const context = {
                 sessionId: this.sessionId,
-                userId: this.config.userId,
-                organizationId: this.config.organizationId,
-                aiProvider: this.config.providerName,
+                userId: this.config.userId || "anonymous",
+                organizationId: this.config.organizationId || "default",
+                aiProvider: this.config.providerName || "unknown",
                 modelId: this.config.modelName,
                 timestamp: Date.now(),
+                // Required properties
+                secureFS: {
+                    readFile: async () => {
+                        throw new Error("secureFS not configured");
+                    },
+                    writeFile: async () => {
+                        throw new Error("secureFS not configured");
+                    },
+                    readdir: async () => {
+                        throw new Error("secureFS not configured");
+                    },
+                    stat: async () => {
+                        throw new Error("secureFS not configured");
+                    },
+                    mkdir: async () => {
+                        throw new Error("secureFS not configured");
+                    },
+                    exists: async () => false,
+                },
+                path: {
+                    join: (...paths) => require("path").join(...paths),
+                    resolve: (...paths) => require("path").resolve(...paths),
+                    relative: (from, to) => require("path").relative(from, to),
+                    dirname: (path) => require("path").dirname(path),
+                    basename: (path, ext) => require("path").basename(path, ext),
+                },
+                grantedPermissions: [],
+                log: console.log,
             };
             // Emit tool start event
             this.executionCount++;

package/dist/mcp/orchestrator.d.ts

@@ -4,7 +4,7 @@
  * Coordinates factory, registry, context, and AI tools for seamless operation
  */
 import type { ToolResult } from "./factory.js";
-import { MCPToolRegistry, type ToolExecutionOptions } from "./registry.js";
+import { MCPToolRegistry, type ToolExecutionOptions } from "./tool-registry.js";
 import { ContextManager, type ContextRequest } from "./context-manager.js";
 /**
  * Pipeline execution options

package/dist/mcp/orchestrator.js

@@ -3,7 +3,7 @@
  * Central orchestrator for coordinated tool execution with pipeline management
  * Coordinates factory, registry, context, and AI tools for seamless operation
  */
-import { MCPToolRegistry, defaultToolRegistry, } from "./registry.js";
+import { MCPToolRegistry, defaultToolRegistry, } from "./tool-registry.js";
 import { ContextManager, defaultContextManager, createExecutionContext, } from "./context-manager.js";
 import { aiCoreServer } from "./servers/ai-providers/ai-core-server.js";
 /**
@@ -25,7 +25,7 @@ export class MCPOrchestrator {
      */
     async initializeDefaultServers() {
         try {
-            await this.registry.registerServer(aiCoreServer);
+            await this.registry.registerServer(aiCoreServer.id, aiCoreServer);
             console.log("[Orchestrator] Initialized with AI Core Server");
         }
         catch (error) {
@@ -46,7 +46,7 @@ export class MCPOrchestrator {
         const context = this.contextManager.createContext(contextRequest);
         console.log(`[Orchestrator] Executing tool '${toolName}' in session ${context.sessionId}`);
         // Execute tool through registry
-        const result = await this.registry.executeTool(toolName, params, context, options);
+        const result = await this.registry.executeTool(toolName, params, context);
         console.log(`[Orchestrator] Tool '${toolName}' execution ${result.success ? "completed" : "failed"}`);
         return result;
     }
@@ -88,16 +88,14 @@ export class MCPOrchestrator {
                     const stepId = step.stepId || `step-${stepsExecuted + 1}`;
                     try {
                         console.log(`[Orchestrator] Executing step: ${stepId} (${step.toolName})`);
-                        const stepResult = await this.registry.executeTool(step.toolName, step.params, context, {
-                            ...step.options,
-                            validateInput: validateInputs,
-                            trackMetrics,
-                            timeoutMs: timeout / steps.length, // Distribute timeout across steps
-                        });
+                        const stepResult = await this.registry.executeTool(step.toolName, step.params, context);
                         results.set(stepId, stepResult);
                         stepsExecuted++;
                         if (!stepResult.success) {
-                            errors.set(stepId, stepResult.error || "Unknown error");
+                            const errorMessage = stepResult.error instanceof Error
+                                ? stepResult.error.message
+                                : stepResult.error || "Unknown error";
+                            errors.set(stepId, errorMessage);
                             if (stopOnError) {
                                 console.error(`[Orchestrator] Pipeline ${pipelineId} stopped due to error in step ${stepId}`);
                                 break;
@@ -300,10 +298,13 @@ export class MCPOrchestrator {
                 executing.add(stepId);
                 const step = stepMap.get(stepId);
                 try {
-                    const result = await this.registry.executeTool(step.toolName, step.params, context, { ...step.options, ...options });
+                    const result = await this.registry.executeTool(step.toolName, step.params, context);
                     results.set(stepId, result);
                     if (!result.success) {
-                        errors.set(stepId, result.error || "Unknown error");
+                        const errorMessage = result.error instanceof Error
+                            ? result.error.message
+                            : result.error || "Unknown error";
+                        errors.set(stepId, errorMessage);
                     }
                 }
                 catch (error) {

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

@@ -0,0 +1,98 @@
+/**
+ * PluginManager - Central Orchestrator for MCP Lifecycle
+ * Implements generic factory pattern with manifest-based discovery
+ * Based on research blueprint for extensible plugin architecture
+ */
+import { MCP } from "./contracts/mcp-contract.js";
+import type { MCPMetadata } from "./contracts/mcp-contract.js";
+/**
+ * Plugin Manager Configuration
+ */
+interface PluginManagerConfig {
+    /** Enable/disable plugin discovery */
+    enableDiscovery?: boolean;
+    /** Custom plugin directories */
+    pluginDirectories?: string[];
+    /** Security level for plugins */
+    securityLevel?: "strict" | "moderate" | "permissive";
+    /** Maximum plugins to load */
+    maxPlugins?: number;
+}
+/**
+ * Central Plugin Manager implementing the research blueprint
+ */
+export declare class PluginManager {
+    private static instance;
+    private mcpConstructors;
+    private mcpInstances;
+    private discoveredMCPs;
+    private securityManager;
+    private initialized;
+    private config;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(config?: PluginManagerConfig): PluginManager;
+    /**
+     * Initialize the plugin manager with discovery
+     */
+    initialize(): Promise<void>;
+    /**
+     * Discover plugins following research blueprint priority:
+     * 1. Core plugins (bundled)
+     * 2. Project plugins (./neurolink-mcp/)
+     * 3. Installed plugins (node_modules)
+     */
+    private discoverPlugins;
+    /**
+     * Discover core plugins bundled with NeuroLink
+     */
+    private discoverCorePlugins;
+    /**
+     * Discover project-local plugins
+     */
+    private discoverProjectPlugins;
+    /**
+     * Discover installed plugins from node_modules
+     */
+    private discoverInstalledPlugins;
+    /**
+     * Discover plugins in a specific directory
+     */
+    private discoverPluginsInDirectory;
+    /**
+     * Validate manifest structure
+     */
+    private validateManifest;
+    /**
+     * Generic Factory Method - Creates type-safe MCP instances
+     * Core implementation of the research blueprint
+     */
+    createInstance<T extends MCP>(name: string, config: unknown): Promise<T>;
+    /**
+     * Get or load constructor for an MCP
+     */
+    private getConstructor;
+    /**
+     * List all discovered MCPs
+     */
+    listDiscovered(): MCPMetadata[];
+    /**
+     * Get metadata for a specific MCP
+     */
+    getMetadata(name: string): MCPMetadata | null;
+    /**
+     * Get discovery statistics
+     */
+    getDiscoveryStats(): Record<string, number>;
+    /**
+     * Dispose of all instances and cleanup
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Export singleton instance getter
+ */
+export declare const pluginManager: PluginManager;
+export {};