@elliotding/ai-agent-mcp 0.1.0

package/src/index.ts

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+/**
+ * CSP AI Agent MCP Server - Main Entry Point
+ */
+
+import { config } from './config';
+import { logger } from './utils/logger';
+import { startLogCleanupSchedule, stopLogCleanupSchedule } from './utils/log-cleaner';
+import { startServer, stopServer } from './server';
+import { stopCacheCleanup } from './auth/token-validator';
+import { sessionManager } from './session/manager';
+
+// Global error handlers
+process.on('uncaughtException', (error: Error) => {
+  // Handle EPIPE and ECONNRESET gracefully (client disconnected)
+  if (error.message.includes('EPIPE') || error.message.includes('ECONNRESET')) {
+    logger.debug({ 
+      error: error.message, 
+      type: 'uncaught_exception_network' 
+    }, 'Client disconnected (EPIPE/ECONNRESET)');
+    return; // Don't exit for network errors
+  }
+  
+  // For other uncaught exceptions, log and exit
+  logger.error({ error, type: 'uncaught_exception' }, `Uncaught Exception: ${error.message}`);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason: unknown, _promise: Promise<unknown>) => {
+  logger.error(
+    {
+      type: 'unhandled_rejection',
+      reason: reason instanceof Error ? reason.message : String(reason),
+      stack: reason instanceof Error ? reason.stack : undefined,
+    },
+    'Unhandled Promise Rejection'
+  );
+  process.exit(1);
+});
+
+async function main() {
+  logger.info(
+    {
+      nodeEnv: config.nodeEnv,
+      port: config.port,
+      logLevel: config.logLevel,
+    },
+    'Starting CSP AI Agent MCP Server...'
+  );
+
+  // Start log cleanup scheduler
+  const cleanupTimer = startLogCleanupSchedule();
+
+  try {
+    // Start MCP Server
+    await startServer();
+
+    logger.info({ port: config.port }, `✅ CSP AI Agent MCP Server started successfully`);
+  } catch (error) {
+    logger.error({ error }, 'Failed to start server');
+    stopLogCleanupSchedule(cleanupTimer);
+    process.exit(1);
+  }
+
+  // Graceful shutdown handlers
+  let isShuttingDown = false;
+  const SHUTDOWN_TIMEOUT = Number(process.env.SHUTDOWN_TIMEOUT) || 30000; // 30 seconds default
+
+  const shutdown = async (signal: string) => {
+    // Prevent multiple shutdown attempts
+    if (isShuttingDown) {
+      logger.warn({ signal }, 'Shutdown already in progress, ignoring signal');
+      return;
+    }
+    isShuttingDown = true;
+
+    logger.info({ signal, timeout: SHUTDOWN_TIMEOUT }, `Received ${signal}, starting graceful shutdown...`);
+
+    // Set timeout for forced shutdown
+    const shutdownTimer = setTimeout(() => {
+      logger.error(
+        { timeout: SHUTDOWN_TIMEOUT },
+        `Graceful shutdown timeout (${SHUTDOWN_TIMEOUT}ms), forcing exit`
+      );
+      process.exit(1);
+    }, SHUTDOWN_TIMEOUT);
+
+    try {
+      // Phase 1: Stop accepting new requests
+      logger.info('Phase 1: Stopping new requests...');
+
+      // Phase 2: Wait for ongoing requests to complete
+      logger.info('Phase 2: Waiting for ongoing requests to complete...');
+
+      // Stop MCP Server (this will close all active sessions and connections)
+      await stopServer();
+
+      // Phase 3: Stop background tasks
+      logger.info('Phase 3: Stopping background tasks...');
+
+      // Stop log cleanup
+      stopLogCleanupSchedule(cleanupTimer);
+      
+      // Stop session cleanup
+      sessionManager.stopCleanup();
+      logger.info('Session cleanup stopped');
+      
+      // Stop token cache cleanup
+      stopCacheCleanup();
+      logger.info('Token cache cleanup stopped');
+
+      // Phase 4: Flush logs
+      logger.info('Phase 4: Flushing logs...');
+      
+      // Give logger time to flush
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      // Clear shutdown timeout
+      clearTimeout(shutdownTimer);
+
+      logger.info('✅ Graceful shutdown completed successfully');
+      process.exit(0);
+    } catch (error) {
+      logger.error({ error }, 'Error during graceful shutdown');
+      clearTimeout(shutdownTimer);
+      process.exit(1);
+    }
+  };
+
+  process.on('SIGINT', () => void shutdown('SIGINT'));
+  process.on('SIGTERM', () => void shutdown('SIGTERM'));
+}
+
+// Start the application
+void main().catch((error: unknown) => {
+  logger.error({ error }, 'Fatal error during startup');
+  process.exit(1);
+});

package/src/monitoring/health.ts

@@ -0,0 +1,132 @@
+import { CacheManager } from '../cache/cache-manager.js';
+
+export interface HealthStatus {
+  status: 'healthy' | 'unhealthy';
+  timestamp: string;
+  services: {
+    http: 'up' | 'down';
+    redis: 'up' | 'down' | 'not_configured';
+    cache: 'healthy' | 'degraded' | 'down';
+  };
+  details?: {
+    redisError?: string;
+    cacheError?: string;
+  };
+}
+
+export class HealthChecker {
+  private cacheManager: CacheManager | null = null;
+
+  constructor(cacheManager?: CacheManager) {
+    this.cacheManager = cacheManager || null;
+  }
+
+  /**
+   * Check HTTP Server health
+   */
+  private checkHttpServer(): 'up' | 'down' {
+    // HTTP server is up if this code is running
+    return 'up';
+  }
+
+  /**
+   * Check Redis connection health
+   */
+  private async checkRedis(): Promise<{ status: 'up' | 'down' | 'not_configured'; error?: string }> {
+    if (!this.cacheManager) {
+      return { status: 'not_configured' };
+    }
+
+    try {
+      // Try to check Redis connection via cache manager
+      const redisCache = (this.cacheManager as any).l2Cache;
+      
+      if (!redisCache) {
+        return { status: 'not_configured' };
+      }
+
+      // Try a simple Redis operation (check client status)
+      const client = (redisCache as any).client;
+      
+      if (!client || !client.isReady) {
+        return { status: 'down', error: 'Redis client not ready' };
+      }
+
+      // Try a ping operation
+      await client.ping();
+      return { status: 'up' };
+    } catch (error) {
+      return {
+        status: 'down',
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  /**
+   * Check Cache health
+   */
+  private checkCache(): { status: 'healthy' | 'degraded' | 'down'; error?: string } {
+    if (!this.cacheManager) {
+      return { status: 'down', error: 'Cache manager not initialized' };
+    }
+
+    try {
+      // Check if cache manager is functional
+      const stats = this.cacheManager.getStats();
+      
+      // Cache is healthy if stats are available
+      if (stats && typeof stats.hitRate === 'number') {
+        // Check if hit rate is reasonable (> 0 means cache is working)
+        if (stats.hitRate >= 0) {
+          return { status: 'healthy' };
+        }
+        return { status: 'degraded', error: 'Low cache hit rate' };
+      }
+
+      return { status: 'degraded', error: 'Cache stats unavailable' };
+    } catch (error) {
+      return {
+        status: 'down',
+        error: error instanceof Error ? error.message : 'Unknown error'
+      };
+    }
+  }
+
+  /**
+   * Perform comprehensive health check
+   */
+  async check(): Promise<HealthStatus> {
+    const httpStatus = this.checkHttpServer();
+    const redisResult = await this.checkRedis();
+    const cacheResult = this.checkCache();
+
+    const allHealthy = 
+      httpStatus === 'up' &&
+      (redisResult.status === 'up' || redisResult.status === 'not_configured') &&
+      cacheResult.status === 'healthy';
+
+    const health: HealthStatus = {
+      status: allHealthy ? 'healthy' : 'unhealthy',
+      timestamp: new Date().toISOString(),
+      services: {
+        http: httpStatus,
+        redis: redisResult.status,
+        cache: cacheResult.status
+      }
+    };
+
+    // Add error details if any
+    if (redisResult.error || cacheResult.error) {
+      health.details = {};
+      if (redisResult.error) {
+        health.details.redisError = redisResult.error;
+      }
+      if (cacheResult.error) {
+        health.details.cacheError = cacheResult.error;
+      }
+    }
+
+    return health;
+  }
+}

package/src/resources/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Resources Module Exports
+ */
+
+export { ResourceLoader, resourceLoader } from './loader';
+export type {
+  AIResourcesConfig,
+  ResourceMetadata,
+  ResourceType,
+  ResourceSource,
+  ResourceConflict,
+  LoaderStats,
+} from '../types/resources';