claude-recall 0.2.0

package/dist/mcp/rate-limiter.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiter = void 0;
+class RateLimiter {
+    constructor(logger, config = {}) {
+        this.logger = logger;
+        this.requests = new Map();
+        this.cleanupInterval = null;
+        this.windowMs = config.windowMs || 60000; // 1 minute default
+        this.maxRequests = config.maxRequests || 100; // 100 requests default
+        this.skipSuccessfulRequests = config.skipSuccessfulRequests || false;
+        // Clean up old entries periodically
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, this.windowMs);
+        this.logger.info('RateLimiter', 'Rate limiter initialized', {
+            windowMs: this.windowMs,
+            maxRequests: this.maxRequests,
+            skipSuccessfulRequests: this.skipSuccessfulRequests
+        });
+    }
+    async checkLimit(sessionId) {
+        const now = Date.now();
+        const requests = this.requests.get(sessionId) || [];
+        // Remove old requests outside window
+        const validRequests = requests.filter(time => now - time < this.windowMs);
+        if (validRequests.length >= this.maxRequests) {
+            this.logger.warn('RateLimiter', 'Rate limit exceeded', {
+                sessionId,
+                requests: validRequests.length,
+                window: this.windowMs,
+                maxRequests: this.maxRequests
+            });
+            return false;
+        }
+        // Don't add to count yet - wait for recordRequest
+        this.requests.set(sessionId, validRequests);
+        return true;
+    }
+    recordRequest(sessionId, successful = true) {
+        if (this.skipSuccessfulRequests && successful) {
+            return; // Don't count successful requests if configured
+        }
+        const now = Date.now();
+        const requests = this.requests.get(sessionId) || [];
+        // Add new request
+        requests.push(now);
+        // Keep only requests within window
+        const validRequests = requests.filter(time => now - time < this.windowMs);
+        this.requests.set(sessionId, validRequests);
+        this.logger.debug('RateLimiter', 'Request recorded', {
+            sessionId,
+            requestCount: validRequests.length,
+            successful
+        });
+    }
+    getRemainingRequests(sessionId) {
+        const now = Date.now();
+        const requests = this.requests.get(sessionId) || [];
+        const validRequests = requests.filter(time => now - time < this.windowMs);
+        return Math.max(0, this.maxRequests - validRequests.length);
+    }
+    resetLimit(sessionId) {
+        this.requests.delete(sessionId);
+        this.logger.info('RateLimiter', 'Rate limit reset', { sessionId });
+    }
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [sessionId, requests] of this.requests) {
+            const validRequests = requests.filter(time => now - time < this.windowMs);
+            if (validRequests.length === 0) {
+                this.requests.delete(sessionId);
+                cleaned++;
+            }
+            else if (validRequests.length < requests.length) {
+                this.requests.set(sessionId, validRequests);
+            }
+        }
+        if (cleaned > 0) {
+            this.logger.debug('RateLimiter', `Cleaned up ${cleaned} expired session limits`);
+        }
+    }
+    getStats() {
+        const now = Date.now();
+        const stats = {
+            activeSessions: this.requests.size,
+            totalRequests: 0,
+            topSessions: []
+        };
+        const sessionRequests = [];
+        for (const [sessionId, requests] of this.requests) {
+            const validRequests = requests.filter(time => now - time < this.windowMs);
+            const count = validRequests.length;
+            stats.totalRequests += count;
+            sessionRequests.push({ sessionId, requests: count });
+        }
+        // Get top 5 sessions by request count
+        stats.topSessions = sessionRequests
+            .sort((a, b) => b.requests - a.requests)
+            .slice(0, 5);
+        return stats;
+    }
+    shutdown() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.logger.info('RateLimiter', 'Rate limiter shut down', {
+            activeSessions: this.requests.size
+        });
+    }
+}
+exports.RateLimiter = RateLimiter;

package/dist/mcp/server.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPServer = void 0;
+const stdio_1 = require("./transports/stdio");
+const memory_tools_1 = require("./tools/memory-tools");
+const memory_1 = require("../services/memory");
+const logging_1 = require("../services/logging");
+const session_manager_1 = require("./session-manager");
+const rate_limiter_1 = require("./rate-limiter");
+class MCPServer {
+    constructor() {
+        this.tools = new Map();
+        this.sessions = new Map();
+        this.isInitialized = false;
+        this.transport = new stdio_1.StdioTransport();
+        this.memoryService = memory_1.MemoryService.getInstance();
+        this.logger = logging_1.LoggingService.getInstance();
+        this.sessionManager = new session_manager_1.SessionManager(this.logger);
+        this.rateLimiter = new rate_limiter_1.RateLimiter(this.logger, {
+            windowMs: 60000, // 1 minute
+            maxRequests: 100, // 100 requests per minute
+            skipSuccessfulRequests: false
+        });
+        this.setupRequestHandlers();
+        this.registerTools();
+    }
+    setupRequestHandlers() {
+        this.transport.onRequest(async (request) => {
+            try {
+                switch (request.method) {
+                    case 'initialize':
+                        return this.handleInitialize(request);
+                    case 'tools/list':
+                        return this.handleToolsList(request);
+                    case 'tools/call':
+                        return this.handleToolCall(request);
+                    case 'notifications/initialized':
+                        return this.handleInitialized(request);
+                    case 'health/check':
+                        return this.handleHealthCheck(request);
+                    default:
+                        return this.createErrorResponse(request.id, -32601, `Method not found: ${request.method}`);
+                }
+            }
+            catch (error) {
+                this.logger.logServiceError('MCPServer', 'handleRequest', error, { method: request.method });
+                return this.createErrorResponse(request.id, -32603, 'Internal error', { message: error.message });
+            }
+        });
+    }
+    registerTools() {
+        const memoryTools = new memory_tools_1.MemoryTools(this.memoryService, this.logger);
+        const tools = memoryTools.getTools();
+        for (const tool of tools) {
+            this.tools.set(tool.name, tool);
+        }
+        this.logger.info('MCPServer', `Registered ${this.tools.size} tools`, {
+            tools: Array.from(this.tools.keys())
+        });
+    }
+    async handleInitialize(request) {
+        const params = request.params || {};
+        this.logger.info('MCPServer', 'Initializing MCP server', params);
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+                protocolVersion: "2024-11-05",
+                capabilities: {
+                    tools: {},
+                    logging: {}
+                },
+                serverInfo: {
+                    name: "claude-recall",
+                    version: "0.2.0"
+                }
+            }
+        };
+    }
+    async handleInitialized(request) {
+        this.isInitialized = true;
+        this.logger.info('MCPServer', 'MCP server initialized successfully');
+        // Note: initialized is a notification, no response required
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: null
+        };
+    }
+    async handleToolsList(request) {
+        const toolList = Array.from(this.tools.values()).map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema
+        }));
+        this.logger.debug('MCPServer', `Listing ${toolList.length} tools`);
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+                tools: toolList
+            }
+        };
+    }
+    async handleToolCall(request) {
+        const { name, arguments: toolArgs } = request.params || {};
+        if (!name || typeof name !== 'string') {
+            return this.createErrorResponse(request.id, -32602, 'Invalid params: tool name required');
+        }
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return this.createErrorResponse(request.id, -32601, `Tool not found: ${name}`);
+        }
+        const startTime = Date.now();
+        try {
+            // Create or get session context
+            const sessionId = toolArgs?.sessionId || this.generateSessionId();
+            // Get or create session
+            let session = this.sessionManager.getSession(sessionId);
+            if (!session) {
+                session = this.sessionManager.createSession(sessionId);
+            }
+            // Check rate limit
+            const withinLimit = await this.rateLimiter.checkLimit(sessionId);
+            if (!withinLimit) {
+                const remaining = this.rateLimiter.getRemainingRequests(sessionId);
+                return this.createErrorResponse(request.id, -32000, // Custom error code for rate limit
+                'Rate limit exceeded', {
+                    sessionId,
+                    remainingRequests: remaining,
+                    windowMs: 60000,
+                    message: 'Too many requests. Please wait before trying again.'
+                });
+            }
+            // Update session activity
+            this.sessionManager.incrementToolCalls(sessionId);
+            const context = {
+                sessionId,
+                timestamp: Date.now(),
+                projectId: toolArgs?.projectId
+            };
+            this.logger.info('MCPServer', `Executing tool: ${name}`, {
+                sessionId,
+                args: toolArgs,
+                toolCallCount: session.toolCalls
+            });
+            const result = await tool.handler(toolArgs || {}, context);
+            // Record successful request for rate limiting
+            this.rateLimiter.recordRequest(sessionId, true);
+            // Claude-flow pattern: Enhanced response format
+            return {
+                jsonrpc: "2.0",
+                id: request.id,
+                result: {
+                    content: [
+                        {
+                            type: "text",
+                            text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+                        }
+                    ],
+                    isError: false,
+                    metadata: {
+                        toolName: name,
+                        duration: Date.now() - startTime,
+                        sessionId: context.sessionId
+                    }
+                }
+            };
+        }
+        catch (error) {
+            this.logger.logServiceError('MCPServer', `tool:${name}`, error, toolArgs);
+            // Record failed request for rate limiting
+            const sessionId = toolArgs?.sessionId || this.generateSessionId();
+            this.rateLimiter.recordRequest(sessionId, false);
+            // Claude-flow pattern: Enhanced error response
+            return {
+                jsonrpc: "2.0",
+                id: request.id,
+                result: {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Tool execution failed: ${error.message}`
+                        }
+                    ],
+                    isError: true,
+                    metadata: {
+                        toolName: name,
+                        duration: Date.now() - startTime,
+                        sessionId: this.generateSessionId(),
+                        error: {
+                            message: error.message,
+                            stack: error.stack
+                        }
+                    }
+                }
+            };
+        }
+    }
+    createErrorResponse(id, code, message, data) {
+        return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+                code,
+                message,
+                ...(data && { data })
+            }
+        };
+    }
+    generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    async handleHealthCheck(request) {
+        const rateLimiterStats = this.rateLimiter.getStats();
+        const health = {
+            status: 'healthy',
+            version: '0.2.0',
+            uptime: process.uptime(),
+            memory: process.memoryUsage(),
+            sessions: {
+                total: this.sessionManager.getAllSessions().length,
+                active: this.sessionManager.getActiveSessionCount()
+            },
+            toolsRegistered: this.tools.size,
+            database: this.memoryService.isConnected() ? 'connected' : 'disconnected',
+            rateLimiter: {
+                activeSessions: rateLimiterStats.activeSessions,
+                totalRequests: rateLimiterStats.totalRequests,
+                topSessions: rateLimiterStats.topSessions
+            }
+        };
+        this.logger.info('MCPServer', 'Health check performed', health);
+        return {
+            jsonrpc: "2.0",
+            id: request.id,
+            result: health
+        };
+    }
+    async start() {
+        try {
+            this.logger.info('MCPServer', 'Starting Claude Recall MCP server...');
+            await this.transport.start();
+            this.logger.info('MCPServer', 'MCP server started successfully');
+        }
+        catch (error) {
+            this.logger.logServiceError('MCPServer', 'start', error);
+            throw error;
+        }
+    }
+    async stop() {
+        try {
+            this.logger.info('MCPServer', 'Stopping MCP server...');
+            // Clean up old sessions before shutdown
+            this.sessionManager.cleanupOldSessions();
+            // Shutdown session manager (persists sessions)
+            this.sessionManager.shutdown();
+            // Shutdown rate limiter
+            this.rateLimiter.shutdown();
+            await this.transport.stop();
+            this.memoryService.close();
+            this.logger.info('MCPServer', 'MCP server stopped');
+        }
+        catch (error) {
+            this.logger.logServiceError('MCPServer', 'stop', error);
+            throw error;
+        }
+    }
+    // Graceful shutdown handling
+    setupSignalHandlers() {
+        process.on('SIGINT', async () => {
+            this.logger.info('MCPServer', 'Received SIGINT, shutting down gracefully...');
+            await this.stop();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            this.logger.info('MCPServer', 'Received SIGTERM, shutting down gracefully...');
+            await this.stop();
+            process.exit(0);
+        });
+    }
+}
+exports.MCPServer = MCPServer;

package/dist/mcp/session-manager.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class SessionManager {
+    constructor(logger) {
+        this.sessions = new Map();
+        this.persistInterval = null;
+        this.logger = logger;
+        this.sessionFile = path.join(os.homedir(), '.claude-recall', 'sessions.json');
+        this.ensureDirectoryExists();
+        this.loadSessions();
+        // Persist sessions periodically
+        this.persistInterval = setInterval(() => {
+            this.persistSessions();
+        }, 30000); // Every 30 seconds
+    }
+    ensureDirectoryExists() {
+        const dir = path.dirname(this.sessionFile);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    createSession(id) {
+        const session = {
+            id,
+            startTime: Date.now(),
+            lastActivity: Date.now(),
+            toolCalls: 0,
+            memories: []
+        };
+        this.sessions.set(id, session);
+        this.persistSessions();
+        this.logger.info('SessionManager', 'Session created', { sessionId: id });
+        return session;
+    }
+    getSession(id) {
+        return this.sessions.get(id);
+    }
+    updateSession(id, update) {
+        const session = this.sessions.get(id);
+        if (session) {
+            Object.assign(session, update, { lastActivity: Date.now() });
+            this.persistSessions();
+            this.logger.debug('SessionManager', 'Session updated', { sessionId: id, update });
+        }
+    }
+    incrementToolCalls(id) {
+        const session = this.sessions.get(id);
+        if (session) {
+            session.toolCalls++;
+            session.lastActivity = Date.now();
+            this.persistSessions();
+        }
+    }
+    addMemory(id, memoryId) {
+        const session = this.sessions.get(id);
+        if (session) {
+            session.memories.push(memoryId);
+            session.lastActivity = Date.now();
+            this.persistSessions();
+        }
+    }
+    loadSessions() {
+        try {
+            if (fs.existsSync(this.sessionFile)) {
+                const data = fs.readFileSync(this.sessionFile, 'utf-8');
+                const sessions = JSON.parse(data);
+                // Convert array back to Map
+                if (Array.isArray(sessions)) {
+                    sessions.forEach(([id, session]) => {
+                        this.sessions.set(id, session);
+                    });
+                }
+                this.logger.info('SessionManager', `Loaded ${this.sessions.size} sessions from disk`);
+            }
+        }
+        catch (error) {
+            this.logger.error('SessionManager', 'Failed to load sessions', error);
+        }
+    }
+    persistSessions() {
+        try {
+            // Save to disk like claude-flow does
+            const data = JSON.stringify(Array.from(this.sessions.entries()), null, 2);
+            fs.writeFileSync(this.sessionFile, data);
+            this.logger.debug('SessionManager', `Persisted ${this.sessions.size} sessions to disk`);
+        }
+        catch (error) {
+            this.logger.error('SessionManager', 'Failed to persist sessions', error);
+        }
+    }
+    // Clean up old sessions (sessions older than 24 hours with no activity)
+    cleanupOldSessions() {
+        const now = Date.now();
+        const maxAge = 24 * 60 * 60 * 1000; // 24 hours
+        let removed = 0;
+        for (const [id, session] of this.sessions) {
+            if (now - session.lastActivity > maxAge) {
+                this.sessions.delete(id);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            this.logger.info('SessionManager', `Cleaned up ${removed} old sessions`);
+            this.persistSessions();
+        }
+    }
+    getAllSessions() {
+        return Array.from(this.sessions.values());
+    }
+    getActiveSessionCount() {
+        const now = Date.now();
+        const activeThreshold = 5 * 60 * 1000; // 5 minutes
+        return Array.from(this.sessions.values()).filter(session => now - session.lastActivity < activeThreshold).length;
+    }
+    shutdown() {
+        if (this.persistInterval) {
+            clearInterval(this.persistInterval);
+            this.persistInterval = null;
+        }
+        this.persistSessions();
+        this.logger.info('SessionManager', 'Session manager shut down');
+    }
+}
+exports.SessionManager = SessionManager;