@push.rocks/smartproxy 3.23.0 → 3.24.0

package/dist_ts/classes.networkproxy.js

@@ -4,13 +4,41 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 export class NetworkProxy {
+    /**
+     * Creates a new NetworkProxy instance
+     */
     constructor(optionsArg) {
         this.proxyConfigs = [];
+        this.defaultHeaders = {};
+        // State tracking
         this.router = new ProxyRouter();
         this.socketMap = new plugins.lik.ObjectMap();
-        this.defaultHeaders = {};
-        this.alreadyAddedReverseConfigs = {};
-        this.options = optionsArg;
+        this.activeContexts = new Set();
+        this.connectedClients = 0;
+        this.startTime = 0;
+        this.requestsServed = 0;
+        this.failedRequests = 0;
+        this.certificateCache = new Map();
+        // Set default options
+        this.options = {
+            port: optionsArg.port,
+            maxConnections: optionsArg.maxConnections || 10000,
+            keepAliveTimeout: optionsArg.keepAliveTimeout || 120000, // 2 minutes 
+            headersTimeout: optionsArg.headersTimeout || 60000, // 1 minute
+            logLevel: optionsArg.logLevel || 'info',
+            cors: optionsArg.cors || {
+                allowOrigin: '*',
+                allowMethods: 'GET, POST, PUT, DELETE, OPTIONS',
+                allowHeaders: 'Content-Type, Authorization',
+                maxAge: 86400
+            }
+        };
+        this.loadDefaultCertificates();
+    }
+    /**
+     * Loads default certificates from the filesystem
+     */
+    loadDefaultCertificates() {
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
         const certPath = path.join(__dirname, '..', 'assets', 'certs');
         try {
@@ -18,288 +46,644 @@ export class NetworkProxy {
                 key: fs.readFileSync(path.join(certPath, 'key.pem'), 'utf8'),
                 cert: fs.readFileSync(path.join(certPath, 'cert.pem'), 'utf8')
             };
+            this.log('info', 'Default certificates loaded successfully');
         }
         catch (error) {
-            console.error('Error loading certificates:', error);
-            throw error;
+            this.log('error', 'Error loading default certificates', error);
+            // Generate self-signed fallback certificates
+            try {
+                // This is a placeholder for actual certificate generation code
+                // In a real implementation, you would use a library like selfsigned to generate certs
+                this.defaultCertificates = {
+                    key: "FALLBACK_KEY_CONTENT",
+                    cert: "FALLBACK_CERT_CONTENT"
+                };
+                this.log('warn', 'Using fallback self-signed certificates');
+            }
+            catch (fallbackError) {
+                this.log('error', 'Failed to generate fallback certificates', fallbackError);
+                throw new Error('Could not load or generate SSL certificates');
+            }
         }
     }
+    /**
+     * Starts the proxy server
+     */
     async start() {
-        // Instead of marking the callback async (which Node won't await),
-        // we call our async handler and catch errors.
+        this.startTime = Date.now();
+        // Create the HTTPS server
         this.httpsServer = plugins.https.createServer({
             key: this.defaultCertificates.key,
             cert: this.defaultCertificates.cert
-        }, (originRequest, originResponse) => {
-            this.handleRequest(originRequest, originResponse).catch((error) => {
-                console.error('Unhandled error in request handler:', error);
-                try {
-                    originResponse.end();
-                }
-                catch (err) {
-                    // ignore errors during cleanup
+        }, (req, res) => this.handleRequest(req, res));
+        // Configure server timeouts
+        this.httpsServer.keepAliveTimeout = this.options.keepAliveTimeout;
+        this.httpsServer.headersTimeout = this.options.headersTimeout;
+        // Setup connection tracking
+        this.setupConnectionTracking();
+        // Setup WebSocket support
+        this.setupWebsocketSupport();
+        // Start metrics collection
+        this.setupMetricsCollection();
+        // Start the server
+        return new Promise((resolve) => {
+            this.httpsServer.listen(this.options.port, () => {
+                this.log('info', `NetworkProxy started on port ${this.options.port}`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Sets up tracking of TCP connections
+     */
+    setupConnectionTracking() {
+        this.httpsServer.on('connection', (connection) => {
+            // Check if max connections reached
+            if (this.socketMap.getArray().length >= this.options.maxConnections) {
+                this.log('warn', `Max connections (${this.options.maxConnections}) reached, rejecting new connection`);
+                connection.destroy();
+                return;
+            }
+            // Add connection to tracking
+            this.socketMap.add(connection);
+            this.connectedClients = this.socketMap.getArray().length;
+            this.log('debug', `New connection. Currently ${this.connectedClients} active connections`);
+            // Setup connection cleanup handlers
+            const cleanupConnection = () => {
+                if (this.socketMap.checkForObject(connection)) {
+                    this.socketMap.remove(connection);
+                    this.connectedClients = this.socketMap.getArray().length;
+                    this.log('debug', `Connection closed. ${this.connectedClients} connections remaining`);
                 }
+            };
+            connection.on('close', cleanupConnection);
+            connection.on('error', (err) => {
+                this.log('debug', 'Connection error', err);
+                cleanupConnection();
+            });
+            connection.on('end', cleanupConnection);
+            connection.on('timeout', () => {
+                this.log('debug', 'Connection timeout');
+                cleanupConnection();
             });
         });
-        // Enable websockets
-        const wsServer = new plugins.ws.WebSocketServer({ server: this.httpsServer });
-        // Set up the heartbeat interval
+    }
+    /**
+     * Sets up WebSocket support
+     */
+    setupWebsocketSupport() {
+        // Create WebSocket server
+        this.wsServer = new plugins.ws.WebSocketServer({
+            server: this.httpsServer,
+            // Add WebSocket specific timeout
+            clientTracking: true
+        });
+        // Handle WebSocket connections
+        this.wsServer.on('connection', (wsIncoming, reqArg) => {
+            this.handleWebSocketConnection(wsIncoming, reqArg);
+        });
+        // Set up the heartbeat interval (check every 30 seconds, terminate after 2 minutes of inactivity)
         this.heartbeatInterval = setInterval(() => {
-            wsServer.clients.forEach((ws) => {
-                const wsIncoming = ws;
-                if (!wsIncoming.lastPong) {
-                    wsIncoming.lastPong = Date.now();
-                }
-                if (Date.now() - wsIncoming.lastPong > 5 * 60 * 1000) {
-                    console.log('Terminating websocket due to missing pong for 5 minutes.');
-                    wsIncoming.terminate();
-                }
-                else {
-                    wsIncoming.ping();
+            if (this.wsServer.clients.size === 0) {
+                return; // Skip if no active connections
+            }
+            this.log('debug', `WebSocket heartbeat check for ${this.wsServer.clients.size} clients`);
+            this.wsServer.clients.forEach((ws) => {
+                const wsWithHeartbeat = ws;
+                if (wsWithHeartbeat.isAlive === false) {
+                    this.log('debug', 'Terminating inactive WebSocket connection');
+                    return wsWithHeartbeat.terminate();
                 }
+                wsWithHeartbeat.isAlive = false;
+                wsWithHeartbeat.ping();
             });
-        }, 60000); // runs every 1 minute
-        wsServer.on('connection', (wsIncoming, reqArg) => {
-            console.log(`wss proxy: got connection for wsc for https://${reqArg.headers.host}${reqArg.url}`);
+        }, 30000);
+    }
+    /**
+     * Sets up metrics collection
+     */
+    setupMetricsCollection() {
+        this.metricsInterval = setInterval(() => {
+            const uptime = Math.floor((Date.now() - this.startTime) / 1000);
+            const metrics = {
+                uptime,
+                activeConnections: this.connectedClients,
+                totalRequests: this.requestsServed,
+                failedRequests: this.failedRequests,
+                activeWebSockets: this.wsServer?.clients.size || 0,
+                memoryUsage: process.memoryUsage(),
+                activeContexts: Array.from(this.activeContexts)
+            };
+            this.log('debug', 'Proxy metrics', metrics);
+        }, 60000); // Log metrics every minute
+    }
+    /**
+     * Handles an incoming WebSocket connection
+     */
+    handleWebSocketConnection(wsIncoming, reqArg) {
+        const wsPath = reqArg.url;
+        const wsHost = reqArg.headers.host;
+        this.log('info', `WebSocket connection for ${wsHost}${wsPath}`);
+        // Setup heartbeat tracking
+        wsIncoming.isAlive = true;
+        wsIncoming.lastPong = Date.now();
+        wsIncoming.on('pong', () => {
+            wsIncoming.isAlive = true;
             wsIncoming.lastPong = Date.now();
-            wsIncoming.on('pong', () => {
-                wsIncoming.lastPong = Date.now();
-            });
-            let wsOutgoing;
-            const outGoingDeferred = plugins.smartpromise.defer();
-            // --- Improvement 2: Only call routeReq once ---
-            const wsDestinationConfig = this.router.routeReq(reqArg);
-            if (!wsDestinationConfig) {
-                wsIncoming.terminate();
-                return;
-            }
+        });
+        // Get the destination configuration
+        const wsDestinationConfig = this.router.routeReq(reqArg);
+        if (!wsDestinationConfig) {
+            this.log('warn', `No route found for WebSocket ${wsHost}${wsPath}`);
+            wsIncoming.terminate();
+            return;
+        }
+        // Check authentication if required
+        if (wsDestinationConfig.authentication) {
             try {
-                wsOutgoing = new plugins.wsDefault(`ws://${wsDestinationConfig.destinationIp}:${wsDestinationConfig.destinationPort}${reqArg.url}`);
-                console.log('wss proxy: initiated outgoing proxy');
-                wsOutgoing.on('open', async () => {
-                    outGoingDeferred.resolve();
-                });
+                if (!this.authenticateRequest(reqArg, wsDestinationConfig)) {
+                    this.log('warn', `WebSocket authentication failed for ${wsHost}${wsPath}`);
+                    wsIncoming.terminate();
+                    return;
+                }
             }
-            catch (err) {
-                console.error('Error initiating outgoing WebSocket:', err);
+            catch (error) {
+                this.log('error', 'WebSocket authentication error', error);
                 wsIncoming.terminate();
                 return;
             }
-            wsIncoming.on('message', async (message, isBinary) => {
-                try {
-                    await outGoingDeferred.promise;
+        }
+        // Setup outgoing WebSocket connection
+        let wsOutgoing;
+        const outGoingDeferred = plugins.smartpromise.defer();
+        try {
+            const wsTarget = `ws://${wsDestinationConfig.destinationIp}:${wsDestinationConfig.destinationPort}${reqArg.url}`;
+            this.log('debug', `Proxying WebSocket to ${wsTarget}`);
+            wsOutgoing = new plugins.wsDefault(wsTarget);
+            wsOutgoing.on('open', () => {
+                this.log('debug', 'Outgoing WebSocket connection established');
+                outGoingDeferred.resolve();
+            });
+            wsOutgoing.on('error', (error) => {
+                this.log('error', 'Outgoing WebSocket error', error);
+                outGoingDeferred.reject(error);
+                if (wsIncoming.readyState === wsIncoming.OPEN) {
+                    wsIncoming.terminate();
+                }
+            });
+        }
+        catch (err) {
+            this.log('error', 'Failed to create outgoing WebSocket connection', err);
+            wsIncoming.terminate();
+            return;
+        }
+        // Handle message forwarding from client to backend
+        wsIncoming.on('message', async (message, isBinary) => {
+            try {
+                // Wait for outgoing connection to be ready
+                await outGoingDeferred.promise;
+                // Only forward if both connections are still open
+                if (wsOutgoing.readyState === wsOutgoing.OPEN) {
                     wsOutgoing.send(message, { binary: isBinary });
                 }
-                catch (error) {
-                    console.error('Error sending message to wsOutgoing:', error);
+            }
+            catch (error) {
+                this.log('error', 'Error forwarding WebSocket message to backend', error);
+            }
+        });
+        // Handle message forwarding from backend to client
+        wsOutgoing.on('message', (message, isBinary) => {
+            try {
+                // Only forward if the incoming connection is still open
+                if (wsIncoming.readyState === wsIncoming.OPEN) {
+                    wsIncoming.send(message, { binary: isBinary });
                 }
-            });
-            wsOutgoing.on('message', async (message, isBinary) => {
+            }
+            catch (error) {
+                this.log('error', 'Error forwarding WebSocket message to client', error);
+            }
+        });
+        // Clean up connections when either side closes
+        wsIncoming.on('close', (code, reason) => {
+            this.log('debug', `Incoming WebSocket closed: ${code} - ${reason}`);
+            if (wsOutgoing && wsOutgoing.readyState !== wsOutgoing.CLOSED) {
                 try {
-                    wsIncoming.send(message, { binary: isBinary });
+                    // Validate close code (must be 1000-4999) or use 1000 as default
+                    const validCode = (code >= 1000 && code <= 4999) ? code : 1000;
+                    wsOutgoing.close(validCode, reason.toString() || '');
                 }
                 catch (error) {
-                    console.error('Error sending message to wsIncoming:', error);
-                }
-            });
-            const terminateWsOutgoing = () => {
-                if (wsOutgoing) {
+                    this.log('error', 'Error closing outgoing WebSocket', error);
                     wsOutgoing.terminate();
-                    console.log('Terminated outgoing ws.');
                 }
-            };
-            wsIncoming.on('error', terminateWsOutgoing);
-            wsIncoming.on('close', terminateWsOutgoing);
-            const terminateWsIncoming = () => {
-                if (wsIncoming) {
-                    wsIncoming.terminate();
-                    console.log('Terminated incoming ws.');
-                }
-            };
-            wsOutgoing.on('error', terminateWsIncoming);
-            wsOutgoing.on('close', terminateWsIncoming);
+            }
         });
-        this.httpsServer.keepAliveTimeout = 600 * 1000;
-        this.httpsServer.headersTimeout = 600 * 1000;
-        this.httpsServer.on('connection', (connection) => {
-            this.socketMap.add(connection);
-            console.log(`Added connection. Now ${this.socketMap.getArray().length} sockets connected.`);
-            const cleanupConnection = () => {
-                if (this.socketMap.checkForObject(connection)) {
-                    this.socketMap.remove(connection);
-                    console.log(`Removed connection. ${this.socketMap.getArray().length} sockets remaining.`);
-                    connection.destroy();
+        wsOutgoing.on('close', (code, reason) => {
+            this.log('debug', `Outgoing WebSocket closed: ${code} - ${reason}`);
+            if (wsIncoming && wsIncoming.readyState !== wsIncoming.CLOSED) {
+                try {
+                    // Validate close code (must be 1000-4999) or use 1000 as default
+                    const validCode = (code >= 1000 && code <= 4999) ? code : 1000;
+                    wsIncoming.close(validCode, reason.toString() || '');
                 }
-            };
-            connection.on('close', cleanupConnection);
-            connection.on('error', cleanupConnection);
-            connection.on('end', cleanupConnection);
-            connection.on('timeout', cleanupConnection);
+                catch (error) {
+                    this.log('error', 'Error closing incoming WebSocket', error);
+                    wsIncoming.terminate();
+                }
+            }
         });
-        this.httpsServer.listen(this.options.port);
-        console.log(`NetworkProxy -> OK: now listening for new connections on port ${this.options.port}`);
     }
     /**
-     * Internal async handler for processing HTTP/HTTPS requests.
+     * Handles an HTTP/HTTPS request
      */
     async handleRequest(originRequest, originResponse) {
-        const endOriginReqRes = (statusArg = 404, messageArg = 'This route is not available on this server.', headers = {}) => {
-            originResponse.writeHead(statusArg, messageArg);
-            originResponse.end(messageArg);
-            if (originRequest.socket !== originResponse.socket) {
-                console.log('hey, something is strange.');
+        this.requestsServed++;
+        const startTime = Date.now();
+        const reqId = `req_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+        try {
+            const reqPath = plugins.url.parse(originRequest.url).path;
+            this.log('info', `[${reqId}] ${originRequest.method} ${originRequest.headers.host}${reqPath}`);
+            // Handle preflight OPTIONS requests for CORS
+            if (originRequest.method === 'OPTIONS' && this.options.cors) {
+                this.handleCorsRequest(originRequest, originResponse);
+                return;
             }
-            originResponse.destroy();
-        };
-        console.log(`got request: ${originRequest.headers.host}${plugins.url.parse(originRequest.url).path}`);
-        const destinationConfig = this.router.routeReq(originRequest);
-        if (!destinationConfig) {
-            console.log(`${originRequest.headers.host} can't be routed properly. Terminating request.`);
-            endOriginReqRes();
-            return;
-        }
-        // authentication
-        if (destinationConfig.authentication) {
-            const authInfo = destinationConfig.authentication;
-            switch (authInfo.type) {
-                case 'Basic': {
-                    const authHeader = originRequest.headers.authorization;
-                    if (!authHeader) {
-                        return endOriginReqRes(401, 'Authentication required', {
-                            'WWW-Authenticate': 'Basic realm="Access to the staging site", charset="UTF-8"',
-                        });
-                    }
-                    if (!authHeader.includes('Basic ')) {
-                        return endOriginReqRes(401, 'Authentication required', {
-                            'WWW-Authenticate': 'Basic realm="Access to the staging site", charset="UTF-8"',
+            // Get destination configuration
+            const destinationConfig = this.router.routeReq(originRequest);
+            if (!destinationConfig) {
+                this.log('warn', `[${reqId}] No route found for ${originRequest.headers.host}`);
+                this.sendErrorResponse(originResponse, 404, 'Not Found: No matching route');
+                this.failedRequests++;
+                return;
+            }
+            // Handle authentication if configured
+            if (destinationConfig.authentication) {
+                try {
+                    if (!this.authenticateRequest(originRequest, destinationConfig)) {
+                        this.sendErrorResponse(originResponse, 401, 'Unauthorized', {
+                            'WWW-Authenticate': 'Basic realm="Access to the proxy site", charset="UTF-8"'
                         });
+                        this.failedRequests++;
+                        return;
                     }
-                    const authStringBase64 = authHeader.replace('Basic ', '');
-                    const authString = plugins.smartstring.base64.decode(authStringBase64);
-                    const userPassArray = authString.split(':');
-                    const user = userPassArray[0];
-                    const pass = userPassArray[1];
-                    if (user === authInfo.user && pass === authInfo.pass) {
-                        console.log('Request successfully authenticated');
-                    }
-                    else {
-                        return endOriginReqRes(403, 'Forbidden: Wrong credentials');
-                    }
-                    break;
                 }
-                default:
-                    return endOriginReqRes(403, 'Forbidden: unsupported authentication method configured. Please report to the admin.');
+                catch (error) {
+                    this.log('error', `[${reqId}] Authentication error`, error);
+                    this.sendErrorResponse(originResponse, 500, 'Internal Server Error: Authentication failed');
+                    this.failedRequests++;
+                    return;
+                }
+            }
+            // Construct destination URL
+            const destinationUrl = `http://${destinationConfig.destinationIp}:${destinationConfig.destinationPort}${originRequest.url}`;
+            this.log('debug', `[${reqId}] Proxying to ${destinationUrl}`);
+            // Forward the request
+            await this.forwardRequest(reqId, originRequest, originResponse, destinationUrl);
+            const processingTime = Date.now() - startTime;
+            this.log('debug', `[${reqId}] Request completed in ${processingTime}ms`);
+        }
+        catch (error) {
+            this.log('error', `[${reqId}] Unhandled error in request handler`, error);
+            try {
+                this.sendErrorResponse(originResponse, 502, 'Bad Gateway: Server error');
+            }
+            catch (responseError) {
+                this.log('error', `[${reqId}] Failed to send error response`, responseError);
             }
+            this.failedRequests++;
         }
-        let destinationUrl;
-        if (destinationConfig) {
-            destinationUrl = `http://${destinationConfig.destinationIp}:${destinationConfig.destinationPort}${originRequest.url}`;
+    }
+    /**
+     * Handles a CORS preflight request
+     */
+    handleCorsRequest(req, res) {
+        const cors = this.options.cors;
+        // Set CORS headers
+        res.setHeader('Access-Control-Allow-Origin', cors.allowOrigin);
+        res.setHeader('Access-Control-Allow-Methods', cors.allowMethods);
+        res.setHeader('Access-Control-Allow-Headers', cors.allowHeaders);
+        res.setHeader('Access-Control-Max-Age', String(cors.maxAge));
+        // Handle preflight request
+        res.statusCode = 204;
+        res.end();
+        // Count this as a request served
+        this.requestsServed++;
+    }
+    /**
+     * Authenticates a request against the destination config
+     */
+    authenticateRequest(req, config) {
+        const authInfo = config.authentication;
+        if (!authInfo) {
+            return true; // No authentication required
         }
-        else {
-            return endOriginReqRes();
+        switch (authInfo.type) {
+            case 'Basic': {
+                const authHeader = req.headers.authorization;
+                if (!authHeader || !authHeader.includes('Basic ')) {
+                    return false;
+                }
+                const authStringBase64 = authHeader.replace('Basic ', '');
+                const authString = plugins.smartstring.base64.decode(authStringBase64);
+                const [user, pass] = authString.split(':');
+                // Use constant-time comparison to prevent timing attacks
+                const userMatch = user === authInfo.user;
+                const passMatch = pass === authInfo.pass;
+                return userMatch && passMatch;
+            }
+            default:
+                throw new Error(`Unsupported authentication method: ${authInfo.type}`);
         }
-        console.log(destinationUrl);
+    }
+    /**
+     * Forwards a request to the destination
+     */
+    async forwardRequest(reqId, originRequest, originResponse, destinationUrl) {
         try {
-            const proxyResponse = await plugins.smartrequest.request(destinationUrl, {
+            const proxyRequest = await plugins.smartrequest.request(destinationUrl, {
                 method: originRequest.method,
-                headers: {
-                    ...originRequest.headers,
-                    'X-Forwarded-Host': originRequest.headers.host,
-                    'X-Forwarded-Proto': 'https',
-                },
+                headers: this.prepareForwardHeaders(originRequest),
                 keepAlive: true,
-            }, true, // streaming (keepAlive)
-            (proxyRequest) => {
-                originRequest.on('data', (data) => {
-                    proxyRequest.write(data);
-                });
-                originRequest.on('end', () => {
-                    proxyRequest.end();
-                });
-                originRequest.on('error', () => {
-                    proxyRequest.end();
-                });
-                originRequest.on('close', () => {
-                    proxyRequest.end();
-                });
-                originRequest.on('timeout', () => {
-                    proxyRequest.end();
-                    originRequest.destroy();
-                });
-                proxyRequest.on('error', () => {
-                    endOriginReqRes();
+                timeout: 30000 // 30 second timeout
+            }, true, // streaming
+            (proxyRequestStream) => this.setupRequestStreaming(originRequest, proxyRequestStream));
+            // Handle the response
+            this.processProxyResponse(reqId, originResponse, proxyRequest);
+        }
+        catch (error) {
+            this.log('error', `[${reqId}] Error forwarding request`, error);
+            this.sendErrorResponse(originResponse, 502, 'Bad Gateway: Unable to reach upstream server');
+            throw error; // Let the main handler catch this
+        }
+    }
+    /**
+     * Prepares headers to forward to the backend
+     */
+    prepareForwardHeaders(req) {
+        const safeHeaders = { ...req.headers };
+        // Add forwarding headers
+        safeHeaders['X-Forwarded-Host'] = req.headers.host;
+        safeHeaders['X-Forwarded-Proto'] = 'https';
+        safeHeaders['X-Forwarded-For'] = (req.socket.remoteAddress || '').replace(/^::ffff:/, '');
+        // Add proxy-specific headers
+        safeHeaders['X-Proxy-Id'] = `NetworkProxy-${this.options.port}`;
+        // Remove sensitive headers we don't want to forward
+        const sensitiveHeaders = ['connection', 'upgrade', 'http2-settings'];
+        for (const header of sensitiveHeaders) {
+            delete safeHeaders[header];
+        }
+        return safeHeaders;
+    }
+    /**
+     * Sets up request streaming for the proxy
+     */
+    setupRequestStreaming(originRequest, proxyRequest) {
+        // Forward request body data
+        originRequest.on('data', (chunk) => {
+            proxyRequest.write(chunk);
+        });
+        // End the request when done
+        originRequest.on('end', () => {
+            proxyRequest.end();
+        });
+        // Handle request errors
+        originRequest.on('error', (error) => {
+            this.log('error', 'Error in client request stream', error);
+            proxyRequest.destroy(error);
+        });
+        // Handle client abort/timeout
+        originRequest.on('close', () => {
+            if (!originRequest.complete) {
+                this.log('debug', 'Client closed connection before request completed');
+                proxyRequest.destroy();
+            }
+        });
+        originRequest.on('timeout', () => {
+            this.log('debug', 'Client request timeout');
+            proxyRequest.destroy(new Error('Client request timeout'));
+        });
+        // Handle proxy request errors
+        proxyRequest.on('error', (error) => {
+            this.log('error', 'Error in outgoing proxy request', error);
+        });
+    }
+    /**
+     * Processes a proxy response
+     */
+    processProxyResponse(reqId, originResponse, proxyResponse) {
+        this.log('debug', `[${reqId}] Received upstream response: ${proxyResponse.statusCode}`);
+        // Set status code
+        originResponse.statusCode = proxyResponse.statusCode;
+        // Add default headers
+        for (const [headerName, headerValue] of Object.entries(this.defaultHeaders)) {
+            originResponse.setHeader(headerName, headerValue);
+        }
+        // Add CORS headers if enabled
+        if (this.options.cors) {
+            originResponse.setHeader('Access-Control-Allow-Origin', this.options.cors.allowOrigin);
+        }
+        // Copy response headers
+        for (const [headerName, headerValue] of Object.entries(proxyResponse.headers)) {
+            // Skip hop-by-hop headers
+            const hopByHopHeaders = ['connection', 'keep-alive', 'transfer-encoding', 'te',
+                'trailer', 'upgrade', 'proxy-authorization', 'proxy-authenticate'];
+            if (!hopByHopHeaders.includes(headerName.toLowerCase())) {
+                originResponse.setHeader(headerName, headerValue);
+            }
+        }
+        // Stream response body
+        proxyResponse.on('data', (chunk) => {
+            const canContinue = originResponse.write(chunk);
+            // Apply backpressure if needed
+            if (!canContinue) {
+                proxyResponse.pause();
+                originResponse.once('drain', () => {
+                    proxyResponse.resume();
                 });
-            });
-            originResponse.statusCode = proxyResponse.statusCode;
-            console.log(proxyResponse.statusCode);
-            for (const defaultHeader of Object.keys(this.defaultHeaders)) {
-                originResponse.setHeader(defaultHeader, this.defaultHeaders[defaultHeader]);
             }
-            for (const header of Object.keys(proxyResponse.headers)) {
-                originResponse.setHeader(header, proxyResponse.headers[header]);
+        });
+        // End the response when done
+        proxyResponse.on('end', () => {
+            originResponse.end();
+        });
+        // Handle response errors
+        proxyResponse.on('error', (error) => {
+            this.log('error', `[${reqId}] Error in proxy response stream`, error);
+            originResponse.destroy(error);
+        });
+        originResponse.on('error', (error) => {
+            this.log('error', `[${reqId}] Error in client response stream`, error);
+            proxyResponse.destroy();
+        });
+    }
+    /**
+     * Sends an error response to the client
+     */
+    sendErrorResponse(res, statusCode = 500, message = 'Internal Server Error', headers = {}) {
+        try {
+            // If headers already sent, just end the response
+            if (res.headersSent) {
+                res.end();
+                return;
+            }
+            // Add default headers
+            for (const [key, value] of Object.entries(this.defaultHeaders)) {
+                res.setHeader(key, value);
+            }
+            // Add provided headers
+            for (const [key, value] of Object.entries(headers)) {
+                res.setHeader(key, value);
+            }
+            // Send error response
+            res.writeHead(statusCode, message);
+            // Send error body as JSON for API clients
+            if (res.getHeader('Content-Type') === 'application/json') {
+                res.end(JSON.stringify({ error: { status: statusCode, message } }));
+            }
+            else {
+                // Send as plain text
+                res.end(message);
             }
-            proxyResponse.on('data', (data) => {
-                originResponse.write(data);
-            });
-            proxyResponse.on('end', () => {
-                originResponse.end();
-            });
-            proxyResponse.on('error', () => {
-                originResponse.destroy();
-            });
-            proxyResponse.on('close', () => {
-                originResponse.end();
-            });
-            proxyResponse.on('timeout', () => {
-                originResponse.end();
-                originResponse.destroy();
-            });
         }
         catch (error) {
-            console.error('Error while processing request:', error);
-            endOriginReqRes(502, 'Bad Gateway: Error processing the request');
+            this.log('error', 'Error sending error response', error);
+            try {
+                res.destroy();
+            }
+            catch (destroyError) {
+                // Last resort - nothing more we can do
+            }
         }
     }
+    /**
+     * Updates proxy configurations
+     */
     async updateProxyConfigs(proxyConfigsArg) {
-        console.log(`got new proxy configs`);
+        this.log('info', `Updating proxy configurations (${proxyConfigsArg.length} configs)`);
+        // Update internal configs
         this.proxyConfigs = proxyConfigsArg;
         this.router.setNewProxyConfigs(proxyConfigsArg);
-        for (const hostCandidate of this.proxyConfigs) {
-            const existingHostNameConfig = this.alreadyAddedReverseConfigs[hostCandidate.hostName];
-            if (!existingHostNameConfig) {
-                this.alreadyAddedReverseConfigs[hostCandidate.hostName] = hostCandidate;
-            }
-            else {
-                if (existingHostNameConfig.publicKey === hostCandidate.publicKey &&
-                    existingHostNameConfig.privateKey === hostCandidate.privateKey) {
-                    continue;
-                }
-                else {
-                    this.alreadyAddedReverseConfigs[hostCandidate.hostName] = hostCandidate;
+        // Collect all hostnames for cleanup later
+        const currentHostNames = new Set();
+        // Add/update SSL contexts for each host
+        for (const config of proxyConfigsArg) {
+            currentHostNames.add(config.hostName);
+            try {
+                // Check if we need to update the cert
+                const currentCert = this.certificateCache.get(config.hostName);
+                const shouldUpdate = !currentCert ||
+                    currentCert.key !== config.privateKey ||
+                    currentCert.cert !== config.publicKey;
+                if (shouldUpdate) {
+                    this.log('debug', `Updating SSL context for ${config.hostName}`);
+                    // Update the HTTPS server context
+                    this.httpsServer.addContext(config.hostName, {
+                        key: config.privateKey,
+                        cert: config.publicKey
+                    });
+                    // Update the cache
+                    this.certificateCache.set(config.hostName, {
+                        key: config.privateKey,
+                        cert: config.publicKey
+                    });
+                    this.activeContexts.add(config.hostName);
                 }
             }
-            this.httpsServer.addContext(hostCandidate.hostName, {
-                cert: hostCandidate.publicKey,
-                key: hostCandidate.privateKey,
-            });
+            catch (error) {
+                this.log('error', `Failed to add SSL context for ${config.hostName}`, error);
+            }
+        }
+        // Clean up removed contexts
+        // Note: Node.js doesn't officially support removing contexts
+        // This would require server restart in production
+        for (const hostname of this.activeContexts) {
+            if (!currentHostNames.has(hostname)) {
+                this.log('info', `Hostname ${hostname} removed from configuration`);
+                this.activeContexts.delete(hostname);
+                this.certificateCache.delete(hostname);
+            }
         }
     }
+    /**
+     * Adds default headers to be included in all responses
+     */
     async addDefaultHeaders(headersArg) {
-        for (const headerKey of Object.keys(headersArg)) {
-            this.defaultHeaders[headerKey] = headersArg[headerKey];
-        }
+        this.log('info', 'Adding default headers', headersArg);
+        this.defaultHeaders = {
+            ...this.defaultHeaders,
+            ...headersArg
+        };
     }
+    /**
+     * Stops the proxy server
+     */
     async stop() {
-        const done = plugins.smartpromise.defer();
-        this.httpsServer.close(() => {
-            done.resolve();
-        });
+        this.log('info', 'Stopping NetworkProxy server');
+        // Clear intervals
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        if (this.metricsInterval) {
+            clearInterval(this.metricsInterval);
+        }
+        // Close WebSocket server if exists
+        if (this.wsServer) {
+            for (const client of this.wsServer.clients) {
+                try {
+                    client.terminate();
+                }
+                catch (error) {
+                    this.log('error', 'Error terminating WebSocket client', error);
+                }
+            }
+        }
+        // Close all tracked sockets
         for (const socket of this.socketMap.getArray()) {
-            socket.destroy();
+            try {
+                socket.destroy();
+            }
+            catch (error) {
+                this.log('error', 'Error destroying socket', error);
+            }
+        }
+        // Close the HTTPS server
+        return new Promise((resolve) => {
+            this.httpsServer.close(() => {
+                this.log('info', 'NetworkProxy server stopped successfully');
+                resolve();
+            });
+        });
+    }
+    /**
+     * Logs a message according to the configured log level
+     */
+    log(level, message, data) {
+        const logLevels = {
+            error: 0,
+            warn: 1,
+            info: 2,
+            debug: 3
+        };
+        // Skip if log level is higher than configured
+        if (logLevels[level] > logLevels[this.options.logLevel]) {
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+        switch (level) {
+            case 'error':
+                console.error(`${prefix} ${message}`, data || '');
+                break;
+            case 'warn':
+                console.warn(`${prefix} ${message}`, data || '');
+                break;
+            case 'info':
+                console.log(`${prefix} ${message}`, data || '');
+                break;
+            case 'debug':
+                console.log(`${prefix} ${message}`, data || '');
+                break;
         }
-        await done.promise;
-        clearInterval(this.heartbeatInterval);
-        console.log('NetworkProxy -> OK: Server has been stopped and all connections closed.');
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.networkproxy.js","sourceRoot":"","sources":["../ts/classes.networkproxy.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.networkproxy.js","sourceRoot":"","sources":["../ts/classes.networkproxy.ts"],"names":[],"mappings":"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"}