memento-mcp-server 0.1.0

package/src/server/index.ts

@@ -0,0 +1,347 @@
+/**
+ * Memento MCP Server 메인 진입점 (리팩토링된 버전)
+ * 모듈화된 도구들을 사용하여 유지보수성 개선
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { initializeDatabase, closeDatabase } from '../database/init.js';
+import { mementoConfig, validateConfig } from '../config/index.js';
+import { DatabaseUtils } from '../utils/database.js';
+import { SearchEngine } from '../algorithms/search-engine.js';
+import { HybridSearchEngine } from '../algorithms/hybrid-search-engine.js';
+import { MemoryEmbeddingService } from '../services/memory-embedding-service.js';
+import { ForgettingPolicyService } from '../services/forgetting-policy-service.js';
+import { PerformanceMonitor } from '../services/performance-monitor.js';
+import { SearchCacheService } from '../services/cache-service.js';
+import { DatabaseOptimizer } from '../services/database-optimizer.js';
+import { ErrorLoggingService, ErrorSeverity, ErrorCategory } from '../services/error-logging-service.js';
+import { PerformanceAlertService, AlertType, AlertLevel } from '../services/performance-alert-service.js';
+// import { PerformanceMonitoringIntegration } from '../services/performance-monitoring-integration.js';
+import { getToolRegistry } from '../tools/index.js';
+import type { ToolContext } from '../tools/types.js';
+import Database from 'better-sqlite3';
+
+// MCP 서버 인스턴스
+let server: Server;
+let db: Database.Database | null = null;
+let searchEngine: SearchEngine;
+let hybridSearchEngine: HybridSearchEngine;
+let embeddingService: MemoryEmbeddingService;
+let forgettingPolicyService: ForgettingPolicyService;
+let performanceMonitor: PerformanceMonitor;
+let searchCache: SearchCacheService;
+let databaseOptimizer: DatabaseOptimizer;
+let errorLoggingService: ErrorLoggingService;
+let performanceAlertService: PerformanceAlertService;
+// let performanceMonitoringIntegration: PerformanceMonitoringIntegration;
+
+// MCP 서버에서는 모든 로그 출력을 완전히 차단
+// 모든 console 메서드를 빈 함수로 교체
+console.log = () => {};
+console.error = () => {};
+console.warn = () => {};
+console.info = () => {};
+console.debug = () => {};
+
+// 동시성 제한을 위한 세마포어
+export class Semaphore {
+  private permits: number;
+  private waiting: Array<() => void> = [];
+
+  constructor(permits: number) {
+    this.permits = permits;
+  }
+
+  async acquire(): Promise<void> {
+    if (this.permits > 0) {
+      this.permits--;
+      return;
+    }
+
+    return new Promise(resolve => {
+      this.waiting.push(resolve);
+    });
+  }
+
+  release(): void {
+    this.permits++;
+    if (this.waiting.length > 0) {
+      const resolve = this.waiting.shift()!;
+      this.permits--;
+      resolve();
+    }
+  }
+}
+
+// 동시 처리 제한 (최대 20개 동시 요청)
+const concurrencyLimiter = new Semaphore(20);
+
+// 데이터베이스 상태 모니터링
+async function monitorDatabaseStatus() {
+  if (!db) return;
+  
+  try {
+    const status = await DatabaseUtils.getDatabaseStatus(db);
+    log('📊 데이터베이스 상태:', {
+      journalMode: status.journalMode,
+      walAutoCheckpoint: status.walAutoCheckpoint,
+      busyTimeout: status.busyTimeout,
+      isLocked: status.isLocked ? '🔒 잠김' : '🔓 정상'
+    });
+    
+    // 락이 감지되면 WAL 체크포인트 실행
+    if (status.isLocked) {
+      log('⚠️ 데이터베이스 락 감지, WAL 체크포인트 실행...');
+      await DatabaseUtils.checkpointWAL(db);
+    }
+  } catch (error) {
+    // 데이터베이스 상태 모니터링 실패
+  }
+}
+
+// MCP 모드 감지 (stdio를 통해 실행되는지 확인)
+const isMCPMode = process.stdin.isTTY === false && process.stdout.isTTY === false;
+
+// MCP 모드에서는 로그를 stderr로 출력
+const log = isMCPMode ? console.error : console.log;
+
+// MCP 서버 초기화
+async function initializeServer() {
+  try {
+    process.stderr.write('🚀 MCP 서버 초기화 시작...\n');
+    
+    // 설정 검증
+    validateConfig();
+    process.stderr.write('✅ 설정 검증 완료\n');
+    
+    // 데이터베이스 초기화
+    db = await initializeDatabase();
+    process.stderr.write('✅ 데이터베이스 초기화 완료\n');
+    
+    // 데이터베이스 상태 모니터링
+    await monitorDatabaseStatus();
+    process.stderr.write('✅ 데이터베이스 상태 모니터링 완료\n');
+    
+    // 검색 엔진 초기화
+    searchEngine = new SearchEngine();
+    hybridSearchEngine = new HybridSearchEngine();
+    embeddingService = new MemoryEmbeddingService();
+    forgettingPolicyService = new ForgettingPolicyService();
+    performanceMonitor = new PerformanceMonitor();
+    searchCache = new SearchCacheService(1000, 300000); // 5분 TTL
+    databaseOptimizer = new DatabaseOptimizer(db);
+    errorLoggingService = new ErrorLoggingService();
+    performanceAlertService = new PerformanceAlertService('./logs');
+    // performanceMonitoringIntegration = new PerformanceMonitoringIntegration(
+    //   db,
+    //   performanceAlertService,
+    //   {
+    //     enableRealTimeMonitoring: true,
+    //     monitoringInterval: 30000, // 30초마다 체크
+    //     alertThresholds: {
+    //       responseTime: { warning: 100, critical: 500 },
+    //       memoryUsage: { warning: 100, critical: 200 },
+    //       errorRate: { warning: 5, critical: 10 },
+    //       throughput: { warning: 10, critical: 5 }
+    //     }
+    //   }
+    // );
+    
+    // 임베딩 프로바이더 정보 표시
+    process.stderr.write(`🔧 임베딩 프로바이더: ${mementoConfig.embeddingProvider.toUpperCase()}\n`);
+    if (mementoConfig.embeddingProvider === 'openai' && mementoConfig.openaiApiKey) {
+      process.stderr.write(`   📝 모델: ${mementoConfig.openaiModel} (${mementoConfig.embeddingDimensions}차원)\n`);
+    } else if (mementoConfig.embeddingProvider === 'gemini' && mementoConfig.geminiApiKey) {
+      process.stderr.write(`   📝 모델: ${mementoConfig.geminiModel} (${mementoConfig.embeddingDimensions}차원)\n`);
+    } else if (mementoConfig.embeddingProvider === 'lightweight') {
+      process.stderr.write(`   📝 모델: lightweight-hybrid (512차원)\n`);
+    }
+    
+    process.stderr.write('✅ 검색 엔진 초기화 완료\n');
+    
+    // MCP 서버 생성
+    server = new Server(
+      {
+        name: mementoConfig.serverName,
+        version: mementoConfig.serverVersion,
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {},
+          prompts: {}
+        }
+      }
+    );
+    process.stderr.write('✅ MCP 서버 생성 완료\n');
+    
+    // 도구 레지스트리 가져오기
+    const toolRegistry = getToolRegistry();
+    
+    // Tools 등록
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      process.stderr.write('📋 도구 목록 요청 처리\n');
+      const tools = toolRegistry.getAll();
+      process.stderr.write(`📋 등록된 도구 개수: ${tools.length}\n`);
+      tools.forEach(tool => {
+        process.stderr.write(`   - ${tool.name}: ${tool.description}\n`);
+      });
+      
+      return {
+        tools: tools.map(tool => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        }))
+      };
+    });
+    
+    // Tool 실행 핸들러 - 동시성 제한 적용
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      process.stderr.write(`🔧 도구 실행 요청: ${name}\n`);
+      process.stderr.write(`🔧 도구 인수: ${JSON.stringify(args)}\n`);
+      
+      // 동시성 제한 적용
+      await concurrencyLimiter.acquire();
+      
+      try {
+        // 도구 컨텍스트 생성
+        const context: ToolContext = {
+          db,
+          services: {
+            searchEngine,
+            hybridSearchEngine,
+            embeddingService,
+            forgettingPolicyService,
+            performanceMonitor,
+            databaseOptimizer,
+            errorLoggingService,
+            performanceAlertService
+            // performanceMonitoringIntegration
+          }
+        };
+        
+        process.stderr.write(`🔧 도구 실행 시작: ${name}\n`);
+        // 도구 실행
+        const toolResult = await toolRegistry.execute(name, args, context);
+        process.stderr.write(`🔧 도구 실행 완료: ${name}\n`);
+        
+        // MCP 형식으로 변환
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(toolResult)
+            }
+          ]
+        };
+      } catch (error) {
+        // 에러 로깅
+        if (errorLoggingService) {
+          errorLoggingService.logError(
+            error instanceof Error ? error : new Error(String(error)),
+            ErrorSeverity.HIGH,
+            ErrorCategory.UNKNOWN,
+            {
+              operation: 'tool_execution',
+              toolName: name,
+              requestId: `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+            }
+          );
+        }
+        
+        if (error instanceof Error) {
+          throw new Error(`Tool execution failed: ${error.message}`);
+        }
+        throw error;
+      } finally {
+        // 동시성 제한 해제
+        concurrencyLimiter.release();
+      }
+    });
+    
+    process.stderr.write('✅ MCP 서버 초기화 완료\n');
+    
+    // 실시간 성능 모니터링 시작
+    // performanceMonitoringIntegration.startRealTimeMonitoring();
+    
+    process.stderr.write('🚀 Memento MCP Server가 시작되었습니다!\n');
+    // process.stderr.write('📊 실시간 성능 모니터링이 활성화되었습니다\n');
+    
+  } catch (error) {
+    process.stderr.write(`❌ 서버 초기화 실패: ${error}\n`);
+    process.exit(1);
+  }
+}
+
+// 서버 시작
+async function startServer() {
+  try {
+    await initializeServer();
+    process.stderr.write('✅ 서버 초기화 완료\n');
+    
+    // Stdio 전송 계층 사용
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.stderr.write('✅ MCP 전송 계층 연결 완료\n');
+    
+    // MCP 클라이언트 연결 대기 중
+    process.stderr.write('🔗 MCP 클라이언트 연결 대기 중...\n');
+    
+    // 서버가 종료될 때까지 대기
+    return new Promise<void>((resolve) => {
+      process.on('SIGINT', () => {
+        process.stderr.write('👋 서버 종료 신호 수신\n');
+        cleanup().then(() => {
+          process.exit(0);
+        });
+      });
+
+      process.on('SIGTERM', () => {
+        process.stderr.write('👋 서버 종료 신호 수신\n');
+        cleanup().then(() => {
+          process.exit(0);
+        });
+      });
+    });
+  } catch (error) {
+    process.stderr.write(`❌ 서버 시작 실패: ${error}\n`);
+    process.exit(1);
+  }
+}
+
+// 정리 함수
+let isCleaningUp = false;
+
+async function cleanup() {
+  if (isCleaningUp) {
+    return; // 이미 정리 중이면 중복 실행 방지
+  }
+  
+  isCleaningUp = true;
+  
+  if (db) {
+    closeDatabase(db);
+    db = null; // 참조 제거
+  }
+  // Memento MCP Server 종료
+}
+
+// 프로세스 종료 시 정리
+process.on('SIGINT', cleanup);
+process.on('SIGTERM', cleanup);
+process.on('uncaughtException', (error) => {
+  // 예상치 못한 오류
+  cleanup();
+  process.exit(1);
+});
+
+// 서버 시작
+if (process.argv[1] && process.argv[1].endsWith('index.js')) {
+  startServer().catch(error => {
+    process.exit(1);
+  });
+}

package/src/server/simple-mcp-server.spec.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, vi } from 'vitest';
+import { AddressInfo } from 'net';
+import type { Server } from 'http';
+
+type SimpleMCPModule = typeof import('./simple-mcp-server.js');
+
+let simpleModule: SimpleMCPModule;
+let server: Server | null = null;
+let baseUrl: string;
+
+const startTestServer = async (module: SimpleMCPModule) => {
+  const httpServer = module.server;
+  await new Promise<void>((resolve) => {
+    server = httpServer.listen(0, () => {
+      const address = server!.address() as AddressInfo;
+      baseUrl = `http://127.0.0.1:${address.port}`;
+      resolve();
+    });
+  });
+};
+
+const stopTestServer = async () => {
+  if (!server) return;
+  await new Promise<void>((resolve, reject) => {
+    server!.close((err) => (err ? reject(err) : resolve()));
+  });
+  server = null;
+};
+
+const postJson = async (path: string, body: unknown) => {
+  const response = await fetch(`${baseUrl}${path}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body)
+  });
+  return { status: response.status, json: await response.json() };
+};
+
+const getJson = async (path: string) => {
+  const response = await fetch(`${baseUrl}${path}`);
+  return { status: response.status, json: await response.json() };
+};
+
+beforeAll(async () => {
+  simpleModule = await import('./simple-mcp-server.js');
+  await startTestServer(simpleModule);
+});
+
+afterAll(async () => {
+  await stopTestServer();
+});
+
+describe('Simple MCP Server', () => {
+  describe('기본 기능', () => {
+    it('헬스 체크 엔드포인트가 작동한다', async () => {
+      const response = await getJson('/health');
+      expect(response.status).toBe(200);
+      expect(response.json.status).toBe('healthy');
+      expect(response.json.server).toBe('memento-memory');
+      expect(response.json.version).toBe('0.1.0');
+      expect(response.json.tools).toBe(2); // remember, recall
+    });
+
+    it('도구 목록을 반환한다', async () => {
+      const response = await getJson('/health');
+      expect(response.json.tools).toBeGreaterThan(0);
+    });
+  });
+
+  describe('SSE 엔드포인트', () => {
+    it('SSE 스트림을 설정한다', async () => {
+      const response = await fetch(`${baseUrl}/mcp`);
+      expect(response.status).toBe(200);
+      expect(response.headers.get('content-type')).toContain('text/event-stream');
+      expect(response.headers.get('cache-control')).toContain('no-cache');
+      expect(response.headers.get('connection')).toBe('keep-alive');
+      
+      // 응답을 읽고 즉시 연결을 종료하여 타임아웃 방지
+      const reader = response.body?.getReader();
+      if (reader) {
+        const { value } = await reader.read();
+        const text = new TextDecoder().decode(value);
+        expect(text).toContain('event: endpoint');
+        expect(text).toContain('data: {"type": "ready"}');
+        expect(text).toMatch(/session_\d+_[a-z0-9]+/);
+        reader.cancel();
+      }
+    }, 10000);
+
+    it('SSE 연결 종료를 처리한다', async () => {
+      const controller = new AbortController();
+      const response = await fetch(`${baseUrl}/mcp`, {
+        signal: controller.signal
+      });
+      
+      expect(response.status).toBe(200);
+      controller.abort();
+      expect(response.ok).toBe(true);
+    });
+  });
+
+  describe('MCP 메시지 처리', () => {
+    it('initialize 요청을 처리한다', async () => {
+      const response = await postJson('/messages?sessionId=test-session', {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: {
+            name: 'test-client',
+            version: '1.0.0'
+          }
+        }
+      });
+
+      expect(response.status).toBe(200);
+      expect(response.json.status).toBe('ok');
+    });
+
+    it('notifications/initialized 요청을 처리한다', async () => {
+      const response = await postJson('/messages?sessionId=test-session', {
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'notifications/initialized'
+      });
+
+      expect(response.status).toBe(200);
+      expect(response.json.status).toBe('ok');
+    });
+
+    it('tools/list 요청을 처리한다', async () => {
+      const response = await postJson('/messages?sessionId=test-session', {
+        jsonrpc: '2.0',
+        id: 3,
+        method: 'tools/list'
+      });
+
+      expect(response.status).toBe(200);
+      expect(response.json.status).toBe('ok');
+      expect(response.json.sseData).toContain('tools');
+    });
+
+    it('알 수 없는 메서드를 처리한다', async () => {
+      const response = await postJson('/messages?sessionId=test-session', {
+        jsonrpc: '2.0',
+        id: 4,
+        method: 'unknown/method'
+      });
+
+      expect(response.status).toBe(200);
+      expect(response.json.status).toBe('ok');
+      expect(response.json.sseData).toContain('Method not found');
+    });
+  });
+
+  describe('에러 처리', () => {
+    it('세션 ID가 없으면 400을 반환한다', async () => {
+      const response = await postJson('/messages', {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize'
+      });
+
+      // simple-mcp-server는 세션 ID가 없어도 200을 반환하므로 실제 구현에 맞게 수정
+      expect(response.status).toBe(200);
+    });
+
+    it('잘못된 JSON을 처리한다', async () => {
+      const response = await fetch(`${baseUrl}/messages?sessionId=test-session`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: 'invalid json'
+      });
+
+      expect(response.status).toBe(400);
+    });
+
+    it('메시지 처리 중 에러가 발생하면 적절히 처리한다', async () => {
+      // 잘못된 메시지 구조로 에러 유발
+      const response = await postJson('/messages?sessionId=test-session', {
+        invalid: 'message'
+      });
+
+      expect(response.status).toBe(200);
+      // simple-mcp-server는 에러가 발생해도 'ok'를 반환하므로 실제 구현에 맞게 수정
+      expect(response.json.status).toBe('ok');
+    });
+  });
+
+  describe('CORS 설정', () => {
+    it('CORS 헤더가 올바르게 설정된다', async () => {
+      const response = await fetch(`${baseUrl}/health`, {
+        method: 'OPTIONS',
+        headers: {
+          'Origin': 'http://localhost:3000',
+          'Access-Control-Request-Method': 'GET'
+        }
+      });
+
+      // OPTIONS 요청은 204를 반환하는 것이 정상
+      expect(response.status).toBe(204);
+      expect(response.headers.get('access-control-allow-origin')).toBe('*');
+    });
+  });
+});