Complete Guide to SSE Endpoint of Your MCP Server: Implementation & Best Practices

const express = require('express');
const cors = require('cors');
const app = express();

// Enable CORS for SSE endpoint
app.use(cors({
    origin: process.env.ALLOWED_ORIGINS?.split(',') || '*',
    credentials: true
}));

// SSE endpoint configuration
app.get('/api/mcp/sse', (req, res) => {
    // Set SSE headers
    res.setHeader('Content-Type', 'text/event-stream');
    res.setHeader('Cache-Control', 'no-cache');
    res.setHeader('Connection', 'keep-alive');
    res.setHeader('X-Accel-Buffering', 'no'); // Disable buffering in nginx
    
    // Authentication check
    const token = req.headers.authorization?.replace('Bearer ', '');
    if (!authenticateToken(token)) {
        res.status(401).json({ error: 'Unauthorized' });
        return;
    }
    
    // Send initial connection message
    res.write('data: {"type":"connected","timestamp":"' + Date.now() + '"}\n\n');
    
    // Heartbeat to keep connection alive
    const heartbeatInterval = setInterval(() => {
        res.write(':heartbeat\n\n');
    }, 15000);
    
    // Handle client disconnect
    req.on('close', () => {
        clearInterval(heartbeatInterval);
        console.log('Client disconnected from SSE endpoint');
    });
    
    // Store connection for broadcasting events
    activeConnections.set(req.connection.remoteAddress, res);
});

function authenticateToken(token) {
    // Implement your authentication logic
    return token && token === process.env.MCP_API_KEY;
}

const activeConnections = new Map();

app.listen(3000, () => {
    console.log('MCP SSE Server running on port 3000');
});

class MCPToolsHandler {
    constructor(sseConnections) {
        this.connections = sseConnections;
        this.tools = new Map();
        this.initializeTools();
    }
    
    initializeTools() {
        // Register your MCP tools
        this.tools.set('code_analysis', this.analyzeCode.bind(this));
        this.tools.set('data_transform', this.transformData.bind(this));
        this.tools.set('file_processor', this.processFile.bind(this));
    }
    
    async executeTool(toolName, params, connectionId) {
        const tool = this.tools.get(toolName);
        
        if (!tool) {
            this.sendError(connectionId, `Tool ${toolName} not found`);
            return;
        }
        
        try {
            // Send execution start event
            this.sendEvent(connectionId, {
                type: 'tool_execution_start',
                tool: toolName,
                timestamp: Date.now()
            });
            
            // Execute tool with streaming updates
            const result = await tool(params, (progress) => {
                this.sendEvent(connectionId, {
                    type: 'tool_progress',
                    tool: toolName,
                    progress: progress,
                    timestamp: Date.now()
                });
            });
            
            // Send completion event
            this.sendEvent(connectionId, {
                type: 'tool_execution_complete',
                tool: toolName,
                result: result,
                timestamp: Date.now()
            });
            
        } catch (error) {
            this.sendError(connectionId, error.message, toolName);
        }
    }
    
    async analyzeCode(params, progressCallback) {
        // Example tool implementation
        progressCallback({ stage: 'parsing', percent: 20 });
        
        // Simulate code analysis
        await new Promise(resolve => setTimeout(resolve, 1000));
        progressCallback({ stage: 'analyzing', percent: 60 });
        
        await new Promise(resolve => setTimeout(resolve, 1000));
        progressCallback({ stage: 'generating_report', percent: 90 });
        
        return {
            complexity: 'medium',
            issues: [],
            suggestions: ['Consider adding error handling']
        };
    }
    
    async transformData(params, progressCallback) {
        // Data transformation logic
        progressCallback({ stage: 'loading', percent: 25 });
        // ... transformation code
        return { transformed: true, records: 1500 };
    }
    
    async processFile(params, progressCallback) {
        // File processing logic
        progressCallback({ stage: 'reading', percent: 30 });
        // ... processing code
        return { status: 'processed', size: 2048 };
    }
    
    sendEvent(connectionId, data) {
        const connection = this.connections.get(connectionId);
        if (connection) {
            connection.write(`data: ${JSON.stringify(data)}\n\n`);
        }
    }
    
    sendError(connectionId, message, tool = null) {
        this.sendEvent(connectionId, {
            type: 'error',
            tool: tool,
            message: message,
            timestamp: Date.now()
        });
    }
}

module.exports = MCPToolsHandler;

const jwt = require('jsonwebtoken');
const rateLimit = require('express-rate-limit');

class SSEAuthMiddleware {
    constructor(config) {
        this.jwtSecret = config.jwtSecret;
        this.apiKeys = new Set(config.apiKeys || []);
        this.rateLimiter = this.createRateLimiter();
    }
    
    createRateLimiter() {
        return rateLimit({
            windowMs: 15 * 60 * 1000, // 15 minutes
            max: 100, // Limit each IP to 100 requests per window
            message: 'Too many requests from this IP',
            standardHeaders: true,
            legacyHeaders: false,
        });
    }
    
    authenticate(req, res, next) {
        // Extract token from various sources
        const token = this.extractToken(req);
        
        if (!token) {
            return res.status(401).json({ 
                error: 'Authentication required',
                message: 'No valid authentication token provided'
            });
        }
        
        // Try JWT authentication first
        if (token.startsWith('eyJ')) {
            return this.verifyJWT(token, req, res, next);
        }
        
        // Fall back to API key authentication
        if (this.apiKeys.has(token)) {
req.authenticated = true;
            req.authMethod = 'api_key';
            return next();
        }
        
        return res.status(401).json({ 
            error: 'Invalid authentication credentials' 
        });
    }
    
    extractToken(req) {
        // Check Authorization header
        const authHeader = req.headers.authorization;
        if (authHeader) {
            return authHeader.replace('Bearer ', '');
        }
        
        // Check query parameter
        if (req.query.token) {
            return req.query.token;
        }
        
        // Check custom header
        if (req.headers['x-api-key']) {
            return req.headers['x-api-key'];
        }
        
        return null;
    }
    
    verifyJWT(token, req, res, next) {
        try {
            const decoded = jwt.verify(token, this.jwtSecret);
            
            // Check token expiration
            if (decoded.exp && decoded.exp < Date.now() / 1000) {
                return res.status(401).json({ 
                    error: 'Token expired' 
                });
            }
            
            // Attach user info to request
            req.user = decoded;
            req.authenticated = true;
            req.authMethod = 'jwt';
            
            next();
        } catch (error) {
            return res.status(401).json({ 
                error: 'Invalid JWT token',
                details: error.message 
            });
        }
    }
    
    // Authorization check for specific tools
    authorizeToolAccess(toolName, user) {
        const toolPermissions = {
            'code_analysis': ['admin', 'developer'],
            'data_transform': ['admin', 'developer', 'analyst'],
            'file_processor': ['admin']
        };
        
        const requiredRoles = toolPermissions[toolName] || [];
        return requiredRoles.includes(user.role);
    }
}

module.exports = SSEAuthMiddleware;

const helmet = require('helmet');

class SecurityConfig {
    static applySecurityHeaders(app) {
        // Apply Helmet with custom configurations
        app.use(helmet({
            contentSecurityPolicy: {
                directives: {
                    defaultSrc: ["'self'"],
                    connectSrc: ["'self'", process.env.ALLOWED_DOMAINS],
                }
            },
            hsts: {
                maxAge: 31536000,
                includeSubDomains: true,
                preload: true
            }
        }));
        
        // Custom CORS middleware for SSE
        app.use('/api/mcp/sse', (req, res, next) => {
            const origin = req.headers.origin;
            const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(',') || [];
            
            if (allowedOrigins.includes(origin) || allowedOrigins.includes('*')) {
                res.setHeader('Access-Control-Allow-Origin', origin);
                res.setHeader('Access-Control-Allow-Credentials', 'true');
                res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
                res.setHeader('Access-Control-Allow-Headers', 
                    'Authorization, Content-Type, X-API-Key');
            }
            
            if (req.method === 'OPTIONS') {
                return res.status(200).end();
            }
            
            next();
        });
    }
    
    static configureConnectionLimits(app) {
        const connectionTracker = new Map();
        const MAX_CONNECTIONS_PER_IP = 5;
        
        app.use('/api/mcp/sse', (req, res, next) => {
            const clientIP = req.ip || req.connection.remoteAddress;
            const currentConnections = connectionTracker.get(clientIP) || 0;
            
            if (currentConnections >= MAX_CONNECTIONS_PER_IP) {
                return res.status(429).json({ 
                    error: 'Connection limit exceeded',
                    message: `Maximum ${MAX_CONNECTIONS_PER_IP} concurrent connections allowed`
                });
            }
            
            connectionTracker.set(clientIP, currentConnections + 1);
            
            req.on('close', () => {
                const count = connectionTracker.get(clientIP);
                if (count <= 1) {
                    connectionTracker.delete(clientIP);
                } else {
                    connectionTracker.set(clientIP, count - 1);
                }
            });
            
            next();
        });
    }
    
    static enforceHTTPS(app) {
        app.use((req, res, next) => {
            if (process.env.NODE_ENV === 'production' && 
                !req.secure && 
                req.get('x-forwarded-proto') !== 'https') {
                return res.redirect(301, `https://${req.get('host')}${req.url}`);
            }
            next();
        });
    }
}

module.exports = SecurityConfig;

class SSEConnectionManager {
    constructor(options = {}) {
        this.connections = new Map();
        this.connectionsByUser = new Map();
        this.maxConnectionsPerUser = options.maxConnectionsPerUser || 3;
        this.connectionTimeout = options.connectionTimeout || 60000;
        this.heartbeatInterval = options.heartbeatInterval || 15000;
        this.compressionEnabled = options.compression || true;
        
        this.startCleanupTask();
    }
    
    addConnection(connectionId, userId, response) {
        // Check user connection limit
        const userConnections = this.connectionsByUser.get(userId) || new Set();
        
        if (userConnections.size >= this.maxConnectionsPerUser) {
            // Close oldest connection
            const oldestConnection = Array.from(userConnections)[0];
            this.removeConnection(oldestConnection);
        }
        
        const connection = {
            id: connectionId,
            userId: userId,
            response: response,
            createdAt: Date.now(),
            lastActivity: Date.now(),
            messageCount: 0,
            heartbeatTimer: null
        };
        
        this.connections.set(connectionId, connection);
        userConnections.add(connectionId);
        this.connectionsByUser.set(userId, userConnections);
        
        // Start heartbeat
        this.startHeartbeat(connectionId);
        
        return connection;
    }
    
    removeConnection(connectionId) {
        const connection = this.connections.get(connectionId);
        
        if (!connection) return;
        
        // Clear heartbeat
        if (connection.heartbeatTimer) {
            clearInterval(connection.heartbeatTimer);
        }
        
        // Remove from user connections
        const userConnections = this.connectionsByUser.get(connection.userId);
        if (userConnections) {
            userConnections.delete(connectionId);
            if (userConnections.size === 0) {
                this.connectionsByUser.delete(connection.userId);
            }
        }
        
        // Close response stream
        try {
            connection.response.end();
        } catch (error) {
            console.error('Error closing connection:', error);
        }
        
        this.connections.delete(connectionId);
    }
    
    startHeartbeat(connectionId) {
        const connection = this.connections.get(connectionId);
        if (!connection) return;
        
        connection.heartbeatTimer = setInterval(() => {
            this.sendHeartbeat(connectionId);
            
            // Check for inactive connections
            const inactiveTime = Date.now() - connection.lastActivity;
            if (inactiveTime > this.connectionTimeout) {
                console.log(`Connection ${connectionId} timed out`);
                this.removeConnection(connectionId);
            }
        }, this.heartbeatInterval);
    }
    
    sendHeartbeat(connectionId) {
        const connection = this.connections.get(connectionId);
        if (!connection) return;
        
        try {
            connection.response.write(':heartbeat\n\n');
            connection.lastActivity = Date.now();
        } catch (error) {
            console.error('Heartbeat failed, removing connection:', error);
            this.removeConnection(connectionId);
        }
    }
    
    broadcast(event, data, filter = null) {
        let sentCount = 0;
        
        for (const [connectionId, connection] of this.connections.entries()) {
            // Apply filter if provided
            if (filter && !filter(connection)) {
                continue;
            }
            
            this.sendToConnection(connectionId, event, data);
            sentCount++;
        }
        
        return sentCount;
    }
    
    sendToConnection(connectionId, event, data) {
        const connection = this.connections.get(connectionId);
        if (!connection) return false;
        
        try {
            const payload = this.formatSSEMessage(event, data);
            connection.response.write(payload);
            connection.messageCount++;
            connection.lastActivity = Date.now();
            return true;
        } catch (error) {
            console.error(`Failed to send to connection ${connectionId}:`, error);
            this.removeConnection(connectionId);
            return false;
        }
    }
    
    sendToUser(userId, event, data) {
        const userConnections = this.connectionsByUser.get(userId);
        if (!userConnections) return 0;
        
        let sentCount = 0;
        for (const connectionId of userConnections) {
            if (this.sendToConnection(connectionId, event, data)) {
                sentCount++;
            }
        }
        
        return sentCount;
    }
    
    formatSSEMessage(event, data) {
        let message = '';
        
        if (event) {
            message += `event: ${event}\n`;
        }
        
        const dataStr = typeof data === 'string' ? 
            data : JSON.stringify(data);
        
        // Split data into multiple lines if needed
        const lines = dataStr.split('\n');
        lines.forEach(line => {
            message += `data: ${line}\n`;
        });
        
        message += '\n';
        return message;
    }
    
    startCleanupTask() {
        setInterval(() => {
            const now = Date.now();
            const staleConnections = [];
            
            for (const [connectionId, connection] of this.connections.entries()) {
                if (now - connection.lastActivity > this.connectionTimeout) {
                    staleConnections.push(connectionId);
                }
            }
            
            staleConnections.forEach(id => this.removeConnection(id));
            
            if (staleConnections.length > 0) {
                console.log(`Cleaned up ${staleConnections.length} stale connections`);
            }
        }, 30000); // Run cleanup every 30 seconds
    }
    
    getStats() {
        return {
            totalConnections: this.connections.size,
            totalUsers: this.connectionsByUser.size,
            averageMessagesPerConnection: this.getAverageMessages(),
            oldestConnection: this.getOldestConnectionAge()
        };
    }
    
    getAverageMessages() {
        if (this.connections.size === 0) return 0;
        
        const totalMessages = Array.from(this.connections.values())
            .reduce((sum, conn) => sum + conn.messageCount, 0);
        
        return Math.round(totalMessages / this.connections.size);
    }
    
    getOldestConnectionAge() {
        if (this.connections.size === 0) return 0;
        
        const oldest = Math.min(...Array.from(this.connections.values())
            .map(conn => conn.createdAt));
        
        return Math.floor((Date.now() - oldest) / 1000);
    }
}

module.exports = SSEConnectionManager;

const zlib = require('zlib');

class MessageOptimizer {
    constructor(options = {}) {
        this.batchSize = options.batchSize || 10;
        this.batchTimeout = options.batchTimeout || 100;
        this.compressionThreshold = options.compressionThreshold || 1024;
        this.batches = new Map();
    }
    
    queueMessage(connectionId, event, data) {
        if (!this.batches.has(connectionId)) {
            this.batches.set(connectionId, {
                messages: [],
                timer: null
            });
        }
        
        const batch = this.batches.get(connectionId);
        batch.messages.push({ event, data, timestamp: Date.now() });
        
        // Send immediately if batch is full
        if (batch.messages.length >= this.batchSize) {
            this.flushBatch(connectionId);
            return;
        }
        
        // Set timeout to send batch
        if (!batch.timer) {
            batch.timer = setTimeout(() => {
                this.flushBatch(connectionId);
            }, this.batchTimeout);
        }
    }
    
    flushBatch(connectionId) {
        const batch = this.batches.get(connectionId);
        if (!batch || batch.messages.length === 0) return null;
        
        // Clear timeout
        if (batch.timer) {
            clearTimeout(batch.timer);
            batch.timer = null;
        }
        
        const messages = batch.messages.splice(0);
        const payload = this.createBatchPayload(messages);
        
        return payload;
    }
    
    createBatchPayload(messages) {
        if (messages.length === 1) {
            return {
                event: messages[0].event,
                data: messages[0].data,
                batched: false
            };
        }
        
        return {
            event: 'batch',
            data: {
                count: messages.length,
                messages: messages
            },
            batched: true
        };
    }
    
    async compressData(data) {
        const jsonData = JSON.stringify(data);
        
        // Only compress if data exceeds threshold
        if (jsonData.length < this.compressionThreshold) {
            return {
                data: jsonData,
                compressed: false,
                originalSize: jsonData.length
            };
        }
        
        return new Promise((resolve, reject) => {
            zlib.gzip(Buffer.from(jsonData), (error, compressed) => {
                if (error) {
                    reject(error);
                    return;
                }
                
                resolve({
                    data: compressed.toString('base64'),
                    compressed: true,
                    originalSize: jsonData.length,
                    compressedSize: compressed.length,
                    ratio: (compressed.length / jsonData.length * 100).toFixed(2)
                });
            });
        });
    }
    
    prioritizeMessages(messages) {
        // Priority levels: critical > high > normal > low
        const priorityOrder = { critical: 0, high: 1, normal: 2, low: 3 };
        
        return messages.sort((a, b) => {
            const priorityA = priorityOrder[a.priority || 'normal'];
            const priorityB = priorityOrder[b.priority || 'normal'];
            
            if (priorityA !== priorityB) {
                return priorityA - priorityB;
            }
            
            // Sort by timestamp if same priority
            return a.timestamp - b.timestamp;
        });
    }
    
    filterDuplicates(messages, dedupeKey = 'id') {
        const seen = new Set();
        return messages.filter(msg => {
            const key = msg.data?.[dedupeKey] || msg.timestamp;
            if (seen.has(key)) {
                return false;
            }
            seen.add(key);
            return true;
        });
    }
}

module.exports = MessageOptimizer;

class MCPSSEClient {
    constructor(endpoint, options = {}) {
        this.endpoint = endpoint;
        this.token = options.token;
        this.reconnectDelay = options.reconnectDelay || 1000;
        this.maxReconnectDelay = options.maxReconnectDelay || 30000;
        this.reconnectAttempts = 0;
        this.eventSource = null;
        this.eventHandlers = new Map();
        this.connectionState = 'disconnected';
        this.connectionId = null;
    }
    
    connect() {
        if (this.connectionState === 'connected' || 
            this.connectionState === 'connecting') {
            return;
        }
        
        this.connectionState = 'connecting';
        
        // Construct URL with authentication
        const url = new URL(this.endpoint);
        if (this.token) {
            url.searchParams.append('token', this.token);
        }
        
        try {
            this.eventSource = new EventSource(url.toString());
            
            this.eventSource.onopen = () => {
                console.log('SSE connection established');
                this.connectionState = 'connected';
                this.reconnectAttempts = 0;
                this.reconnectDelay = 1000;
                this.emit('connected');
            };
            
            this.eventSource.onerror = (error) => {
                console.error('SSE connection error:', error);
                this.connectionState = 'disconnected';
                this.emit('error', error);
                this.handleReconnect();
            };
            
            this.eventSource.onmessage = (event) => {
                this.handleMessage(event);
            };
            
            // Register custom event listeners
            this.registerEventListeners();
            
        } catch (error) {
            console.error('Failed to create EventSource:', error);
            this.handleReconnect();
        }
    }
    
    disconnect() {
        if (this.eventSource) {
            this.eventSource.close();
            this.eventSource = null;
        }
        this.connectionState = 'disconnected';
        this.emit('disconnected');
    }
    
    handleReconnect() {
        if (this.eventSource) {
            this.eventSource.close();
        }
        
        this.reconnectAttempts++;
        
        // Calculate delay with exponential backoff
        const delay = Math.min(
            this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
            this.maxReconnectDelay
        );
        
        console.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
        
        setTimeout(() => {
            this.connect();
        }, delay);
    }
    
    registerEventListeners() {
        // Listen for specific event types
        const eventTypes = [
            'connected', 'tool_execution_start', 'tool_progress',
            'tool_execution_complete', 'error', 'batch'
        ];
        
        eventTypes.forEach(type => {
            this.eventSource.addEventListener(type, (event) => {
                this.handleTypedEvent(type, event);
            });
        });
    }
    
    handleMessage(event) {
        try {
            const data = JSON.parse(event.data);
            
            // Handle connection ID
            if (data.type === 'connected') {
                this.connectionId = data.connectionId;
            }
            
            // Handle batched messages
            if (data.type === 'batch') {
                data.messages.forEach(msg => {
                    this.emit(msg.event, msg.data);
                });
                return;
            }
            
            this.emit('message', data);
            
            if (data.type) {
                this.emit(data.type, data);
            }
            
        } catch (error) {
            console.error('Failed to parse message:', error);
        }
    }
    
    handleTypedEvent(type, event) {
        try {
            const data = JSON.parse(event.data);
            this.emit(type, data);
        } catch (error) {
            console.error(`Failed to parse ${type} event:`, error);
        }
    }
    
    on(event, handler) {
        if (!this.eventHandlers.has(event)) {
            this.eventHandlers.set(event, []);
        }
        this.eventHandlers.get(event).push(handler);
        
        return () => this.off(event, handler);
    }
    
    off(event, handler) {
        const handlers = this.eventHandlers.get(event);
        if (!handlers) return;
        
        const index = handlers.indexOf(handler);
        if (index > -1) {
            handlers.splice(index, 1);
        }
    }
    
    emit(event, data) {
        const handlers = this.eventHandlers.get(event);
        if (!handlers) return;
        
        handlers.forEach(handler => {
            try {
                handler(data);
            } catch (error) {
                console.error(`Error in ${event} handler:`, error);
            }
        });
    }
    
    async invokeTool(toolName, params) {
        if (this.connectionState !== 'connected') {
            throw new Error('Not connected to SSE endpoint');
        }
        
        // Send tool invocation request via separate API call
        // (SSE is one-way, so we need HTTP POST for requests)
        const response = await fetch(`${this.endpoint}/invoke`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${this.token}`,
                'X-Connection-ID': this.connectionId
            },
            body: JSON.stringify({
                tool: toolName,
                params: params
            })
        });
        
        if (!response.ok) {
            throw new Error(`Tool invocation failed: ${response.statusText}`);
        }
        
        return response.json();
    }
    
    getConnectionState() {
        return {
            state: this.connectionState,
            connectionId: this.connectionId,
            reconnectAttempts: this.reconnectAttempts
        };
    }
}

// Example usage
const client = new MCPSSEClient('https://api.example.com/mcp/sse', {
    token: 'your-auth-token'
});

client.on('connected', () => {
    console.log('Connected to MCP server');
});

client.on('tool_progress', (data) => {
    console.log(`Tool progress: ${data.progress.percent}%`);
});

client.on('tool_execution_complete', (data) => {
    console.log('Tool execution completed:', data.result);
});

client.connect();

const winston = require('winston');
const prometheus = require('prom-client');

class SSEMonitoring {
    constructor() {
        this.setupLogger();
        this.setupMetrics();
        this.connectionMetrics = new Map();
    }
    
    setupLogger() {
        this.logger = winston.createLogger({
            level: process.env.LOG_LEVEL || 'info',
            format: winston.format.combine(
                winston.format.timestamp(),
                winston.format.errors({ stack: true }),
                winston.format.json()
            ),
            transports: [
                new winston.transports.File({ 
                    filename: 'logs/sse-error.log', 
                    level: 'error' 
                }),
                new winston.transports.File({ 
                    filename: 'logs/sse-combined.log' 
                }),
                new winston.transports.Console({
                    format: winston.format.combine(
                        winston.format.colorize(),
                        winston.format.simple()
                    )
                })
            ]
        });
    }
    
    setupMetrics() {
        // Register Prometheus metrics
        this.register = new prometheus.Registry();
        
        this.metrics = {
            activeConnections: new prometheus.Gauge({
                name: 'sse_active_connections',
                help: 'Number of active SSE connections',
                registers: [this.register]
            }),
            
            totalMessages: new prometheus.Counter({
                name: 'sse_messages_total',
                help: 'Total number of SSE messages sent',
                labelNames: ['event_type'],
                registers: [this.register]
            }),
            
            messageLatency: new prometheus.Histogram({
                name: 'sse_message_latency_ms',
                help: 'Message processing latency in milliseconds',
                buckets: [1, 5, 10, 50, 100, 500, 1000],
                registers: [this.register]
            }),
            
            connectionDuration: new prometheus.Histogram({
                name: 'sse_connection_duration_seconds',
                help: 'Connection duration in seconds',
                buckets: [10, 30, 60, 300, 600, 1800, 3600],
                registers: [this.register]
            }),
            
            errors: new prometheus.Counter({
                name: 'sse_errors_total',
                help: 'Total number of SSE errors',
                labelNames: ['error_type'],
                registers: [this.register]
            })
        };
        
        // Add default metrics
        prometheus.collectDefaultMetrics({ register: this.register });
    }
    
    logConnectionStart(connectionId, userId, metadata = {}) {
        this.logger.info('SSE connection established', {
            event: 'connection_start',
            connectionId,
            userId,
            ...metadata
        });
        
        this.connectionMetrics.set(connectionId, {
            startTime: Date.now(),
            messageCount: 0,
            lastActivity: Date.now()
        });
        
        this.metrics.activeConnections.inc();
    }
    
    logConnectionEnd(connectionId, reason = 'client_disconnect') {
        const connMetrics = this.connectionMetrics.get(connectionId);
        
        if (connMetrics) {
            const duration = (Date.now() - connMetrics.startTime) / 1000;
            
            this.logger.info('SSE connection closed', {
                event: 'connection_end',
                connectionId,
                reason,
                duration,
                messageCount: connMetrics.messageCount
            });
            
            this.metrics.connectionDuration.observe(duration);
            this.connectionMetrics.delete(connectionId);
        }
        
        this.metrics.activeConnections.dec();
    }
    
    logMessage(connectionId, eventType, size) {
        const connMetrics = this.connectionMetrics.get(connectionId);
        
        if (connMetrics) {
            connMetrics.messageCount++;
            connMetrics.lastActivity = Date.now();
        }
        
        this.metrics.totalMessages.inc({ event_type: eventType });
        
        this.logger.debug('SSE message sent', {
            event: 'message_sent',
            connectionId,
            eventType,size
        });
    }
    
    trackLatency(operation, startTime) {
        const latency = Date.now() - startTime;
        this.metrics.messageLatency.observe(latency);
        
        if (latency > 100) {
            this.logger.warn('High message latency detected', {
                event: 'high_latency',
                operation,
                latency
            });
        }
    }
    
    logError(error, context = {}) {
        this.logger.error('SSE error occurred', {
            event: 'error',
            error: error.message,
            stack: error.stack,
            ...context
        });
        
        this.metrics.errors.inc({ 
            error_type: error.name || 'unknown' 
        });
    }
    
    getHealthStatus() {
        const activeConns = this.connectionMetrics.size;
        const staleConnections = Array.from(this.connectionMetrics.values())
            .filter(m => Date.now() - m.lastActivity > 60000).length;
        
        return {
            status: activeConns > 0 ? 'healthy' : 'idle',
            activeConnections: activeConns,
            staleConnections: staleConnections,
            uptime: process.uptime(),
            memory: process.memoryUsage(),
            timestamp: Date.now()
        };
    }
    
    async generateReport() {
        const metrics = await this.register.metrics();
        const health = this.getHealthStatus();
        
        return {
            metrics: metrics,
            health: health,
            connections: Array.from(this.connectionMetrics.entries()).map(([id, data]) => ({
                id,
                uptime: Math.floor((Date.now() - data.startTime) / 1000),
                messages: data.messageCount,
                lastActivity: Math.floor((Date.now() - data.lastActivity) / 1000)
            }))
        };
    }
    
    // Expose metrics endpoint for Prometheus
    getMetricsHandler() {
        return async (req, res) => {
            res.setHeader('Content-Type', this.register.contentType);
            const metrics = await this.register.metrics();
            res.send(metrics);
        };
    }
}

module.exports = SSEMonitoring;

class CodeAnalysisService {
    constructor(sseManager, toolsHandler) {
        this.sseManager = sseManager;
        this.toolsHandler = toolsHandler;
    }
    
    async analyzeCode(connectionId, userId, codePayload) {
        const analysisId = this.generateAnalysisId();
        
        try {
            // Send initial acknowledgment
            this.sseManager.sendToConnection(connectionId, 'analysis_started', {
                analysisId: analysisId,
                timestamp: Date.now(),
                estimatedDuration: 30000
            });
            
            // Run syntax analysis
            await this.runPhase(connectionId, analysisId, 'syntax', async () => {
                return await this.toolsHandler.executeTool('syntax_checker', {
                    code: codePayload.code,
                    language: codePayload.language
                });
            });
            
            // Run security scan
            await this.runPhase(connectionId, analysisId, 'security', async () => {
                return await this.toolsHandler.executeTool('security_scanner', {
                    code: codePayload.code,
                    rules: ['sql-injection', 'xss', 'path-traversal']
                });
            });
            
            // Run complexity analysis
            await this.runPhase(connectionId, analysisId, 'complexity', async () => {
                return await this.toolsHandler.executeTool('complexity_analyzer', {
                    code: codePayload.code
                });
            });
            
            // Run performance suggestions
            await this.runPhase(connectionId, analysisId, 'performance', async () => {
                return await this.toolsHandler.executeTool('performance_advisor', {
                    code: codePayload.code,
                    context: codePayload.context
                });
            });
            
            // Send completion summary
            this.sseManager.sendToConnection(connectionId, 'analysis_complete', {
                analysisId: analysisId,
                timestamp: Date.now(),
                summary: {
                    totalIssues: this.calculateTotalIssues(),
                    criticalCount: this.getCriticalCount(),
                    overallScore: this.calculateScore()
                }
            });
            
        } catch (error) {
            this.sseManager.sendToConnection(connectionId, 'analysis_error', {
                analysisId: analysisId,
                error: error.message
            });
        }
    }
    
    async runPhase(connectionId, analysisId, phaseName, analysisFn) {
        // Send phase start event
        this.sseManager.sendToConnection(connectionId, 'phase_started', {
            analysisId: analysisId,
            phase: phaseName,
            timestamp: Date.now()
        });
        
        const startTime = Date.now();
        
        try {
            const result = await analysisFn();
            
            // Send phase results as they come in
            this.sseManager.sendToConnection(connectionId, 'phase_result', {
                analysisId: analysisId,
                phase: phaseName,
                result: result,
                duration: Date.now() - startTime
            });
            
            return result;
            
        } catch (error) {
            this.sseManager.sendToConnection(connectionId, 'phase_error', {
                analysisId: analysisId,
                phase: phaseName,
                error: error.message
            });
            throw error;
        }
    }
    
    generateAnalysisId() {
        return `analysis_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    }
    
    calculateTotalIssues() {
        // Implementation for calculating total issues
        return 0;
    }
    
    getCriticalCount() {
        // Implementation for critical issue count
        return 0;
    }
    
    calculateScore() {
        // Implementation for overall code quality score
        return 85;
    }
}

module.exports = CodeAnalysisService;

# Multi-stage build for optimized image
FROM node:18-alpine AS builder

WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application code
COPY . .

# Production stage
FROM node:18-alpine

# Install dumb-init for proper signal handling
RUN apk add --no-cache dumb-init

# Create non-root user
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001

WORKDIR /app

# Copy from builder
COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
COPY --chown=nodejs:nodejs . .

# Set environment
ENV NODE_ENV=production \
    PORT=3000 \
    LOG_LEVEL=info

# Expose port
EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=40s --retries=3 \
    CMD node healthcheck.js || exit 1

# Switch to non-root user
USER nodejs

# Use dumb-init to handle signals properly
ENTRYPOINT ["dumb-init", "--"]

# Start application
CMD ["node", "server.js"]

upstream mcp_backend {
    least_conn;
    server mcp-server-1:3000 max_fails=3 fail_timeout=30s;
    server mcp-server-2:3000 max_fails=3 fail_timeout=30s;
    keepalive 32;
}

server {
    listen 443 ssl http2;
    server_name api.yourcompany.com;
    
    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    
    # Security headers
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    
    # SSE endpoint configuration
    location /api/mcp/sse {
        proxy_pass http://mcp_backend;
        proxy_http_version 1.1;
        
        # Critical SSE settings
        proxy_set_header Connection '';
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Host $host;
        
        # Disable buffering for SSE
        proxy_buffering off;
        proxy_cache off;
        
        # Timeouts for long-lived connections
        proxy_read_timeout 3600s;
        proxy_connect_timeout 60s;
        proxy_send_timeout 3600s;
        
        # Enable chunked transfer encoding
        chunked_transfer_encoding on;
        
        # Disable gzip for SSE
        gzip off;
    }
    
    # Regular API endpoints
    location /api/ {
        proxy_pass http://mcp_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        
        # Enable compression for non-SSE endpoints
        gzip on;
        gzip_types application/json text/plain;
    }
    
    # Health check endpoint
    location /health {
        access_log off;
        proxy_pass http://mcp_backend/health;
        proxy_http_version 1.1;
    }
}

# Redirect HTTP to HTTPS
server {
    listen 80;
    server_name api.yourcompany.com;
    return 301 https://$server_name$request_uri;
}

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-sse-server
  namespace: production
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels:
      app: mcp-sse-server
  template:
    metadata:
      labels:
        app: mcp-sse-server
        version: v1.0.0
    spec:
      containers:
      - name: mcp-server
        image: yourregistry/mcp-server:latest
        ports:
        - containerPort: 3000
          name: http
        env:
        - name: NODE_ENV
          value: "production"
        - name: PORT
          value: "3000"
        - name: MCP_API_KEY
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: api-key
        - name: JWT_SECRET
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: jwt-secret
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
        lifecycle:
          preStop:
            exec:
              command: ["/bin/sh", "-c", "sleep 15"]
---
apiVersion: v1
kind: Service
metadata:
  name: mcp-sse-service
  namespace: production
spec:
  type: ClusterIP
  sessionAffinity: ClientIP
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 3600
  ports:
  - port: 80
    targetPort: 3000
    protocol: TCP
  selector:
    app: mcp-sse-server
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: mcp-sse-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: mcp-sse-server
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80