@juspay/neurolink 6.1.0 → 6.2.1

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

@@ -1,98 +0,0 @@
-/**
- * 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 {};

package/dist/lib/mcp/plugin-manager.js

@@ -1,296 +0,0 @@
-/**
- * PluginManager - Central Orchestrator for MCP Lifecycle
- * Implements generic factory pattern with manifest-based discovery
- * Based on research blueprint for extensible plugin architecture
- */
-import * as fs from "fs/promises";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { dirname } from "path";
-// ES Module compatibility
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-import { SecurityManager } from "./security-manager.js";
-import { mcpLogger } from "./logging.js";
-/**
- * Central Plugin Manager implementing the research blueprint
- */
-export class PluginManager {
-    static instance;
-    mcpConstructors = new Map();
-    mcpInstances = new Map();
-    discoveredMCPs = new Map();
-    securityManager;
-    initialized = false;
-    config;
-    constructor(config = {}) {
-        this.config = {
-            enableDiscovery: true,
-            pluginDirectories: [],
-            securityLevel: "moderate",
-            maxPlugins: 50,
-            ...config,
-        };
-        this.securityManager = new SecurityManager(this.config.securityLevel);
-    }
-    /**
-     * Get the singleton instance
-     */
-    static getInstance(config) {
-        if (!PluginManager.instance) {
-            PluginManager.instance = new PluginManager(config);
-        }
-        return PluginManager.instance;
-    }
-    /**
-     * Initialize the plugin manager with discovery
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        mcpLogger.info("[PluginManager] Initializing plugin discovery...");
-        if (this.config.enableDiscovery) {
-            await this.discoverPlugins();
-        }
-        this.initialized = true;
-        mcpLogger.info(`[PluginManager] Initialized with ${this.discoveredMCPs.size} discovered plugins`);
-    }
-    /**
-     * Discover plugins following research blueprint priority:
-     * 1. Core plugins (bundled)
-     * 2. Project plugins (./neurolink-mcp/)
-     * 3. Installed plugins (node_modules)
-     */
-    async discoverPlugins() {
-        const functionTag = "PluginManager.discoverPlugins";
-        try {
-            // 1. Discover core plugins
-            await this.discoverCorePlugins();
-            // 2. Discover project plugins
-            await this.discoverProjectPlugins();
-            // 3. Discover installed plugins
-            await this.discoverInstalledPlugins();
-            mcpLogger.debug(`[${functionTag}] Discovery completed`, {
-                total: this.discoveredMCPs.size,
-                bySource: this.getDiscoveryStats(),
-            });
-        }
-        catch (error) {
-            mcpLogger.error(`[${functionTag}] Discovery failed:`, error);
-        }
-    }
-    /**
-     * Discover core plugins bundled with NeuroLink
-     */
-    async discoverCorePlugins() {
-        // Correctly resolve path from 'dist' to 'src'
-        const corePluginsPath = path.resolve(__dirname, "../../src/lib/mcp/plugins/core");
-        await this.discoverPluginsInDirectory(corePluginsPath, "core");
-    }
-    /**
-     * Discover project-local plugins
-     */
-    async discoverProjectPlugins() {
-        const projectPluginsPath = path.join(process.cwd(), "neurolink-mcp");
-        await this.discoverPluginsInDirectory(projectPluginsPath, "project");
-    }
-    /**
-     * Discover installed plugins from node_modules
-     */
-    async discoverInstalledPlugins() {
-        const nodeModulesPath = path.join(process.cwd(), "node_modules");
-        try {
-            const packages = await fs.readdir(nodeModulesPath);
-            for (const pkg of packages) {
-                if (pkg.startsWith(".")) {
-                    continue;
-                }
-                const packagePath = path.join(nodeModulesPath, pkg);
-                const packageJsonPath = path.join(packagePath, "package.json");
-                try {
-                    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
-                    // Check for neurolink-mcp keyword
-                    if (packageJson.keywords?.includes("neurolink-mcp")) {
-                        await this.discoverPluginsInDirectory(packagePath, "installed");
-                    }
-                }
-                catch {
-                    // Skip invalid packages
-                }
-            }
-        }
-        catch {
-            // node_modules doesn't exist or not accessible
-        }
-    }
-    /**
-     * Discover plugins in a specific directory
-     */
-    async discoverPluginsInDirectory(dirPath, source) {
-        try {
-            const manifestPath = path.join(dirPath, "neurolink-mcp.json");
-            const manifestExists = await fs
-                .access(manifestPath)
-                .then(() => true)
-                .catch(() => false);
-            if (!manifestExists) {
-                return;
-            }
-            const manifest = JSON.parse(await fs.readFile(manifestPath, "utf-8"));
-            // Validate manifest
-            if (!this.validateManifest(manifest)) {
-                mcpLogger.warn(`[PluginManager] Invalid manifest in ${dirPath}`);
-                return;
-            }
-            // Now we know manifest is MCPMetadata due to type guard
-            const validatedManifest = manifest;
-            const entryPath = path
-                .resolve(dirPath, validatedManifest.main)
-                .replace(`${process.cwd()}/src/lib`, `${process.cwd()}/dist`);
-            this.discoveredMCPs.set(validatedManifest.name, {
-                metadata: validatedManifest,
-                entryPath,
-                source,
-                constructor: undefined, // Will be loaded on demand
-            });
-            mcpLogger.debug(`[PluginManager] Discovered ${validatedManifest.name} from ${source}`);
-        }
-        catch (error) {
-            mcpLogger.debug(`[PluginManager] Failed to discover plugin in ${dirPath}:`, error);
-        }
-    }
-    /**
-     * Validate manifest structure
-     */
-    validateManifest(manifest) {
-        if (!manifest || typeof manifest !== "object") {
-            return false;
-        }
-        const obj = manifest;
-        return Boolean(typeof obj.name === "string" &&
-            typeof obj.version === "string" &&
-            typeof obj.main === "string" &&
-            typeof obj.engine === "object" &&
-            obj.engine &&
-            "neurolink" in obj.engine &&
-            typeof obj.description === "string" &&
-            Array.isArray(obj.permissions));
-    }
-    /**
-     * Generic Factory Method - Creates type-safe MCP instances
-     * Core implementation of the research blueprint
-     */
-    async createInstance(name, config) {
-        const functionTag = "PluginManager.createInstance";
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        // Check if already instantiated
-        const existingInstance = this.mcpInstances.get(name);
-        if (existingInstance) {
-            mcpLogger.debug(`[${functionTag}] Returning existing instance of ${name}`);
-            return existingInstance;
-        }
-        // Get constructor (load if necessary)
-        const Constructor = await this.getConstructor(name);
-        if (!Constructor) {
-            throw new Error(`MCP with name "${name}" is not registered or failed validation.`);
-        }
-        // Security check
-        const discovered = this.discoveredMCPs.get(name);
-        if (discovered &&
-            !this.securityManager.validatePermissions(discovered.metadata.permissions)) {
-            throw new Error(`Security validation failed for MCP "${name}"`);
-        }
-        try {
-            // Instantiate the class
-            const instance = new Constructor();
-            // Initialize with config
-            await instance.initialize(config);
-            // Store instance
-            this.mcpInstances.set(name, instance);
-            mcpLogger.info(`[${functionTag}] Created and initialized ${name}`);
-            return instance;
-        }
-        catch (error) {
-            mcpLogger.error(`[${functionTag}] Failed to create instance of ${name}:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Get or load constructor for an MCP
-     */
-    async getConstructor(name) {
-        // Check if already loaded
-        const existingConstructor = this.mcpConstructors.get(name);
-        if (existingConstructor) {
-            return existingConstructor;
-        }
-        // Load from discovered plugins
-        const discovered = this.discoveredMCPs.get(name);
-        if (!discovered) {
-            return null;
-        }
-        try {
-            // Dynamic import of the plugin
-            const module = await import(discovered.entryPath);
-            const Constructor = module.default || module[discovered.metadata.name];
-            if (typeof Constructor !== "function") {
-                throw new Error(`Invalid export from ${discovered.entryPath}`);
-            }
-            // Store constructor
-            this.mcpConstructors.set(name, Constructor);
-            return Constructor;
-        }
-        catch (error) {
-            mcpLogger.error(`[PluginManager] Failed to load ${name} from ${discovered.entryPath}:`, error);
-            return null;
-        }
-    }
-    /**
-     * List all discovered MCPs
-     */
-    listDiscovered() {
-        return Array.from(this.discoveredMCPs.values()).map((d) => d.metadata);
-    }
-    /**
-     * Get metadata for a specific MCP
-     */
-    getMetadata(name) {
-        const discovered = this.discoveredMCPs.get(name);
-        return discovered ? discovered.metadata : null;
-    }
-    /**
-     * Get discovery statistics
-     */
-    getDiscoveryStats() {
-        const stats = { core: 0, project: 0, installed: 0 };
-        for (const discovered of this.discoveredMCPs.values()) {
-            stats[discovered.source]++;
-        }
-        return stats;
-    }
-    /**
-     * Dispose of all instances and cleanup
-     */
-    async dispose() {
-        mcpLogger.info("[PluginManager] Disposing all MCP instances...");
-        for (const [name, instance] of this.mcpInstances) {
-            try {
-                await instance.dispose();
-                mcpLogger.debug(`[PluginManager] Disposed ${name}`);
-            }
-            catch (error) {
-                mcpLogger.error(`[PluginManager] Failed to dispose ${name}:`, error);
-            }
-        }
-        this.mcpInstances.clear();
-        this.mcpConstructors.clear();
-        this.initialized = false;
-    }
-}
-/**
- * Export singleton instance getter
- */
-export const pluginManager = PluginManager.getInstance();

package/dist/lib/mcp/plugins/core/filesystem-mcp.d.ts

@@ -1,36 +0,0 @@
-/**
- * FileSystemMCP - Proof of Concept Plugin
- * Demonstrates the research blueprint implementation
- */
-import { MCP } from "../../contracts/mcp-contract.js";
-import type { MCPMetadata, ExecutionContext } from "../../contracts/mcp-contract.js";
-import type { UnknownRecord } from "../../../types/common.js";
-interface FileSystemConfig {
-    basePath: string;
-    allowedExtensions?: string[];
-}
-interface FileSystemArgs {
-    operation: "readFile" | "writeFile" | "listFiles" | "createDir";
-    path: string;
-    content?: string;
-    options?: UnknownRecord;
-}
-interface FileSystemResult {
-    success: boolean;
-    data?: UnknownRecord;
-    error?: string;
-}
-/**
- * FileSystem MCP implementing the abstract contract
- */
-export declare class FileSystemMCP extends MCP<FileSystemConfig, FileSystemArgs, FileSystemResult> {
-    readonly metadata: MCPMetadata;
-    initialize(config: FileSystemConfig): Promise<void>;
-    execute(context: ExecutionContext, args: FileSystemArgs): Promise<FileSystemResult>;
-    private readFile;
-    private writeFile;
-    private listFiles;
-    private createDirectory;
-    dispose(): Promise<void>;
-}
-export default FileSystemMCP;

package/dist/lib/mcp/plugins/core/filesystem-mcp.js

@@ -1,142 +0,0 @@
-/**
- * FileSystemMCP - Proof of Concept Plugin
- * Demonstrates the research blueprint implementation
- */
-import { MCP } from "../../contracts/mcp-contract.js";
-import * as path from "path";
-/**
- * FileSystem MCP implementing the abstract contract
- */
-export class FileSystemMCP extends MCP {
-    metadata = {
-        name: "@neurolink-mcp/filesystem",
-        version: "1.0.0",
-        main: "./filesystem-mcp.js",
-        engine: {
-            neurolink: ">=1.9.0 <2.0.0",
-        },
-        description: "Provides secure file system operations for NeuroLink agents",
-        permissions: [
-            "fs:read:./**/*",
-            "fs:write:./output/**/*",
-            "fs:write:./temp/**/*",
-        ],
-    };
-    async initialize(config) {
-        if (!config.basePath) {
-            throw new Error("basePath is required in FileSystemMCP configuration");
-        }
-        this.config = {
-            allowedExtensions: [".txt", ".json", ".md", ".js", ".ts"],
-            ...config,
-        };
-        this.initialized = true;
-    }
-    async execute(context, args) {
-        this.log(context, "info", "Executing FileSystemMCP", { args });
-        this.log(context, "info", "Executing FileSystemMCP", { args });
-        this.log(context, "info", "Executing FileSystemMCP", { args });
-        this.ensureInitialized();
-        try {
-            if (!args.path) {
-                // This is a configuration call, not an operation
-                return { success: true, data: { configured: true } };
-            }
-            const fullPath = path.isAbsolute(args.path)
-                ? args.path
-                : context.path.join(this.config.basePath, args.path);
-            switch (args.operation) {
-                case "readFile":
-                    return await this.readFile(context, fullPath);
-                case "writeFile":
-                    return await this.writeFile(context, fullPath, args.content);
-                case "listFiles":
-                    return await this.listFiles(context, fullPath);
-                case "createDir":
-                    return await this.createDirectory(context, fullPath);
-                default:
-                    throw new Error(`Unsupported operation: ${args.operation}`);
-            }
-        }
-        catch (error) {
-            this.log(context, "error", "Operation failed", {
-                operation: args.operation,
-                error,
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async readFile(context, filePath) {
-        const content = await context.secureFS.readFile(filePath, "utf-8");
-        const stats = await context.secureFS.stat(filePath);
-        return {
-            success: true,
-            data: {
-                content,
-                size: stats.size,
-                lastModified: stats.mtime ||
-                    new Date(stats.mtimeMs || Date.now()),
-                path: filePath,
-            },
-        };
-    }
-    async writeFile(context, filePath, content) {
-        await context.secureFS.writeFile(filePath, content);
-        return {
-            success: true,
-            data: {
-                path: filePath,
-                size: content.length,
-                written: true,
-            },
-        };
-    }
-    async listFiles(context, dirPath) {
-        const items = await context.secureFS.readdir(dirPath);
-        const itemDetails = [];
-        for (const item of items) {
-            const itemPath = context.path.join(dirPath, item);
-            try {
-                const stats = await context.secureFS.stat(itemPath);
-                itemDetails.push({
-                    name: item,
-                    type: stats.isDirectory() ? "directory" : "file",
-                    size: stats.isFile() ? stats.size : undefined,
-                    lastModified: stats.mtime ||
-                        new Date(stats.mtimeMs ||
-                            Date.now()),
-                });
-            }
-            catch {
-                // Skip inaccessible items
-            }
-        }
-        return {
-            success: true,
-            data: {
-                path: dirPath,
-                items: itemDetails,
-                count: itemDetails.length,
-            },
-        };
-    }
-    async createDirectory(context, dirPath) {
-        await context.secureFS.mkdir(dirPath, { recursive: true });
-        return {
-            success: true,
-            data: {
-                path: dirPath,
-                created: true,
-            },
-        };
-    }
-    async dispose() {
-        this.initialized = false;
-        this.config = undefined;
-    }
-}
-// Export as default for dynamic import
-export default FileSystemMCP;

package/dist/lib/mcp/plugins/filesystem-mcp.d.ts

@@ -1,37 +0,0 @@
-/**
- * Enhanced FileSystem MCP Plugin
- * Implements the new MCP contract with security sandbox
- * Based on research document recommendations
- */
-import { MCP, type MCPMetadata, type ExecutionContext } from "../contracts/mcp-contract.js";
-import type { Unknown } from "../../types/common.js";
-/**
- * FileSystem MCP Configuration
- */
-export interface FileSystemConfig {
-    basePath: string;
-    allowedExtensions?: string[];
-    maxFileSize?: number;
-    readOnly?: boolean;
-}
-/**
- * FileSystem Operation Arguments
- */
-export interface FileSystemArgs {
-    operation: "readFile" | "writeFile" | "listFiles" | "getFileInfo";
-    path: string;
-    content?: string;
-    encoding?: string;
-}
-/**
- * Enhanced FileSystem MCP Plugin
- */
-export declare class FileSystemMCP extends MCP<FileSystemConfig> {
-    config: FileSystemConfig;
-    readonly metadata: MCPMetadata;
-    initialize(config: FileSystemConfig): Promise<void>;
-    execute(context: ExecutionContext, args: FileSystemArgs): Promise<Unknown>;
-    private resolvePath;
-    dispose(): Promise<void>;
-}
-export declare function createFileSystemMCP(): FileSystemMCP;

package/dist/lib/mcp/plugins/filesystem-mcp.js

@@ -1,54 +0,0 @@
-/**
- * Enhanced FileSystem MCP Plugin
- * Implements the new MCP contract with security sandbox
- * Based on research document recommendations
- */
-import path from "path";
-import { MCP, } from "../contracts/mcp-contract.js";
-/**
- * Enhanced FileSystem MCP Plugin
- */
-export class FileSystemMCP extends MCP {
-    metadata = {
-        name: "@neurolink-mcp/filesystem",
-        version: "1.0.0",
-        main: "./dist/filesystem-mcp.js",
-        engine: { neurolink: ">=1.9.0 <2.0.0" },
-        description: "Secure file system operations with permission-based access control",
-        permissions: ["fs:read:./**/*", "fs:write:./output/**/*"],
-    };
-    async initialize(config) {
-        this.config = {
-            allowedExtensions: [".txt", ".md", ".json", ".js", ".ts"],
-            maxFileSize: 10 * 1024 * 1024,
-            readOnly: false,
-            ...config,
-        };
-    }
-    async execute(context, args) {
-        const resolvedPath = this.resolvePath(args.path);
-        switch (args.operation) {
-            case "readFile":
-                return await context.secureFS.readFile(resolvedPath, args.encoding || "utf-8");
-            case "listFiles":
-                return await context.secureFS.readdir(resolvedPath);
-            case "getFileInfo":
-                return await context.secureFS.stat(resolvedPath);
-            default:
-                throw new Error(`Unsupported operation: ${args.operation}`);
-        }
-    }
-    resolvePath(inputPath) {
-        const resolved = path.resolve(this.config.basePath, inputPath);
-        if (!resolved.startsWith(this.config.basePath)) {
-            throw new Error(`Path outside allowed directory: ${inputPath}`);
-        }
-        return resolved;
-    }
-    async dispose() {
-        // Cleanup resources
-    }
-}
-export function createFileSystemMCP() {
-    return new FileSystemMCP();
-}