@juspay/neurolink 6.1.0 → 6.2.0

package/dist/lib/mcp/session-persistence.js

@@ -1,301 +0,0 @@
-/**
- * NeuroLink Session Persistence Layer
- * Provides file-based persistence for sessions with atomic writes and recovery
- */
-import fs from "fs/promises";
-import path from "path";
-import crypto from "crypto";
-/**
- * Session Persistence Manager
- * Handles saving and loading sessions to/from disk with recovery mechanisms
- */
-export class SessionPersistence {
-    directory;
-    snapshotInterval;
-    retentionPeriod;
-    enableChecksum;
-    maxRetries;
-    snapshotTimer = null;
-    sessionMap;
-    constructor(sessionMap, options = {}) {
-        this.sessionMap = sessionMap;
-        this.directory = options.directory || ".neurolink/sessions";
-        this.snapshotInterval = options.snapshotInterval || 30000; // 30 seconds
-        this.retentionPeriod = options.retentionPeriod || 86400000; // 24 hours
-        this.enableChecksum = options.enableChecksum ?? true;
-        this.maxRetries = options.maxRetries || 3;
-    }
-    /**
-     * Initialize persistence layer
-     */
-    async initialize() {
-        // Create sessions directory if it doesn't exist
-        await this.ensureDirectory();
-        // Load existing sessions
-        await this.loadSessions();
-        // Start snapshot timer
-        this.startSnapshotTimer();
-        if (process.env.NEUROLINK_DEBUG === "true") {
-            console.log(`[SessionPersistence] Initialized with directory: ${this.directory}`);
-        }
-    }
-    /**
-     * Ensure sessions directory exists
-     */
-    async ensureDirectory() {
-        await fs.mkdir(this.directory, { recursive: true });
-    }
-    /**
-     * Calculate checksum for data integrity
-     */
-    calculateChecksum(data) {
-        return crypto.createHash("sha256").update(data).digest("hex");
-    }
-    /**
-     * Serialize session to JSON with metadata
-     */
-    serializeSession(session) {
-        // Convert Map to array for JSON serialization
-        const sessionData = {
-            ...session,
-            state: Array.from(session.state.entries()),
-        };
-        const fileData = {
-            session: sessionData,
-            checksum: "",
-            version: "1.0",
-            lastSaved: Date.now(),
-        };
-        if (this.enableChecksum) {
-            // First serialization without checksum
-            const tempJsonData = JSON.stringify(fileData, null, 2);
-            // Calculate checksum based on the first serialization
-            fileData.checksum = this.calculateChecksum(tempJsonData);
-        }
-        // Final serialization with checksum included
-        return JSON.stringify(fileData, null, 2);
-    }
-    /**
-     * Deserialize session from JSON
-     */
-    deserializeSession(data) {
-        try {
-            const fileData = JSON.parse(data);
-            // Verify checksum if enabled
-            if (this.enableChecksum && fileData.checksum) {
-                const tempData = { ...fileData, checksum: "" };
-                const expectedChecksum = this.calculateChecksum(JSON.stringify(tempData, null, 2));
-                if (fileData.checksum !== expectedChecksum) {
-                    console.error("[SessionPersistence] Checksum mismatch, session corrupted");
-                    return null;
-                }
-            }
-            // Convert state array back to Map
-            const serializedSession = fileData.session;
-            const session = {
-                ...serializedSession,
-                state: new Map(serializedSession.state),
-            };
-            return session;
-        }
-        catch (error) {
-            console.error("[SessionPersistence] Failed to deserialize session:", error);
-            return null;
-        }
-    }
-    /**
-     * Save single session with atomic write
-     */
-    async saveSession(sessionId, session) {
-        const filename = `${sessionId}.json`;
-        const filepath = path.join(this.directory, filename);
-        const tempPath = `${filepath}.tmp`;
-        let retries = 0;
-        while (retries < this.maxRetries) {
-            try {
-                // Serialize session
-                const data = this.serializeSession(session);
-                // Write to temporary file first (atomic write pattern)
-                await fs.writeFile(tempPath, data, "utf8");
-                // Rename temp file to final location (atomic operation)
-                await fs.rename(tempPath, filepath);
-                if (process.env.NEUROLINK_DEBUG === "true") {
-                    console.log(`[SessionPersistence] Saved session ${sessionId}`);
-                }
-                return true;
-            }
-            catch (error) {
-                retries++;
-                console.error(`[SessionPersistence] Failed to save session (attempt ${retries}):`, error);
-                // Clean up temp file if it exists
-                try {
-                    await fs.unlink(tempPath);
-                }
-                catch {
-                    // Ignore errors when cleaning up temp file
-                }
-                if (retries < this.maxRetries) {
-                    // Exponential backoff
-                    await new Promise((resolve) => setTimeout(resolve, Math.pow(2, retries) * 100));
-                }
-            }
-        }
-        return false;
-    }
-    /**
-     * Load single session from disk
-     */
-    async loadSession(sessionId) {
-        const filename = `${sessionId}.json`;
-        const filepath = path.join(this.directory, filename);
-        try {
-            const data = await fs.readFile(filepath, "utf8");
-            return this.deserializeSession(data);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                console.error(`[SessionPersistence] Failed to load session ${sessionId}:`, error);
-            }
-            return null;
-        }
-    }
-    /**
-     * Load all sessions from disk on startup
-     */
-    async loadSessions() {
-        try {
-            const files = await fs.readdir(this.directory);
-            const sessionFiles = files.filter((f) => f.endsWith(".json"));
-            let loaded = 0;
-            let expired = 0;
-            for (const file of sessionFiles) {
-                const sessionId = file.replace(".json", "");
-                const session = await this.loadSession(sessionId);
-                if (session) {
-                    // Check if session is expired
-                    if (session.expiresAt < Date.now()) {
-                        expired++;
-                        // Clean up expired session file
-                        await this.deleteSession(sessionId);
-                    }
-                    else {
-                        // Restore to memory
-                        this.sessionMap.set(sessionId, session);
-                        loaded++;
-                    }
-                }
-            }
-            console.log(`[SessionPersistence] Loaded ${loaded} sessions, cleaned ${expired} expired sessions`);
-        }
-        catch (error) {
-            console.error("[SessionPersistence] Failed to load sessions:", error);
-        }
-    }
-    /**
-     * Save all active sessions (snapshot)
-     */
-    async saveAllSessions() {
-        const sessions = Array.from(this.sessionMap.entries());
-        // Filter out expired sessions and create save promises
-        const savePromises = sessions
-            .filter(([_, session]) => session.expiresAt >= Date.now())
-            .map(async ([sessionId, session]) => {
-            return (await this.saveSession(sessionId, session)) ? 1 : 0;
-        });
-        // Execute all save operations concurrently
-        const results = await Promise.all(savePromises);
-        const saved = results.reduce((sum, result) => sum + result, 0);
-        if (process.env.NEUROLINK_DEBUG === "true") {
-            console.log(`[SessionPersistence] Snapshot: saved ${saved}/${sessions.length} sessions`);
-        }
-    }
-    /**
-     * Delete session file
-     */
-    async deleteSession(sessionId) {
-        const filename = `${sessionId}.json`;
-        const filepath = path.join(this.directory, filename);
-        try {
-            await fs.unlink(filepath);
-            // Keep memory and disk state in sync
-            this.sessionMap.delete(sessionId);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                console.error(`[SessionPersistence] Failed to delete session ${sessionId}:`, error);
-            }
-        }
-    }
-    /**
-     * Clean up old session files
-     */
-    async cleanupOldSessions() {
-        try {
-            const files = await fs.readdir(this.directory);
-            const now = Date.now();
-            let cleaned = 0;
-            for (const file of files) {
-                if (!file.endsWith(".json")) {
-                    continue;
-                }
-                const filepath = path.join(this.directory, file);
-                const stats = await fs.stat(filepath);
-                // Remove files older than retention period
-                if (now - stats.mtimeMs > this.retentionPeriod) {
-                    await fs.unlink(filepath);
-                    cleaned++;
-                }
-            }
-            if (cleaned > 0) {
-                console.log(`[SessionPersistence] Cleaned up ${cleaned} old session files`);
-            }
-        }
-        catch (error) {
-            console.error("[SessionPersistence] Cleanup failed:", error);
-        }
-    }
-    /**
-     * Start periodic snapshot timer
-     */
-    startSnapshotTimer() {
-        if (this.snapshotTimer) {
-            clearInterval(this.snapshotTimer);
-        }
-        this.snapshotTimer = setInterval(async () => {
-            await this.saveAllSessions();
-            await this.cleanupOldSessions();
-        }, this.snapshotInterval);
-    }
-    /**
-     * Stop snapshot timer
-     */
-    stopSnapshotTimer() {
-        if (this.snapshotTimer) {
-            clearInterval(this.snapshotTimer);
-            this.snapshotTimer = null;
-        }
-    }
-    /**
-     * Shutdown persistence layer
-     */
-    async shutdown() {
-        this.stopSnapshotTimer();
-        // Final snapshot before shutdown
-        await this.saveAllSessions();
-        console.log("[SessionPersistence] Shutdown complete");
-    }
-}
-/**
- * Default session persistence instance
- */
-export let defaultSessionPersistence = null;
-/**
- * Initialize default session persistence
- */
-export async function initializeSessionPersistence(sessionMap, options) {
-    if (!defaultSessionPersistence) {
-        defaultSessionPersistence = new SessionPersistence(sessionMap, options);
-        await defaultSessionPersistence.initialize();
-    }
-    return defaultSessionPersistence;
-}

package/dist/lib/mcp/tool-integration.d.ts

@@ -1,58 +0,0 @@
-/**
- * MCP Tool Integration Layer
- * Connects MCP tools to NeuroLink AI providers following Lighthouse patterns
- */
-import type { Unknown } from "../types/common.js";
-import type { NeuroLinkExecutionContext, ToolResult } from "./factory.js";
-/**
- * Tool Integration System
- * Provides natural language tool discovery and execution
- */
-export declare class MCPToolIntegration {
-    private registry;
-    private context;
-    constructor(context?: Partial<NeuroLinkExecutionContext>);
-    /**
-     * Initialize tools from all active servers
-     */
-    private initializeTools;
-    /**
-     * Get all available tools
-     */
-    getAvailableTools(): Promise<import("./tool-registry.js").ToolInfo[]>;
-    /**
-     * Find tools that match a query
-     */
-    findTools(query: string): Promise<Array<{
-        name: string;
-        description: string;
-        serverId: string;
-        relevance: number;
-    }>>;
-    /**
-     * Execute a tool by name
-     */
-    executeTool(toolName: string, params: Unknown, serverId?: string): Promise<ToolResult>;
-    /**
-     * Enhance AI prompt with tool context
-     */
-    createToolAwarePrompt(userPrompt: string): Promise<string>;
-    /**
-     * Analyze AI response for tool usage requests
-     */
-    analyzeForToolUsage(aiResponse: string): Array<{
-        toolName: string;
-        params: Unknown;
-        confidence: number;
-    }>;
-    /**
-     * Update context for tool execution
-     */
-    updateContext(updates: Partial<NeuroLinkExecutionContext>): void;
-}
-export declare function getToolIntegration(context?: Partial<NeuroLinkExecutionContext>): MCPToolIntegration;
-/**
- * Initialize MCP tools for a session
- * Following Lighthouse's initialization pattern
- */
-export declare function initializeMCPTools(sessionId: string, context?: Partial<NeuroLinkExecutionContext>): Promise<MCPToolIntegration>;

package/dist/lib/mcp/tool-integration.js

@@ -1,203 +0,0 @@
-/**
- * MCP Tool Integration Layer
- * Connects MCP tools to NeuroLink AI providers following Lighthouse patterns
- */
-import { mcpConfig } from "./config.js";
-import { logger } from "../utils/logger.js";
-import { MCPToolRegistry } from "./tool-registry.js";
-/**
- * Tool Integration System
- * Provides natural language tool discovery and execution
- */
-export class MCPToolIntegration {
-    registry;
-    context;
-    constructor(context) {
-        this.registry = new MCPToolRegistry();
-        this.context = {
-            sessionId: context?.sessionId || `session-${Date.now()}`,
-            userId: context?.userId || "anonymous",
-            aiProvider: context?.aiProvider || "unknown",
-            ...context,
-            // Ensure secureFS is properly typed
-            secureFS: context?.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,
-                rmdir: async () => {
-                    throw new Error("secureFS not configured");
-                },
-                unlink: async () => {
-                    throw new Error("secureFS not configured");
-                },
-            },
-        };
-        // Initialize with all active servers
-        this.initializeTools();
-    }
-    /**
-     * Initialize tools from all active servers
-     */
-    async initializeTools() {
-        const servers = await mcpConfig.getServers();
-        for (const server of servers) {
-            await this.registry.registerServer(server.id ||
-                server.name ||
-                "unknown", server);
-        }
-        const tools = await this.registry.listTools();
-        logger.debug("[Tool Integration] Initialized with servers:", {
-            serverCount: servers.length,
-            toolCount: tools.length,
-        });
-    }
-    /**
-     * Get all available tools
-     */
-    getAvailableTools() {
-        return this.registry.listTools();
-    }
-    /**
-     * Find tools that match a query
-     */
-    async findTools(query) {
-        const allTools = await this.registry.listTools();
-        const queryLower = query.toLowerCase();
-        const results = [];
-        for (const toolInfo of allTools) {
-            let relevance = 0;
-            // Check tool name
-            if (toolInfo.name.toLowerCase().includes(queryLower)) {
-                relevance += 10;
-            }
-            // Check tool description
-            if (toolInfo.description?.toLowerCase().includes(queryLower)) {
-                relevance += 5;
-            }
-            // Check category if present (category might not exist on ToolInfo)
-            // if (toolInfo.category?.toLowerCase().includes(queryLower)) {
-            //   relevance += 3;
-            // }
-            if (relevance > 0) {
-                results.push({
-                    name: toolInfo.name,
-                    description: toolInfo.description || "No description available",
-                    serverId: toolInfo.serverId || "unknown",
-                    relevance,
-                });
-            }
-        }
-        // Sort by relevance
-        return results.sort((a, b) => b.relevance - a.relevance);
-    }
-    /**
-     * Execute a tool by name
-     */
-    async executeTool(toolName, params, serverId) {
-        try {
-            // If serverId is provided, use qualified name
-            const qualifiedName = serverId ? `${serverId}.${toolName}` : toolName;
-            const result = await this.registry.executeTool(qualifiedName, params, this.context);
-            return result;
-        }
-        catch (error) {
-            logger.error("[Tool Integration] Tool execution failed:", error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                metadata: {
-                    toolName,
-                    serverId,
-                    timestamp: Date.now(),
-                },
-            };
-        }
-    }
-    /**
-     * Enhance AI prompt with tool context
-     */
-    async createToolAwarePrompt(userPrompt) {
-        const tools = await this.getAvailableTools();
-        const toolDescriptions = tools
-            .map((t) => `- ${t.name}: ${t.description}`)
-            .join("\n");
-        return `${userPrompt}
-
-Available tools:
-${toolDescriptions}
-
-You can use these tools to provide more accurate and real-time information.`;
-    }
-    /**
-     * Analyze AI response for tool usage requests
-     */
-    analyzeForToolUsage(aiResponse) {
-        const toolRequests = [];
-        // Simple pattern matching for tool requests
-        // This can be enhanced with more sophisticated NLP
-        const toolPattern = /<tool[^>]*>([^<]+)<\/tool>/g;
-        let match;
-        while ((match = toolPattern.exec(aiResponse)) !== null) {
-            try {
-                const toolData = JSON.parse(match[1]);
-                toolRequests.push({
-                    toolName: toolData.name,
-                    params: toolData.params || {},
-                    confidence: 1.0,
-                });
-            }
-            catch (error) {
-                logger.warn("[Tool Integration] Failed to parse tool request:", match[1]);
-            }
-        }
-        return toolRequests;
-    }
-    /**
-     * Update context for tool execution
-     */
-    updateContext(updates) {
-        this.context = {
-            ...this.context,
-            ...updates,
-        };
-    }
-}
-/**
- * Create a global tool integration instance
- * This can be initialized once and reused
- */
-let globalToolIntegration = null;
-export function getToolIntegration(context) {
-    if (!globalToolIntegration) {
-        globalToolIntegration = new MCPToolIntegration(context);
-    }
-    else if (context) {
-        globalToolIntegration.updateContext(context);
-    }
-    return globalToolIntegration;
-}
-/**
- * Initialize MCP tools for a session
- * Following Lighthouse's initialization pattern
- */
-export async function initializeMCPTools(sessionId, context) {
-    const integration = getToolIntegration({
-        sessionId,
-        ...context,
-    });
-    logger.debug("[Tool Integration] MCP tools initialized for session:", sessionId);
-    return integration;
-}