@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/proxies/network-proxy/request-handler.js

@@ -0,0 +1,394 @@
+import * as plugins from '../../plugins.js';
+import { createLogger } from './models/types.js';
+import { ConnectionPool } from './connection-pool.js';
+import { ProxyRouter } from '../../http/router/index.js';
+/**
+ * Handles HTTP request processing and proxying
+ */
+export class RequestHandler {
+    constructor(options, connectionPool, router) {
+        this.options = options;
+        this.connectionPool = connectionPool;
+        this.router = router;
+        this.defaultHeaders = {};
+        this.metricsTracker = null;
+        // HTTP/2 client sessions for backend proxying
+        this.h2Sessions = new Map();
+        this.logger = createLogger(options.logLevel || 'info');
+    }
+    /**
+     * Set the metrics tracker instance
+     */
+    setMetricsTracker(tracker) {
+        this.metricsTracker = tracker;
+    }
+    /**
+     * Set default headers to be included in all responses
+     */
+    setDefaultHeaders(headers) {
+        this.defaultHeaders = {
+            ...this.defaultHeaders,
+            ...headers
+        };
+        this.logger.info('Updated default response headers');
+    }
+    /**
+     * Get all default headers
+     */
+    getDefaultHeaders() {
+        return { ...this.defaultHeaders };
+    }
+    /**
+     * Apply CORS headers to response if configured
+     */
+    applyCorsHeaders(res, req) {
+        if (!this.options.cors) {
+            return;
+        }
+        // Apply CORS headers
+        if (this.options.cors.allowOrigin) {
+            res.setHeader('Access-Control-Allow-Origin', this.options.cors.allowOrigin);
+        }
+        if (this.options.cors.allowMethods) {
+            res.setHeader('Access-Control-Allow-Methods', this.options.cors.allowMethods);
+        }
+        if (this.options.cors.allowHeaders) {
+            res.setHeader('Access-Control-Allow-Headers', this.options.cors.allowHeaders);
+        }
+        if (this.options.cors.maxAge) {
+            res.setHeader('Access-Control-Max-Age', this.options.cors.maxAge.toString());
+        }
+        // Handle CORS preflight requests
+        if (req.method === 'OPTIONS') {
+            res.statusCode = 204; // No content
+            res.end();
+            return;
+        }
+    }
+    /**
+     * Apply default headers to response
+     */
+    applyDefaultHeaders(res) {
+        // Apply default headers
+        for (const [key, value] of Object.entries(this.defaultHeaders)) {
+            if (!res.hasHeader(key)) {
+                res.setHeader(key, value);
+            }
+        }
+        // Add server identifier if not already set
+        if (!res.hasHeader('Server')) {
+            res.setHeader('Server', 'NetworkProxy');
+        }
+    }
+    /**
+     * Handle an HTTP request
+     */
+    async handleRequest(req, res) {
+        // Record start time for logging
+        const startTime = Date.now();
+        // Apply CORS headers if configured
+        this.applyCorsHeaders(res, req);
+        // If this is an OPTIONS request, the response has already been ended in applyCorsHeaders
+        // so we should return early to avoid trying to set more headers
+        if (req.method === 'OPTIONS') {
+            // Increment metrics for OPTIONS requests too
+            if (this.metricsTracker) {
+                this.metricsTracker.incrementRequestsServed();
+            }
+            return;
+        }
+        // Apply default headers
+        this.applyDefaultHeaders(res);
+        // Determine routing configuration
+        let proxyConfig;
+        try {
+            proxyConfig = this.router.routeReq(req);
+        }
+        catch (err) {
+            this.logger.error('Error routing request', err);
+            res.statusCode = 500;
+            res.end('Internal Server Error');
+            if (this.metricsTracker)
+                this.metricsTracker.incrementFailedRequests();
+            return;
+        }
+        if (!proxyConfig) {
+            this.logger.warn(`No proxy configuration for host: ${req.headers.host}`);
+            res.statusCode = 404;
+            res.end('Not Found: No proxy configuration for this host');
+            if (this.metricsTracker)
+                this.metricsTracker.incrementFailedRequests();
+            return;
+        }
+        // Determine protocol to backend (per-domain override or global)
+        const backendProto = proxyConfig.backendProtocol || this.options.backendProtocol;
+        if (backendProto === 'http2') {
+            const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
+            const key = `${destination.host}:${destination.port}`;
+            let session = this.h2Sessions.get(key);
+            if (!session || session.closed || session.destroyed) {
+                session = plugins.http2.connect(`http://${destination.host}:${destination.port}`);
+                this.h2Sessions.set(key, session);
+                session.on('error', () => this.h2Sessions.delete(key));
+                session.on('close', () => this.h2Sessions.delete(key));
+            }
+            // Build headers for HTTP/2 request
+            const hdrs = {
+                ':method': req.method,
+                ':path': req.url,
+                ':authority': `${destination.host}:${destination.port}`
+            };
+            for (const [hk, hv] of Object.entries(req.headers)) {
+                if (typeof hv === 'string')
+                    hdrs[hk] = hv;
+            }
+            const h2Stream = session.request(hdrs);
+            req.pipe(h2Stream);
+            h2Stream.on('response', (hdrs2) => {
+                const status = hdrs2[':status'] || 502;
+                res.statusCode = status;
+                // Copy headers from HTTP/2 response to HTTP/1 response
+                for (const [hk, hv] of Object.entries(hdrs2)) {
+                    if (!hk.startsWith(':') && hv != null) {
+                        res.setHeader(hk, hv);
+                    }
+                }
+                h2Stream.pipe(res);
+            });
+            h2Stream.on('error', (err) => {
+                res.statusCode = 502;
+                res.end(`Bad Gateway: ${err.message}`);
+                if (this.metricsTracker)
+                    this.metricsTracker.incrementFailedRequests();
+            });
+            return;
+        }
+        try {
+            // Find target based on hostname
+            const proxyConfig = this.router.routeReq(req);
+            if (!proxyConfig) {
+                // No matching proxy configuration
+                this.logger.warn(`No proxy configuration for host: ${req.headers.host}`);
+                res.statusCode = 404;
+                res.end('Not Found: No proxy configuration for this host');
+                // Increment failed requests counter
+                if (this.metricsTracker) {
+                    this.metricsTracker.incrementFailedRequests();
+                }
+                return;
+            }
+            // Get destination IP using round-robin if multiple IPs configured
+            const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
+            // Create options for the proxy request
+            const options = {
+                hostname: destination.host,
+                port: destination.port,
+                path: req.url,
+                method: req.method,
+                headers: { ...req.headers }
+            };
+            // Remove host header to avoid issues with virtual hosts on target server
+            // The host header should match the target server's expected hostname
+            if (options.headers && options.headers.host) {
+                if (proxyConfig.rewriteHostHeader) {
+                    options.headers.host = `${destination.host}:${destination.port}`;
+                }
+            }
+            this.logger.debug(`Proxying request to ${destination.host}:${destination.port}${req.url}`, { method: req.method });
+            // Create proxy request
+            const proxyReq = plugins.http.request(options, (proxyRes) => {
+                // Copy status code
+                res.statusCode = proxyRes.statusCode || 500;
+                // Copy headers from proxy response to client response
+                for (const [key, value] of Object.entries(proxyRes.headers)) {
+                    if (value !== undefined) {
+                        res.setHeader(key, value);
+                    }
+                }
+                // Pipe proxy response to client response
+                proxyRes.pipe(res);
+                // Increment served requests counter when the response finishes
+                res.on('finish', () => {
+                    if (this.metricsTracker) {
+                        this.metricsTracker.incrementRequestsServed();
+                    }
+                    // Log the completed request
+                    const duration = Date.now() - startTime;
+                    this.logger.debug(`Request completed in ${duration}ms: ${req.method} ${req.url} ${res.statusCode}`, { duration, statusCode: res.statusCode });
+                });
+            });
+            // Handle proxy request errors
+            proxyReq.on('error', (error) => {
+                const duration = Date.now() - startTime;
+                this.logger.error(`Proxy error for ${req.method} ${req.url}: ${error.message}`, { duration, error: error.message });
+                // Increment failed requests counter
+                if (this.metricsTracker) {
+                    this.metricsTracker.incrementFailedRequests();
+                }
+                // Check if headers have already been sent
+                if (!res.headersSent) {
+                    res.statusCode = 502;
+                    res.end(`Bad Gateway: ${error.message}`);
+                }
+                else {
+                    // If headers already sent, just close the connection
+                    res.end();
+                }
+            });
+            // Pipe request body to proxy request and handle client-side errors
+            req.pipe(proxyReq);
+            // Handle client disconnection
+            req.on('error', (error) => {
+                this.logger.debug(`Client connection error: ${error.message}`);
+                proxyReq.destroy();
+                // Increment failed requests counter on client errors
+                if (this.metricsTracker) {
+                    this.metricsTracker.incrementFailedRequests();
+                }
+            });
+            // Handle response errors
+            res.on('error', (error) => {
+                this.logger.debug(`Response error: ${error.message}`);
+                proxyReq.destroy();
+                // Increment failed requests counter on response errors
+                if (this.metricsTracker) {
+                    this.metricsTracker.incrementFailedRequests();
+                }
+            });
+        }
+        catch (error) {
+            // Handle any unexpected errors
+            this.logger.error(`Unexpected error handling request: ${error.message}`, { error: error.stack });
+            // Increment failed requests counter
+            if (this.metricsTracker) {
+                this.metricsTracker.incrementFailedRequests();
+            }
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.end('Internal Server Error');
+            }
+            else {
+                res.end();
+            }
+        }
+    }
+    /**
+     * Handle HTTP/2 stream requests by proxying to HTTP/1 backends
+     */
+    async handleHttp2(stream, headers) {
+        const startTime = Date.now();
+        const method = headers[':method'] || 'GET';
+        const path = headers[':path'] || '/';
+        // If configured to proxy to backends over HTTP/2, use HTTP/2 client sessions
+        if (this.options.backendProtocol === 'http2') {
+            const authority = headers[':authority'] || '';
+            const host = authority.split(':')[0];
+            const fakeReq = { headers: { host }, method: headers[':method'], url: headers[':path'], socket: stream.session.socket };
+            const proxyConfig = this.router.routeReq(fakeReq);
+            if (!proxyConfig) {
+                stream.respond({ ':status': 404 });
+                stream.end('Not Found');
+                if (this.metricsTracker)
+                    this.metricsTracker.incrementFailedRequests();
+                return;
+            }
+            const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
+            const key = `${destination.host}:${destination.port}`;
+            let session = this.h2Sessions.get(key);
+            if (!session || session.closed || session.destroyed) {
+                session = plugins.http2.connect(`http://${destination.host}:${destination.port}`);
+                this.h2Sessions.set(key, session);
+                session.on('error', () => this.h2Sessions.delete(key));
+                session.on('close', () => this.h2Sessions.delete(key));
+            }
+            // Build headers for backend HTTP/2 request
+            const h2Headers = {
+                ':method': headers[':method'],
+                ':path': headers[':path'],
+                ':authority': `${destination.host}:${destination.port}`
+            };
+            for (const [k, v] of Object.entries(headers)) {
+                if (!k.startsWith(':') && typeof v === 'string') {
+                    h2Headers[k] = v;
+                }
+            }
+            const h2Stream2 = session.request(h2Headers);
+            stream.pipe(h2Stream2);
+            h2Stream2.on('response', (hdrs) => {
+                // Map status and headers to client
+                const resp = { ':status': hdrs[':status'] };
+                for (const [hk, hv] of Object.entries(hdrs)) {
+                    if (!hk.startsWith(':') && hv)
+                        resp[hk] = hv;
+                }
+                stream.respond(resp);
+                h2Stream2.pipe(stream);
+            });
+            h2Stream2.on('error', (err) => {
+                stream.respond({ ':status': 502 });
+                stream.end(`Bad Gateway: ${err.message}`);
+                if (this.metricsTracker)
+                    this.metricsTracker.incrementFailedRequests();
+            });
+            return;
+        }
+        try {
+            // Determine host for routing
+            const authority = headers[':authority'] || '';
+            const host = authority.split(':')[0];
+            // Fake request object for routing
+            const fakeReq = { headers: { host }, method, url: path, socket: stream.session.socket };
+            const proxyConfig = this.router.routeReq(fakeReq);
+            if (!proxyConfig) {
+                stream.respond({ ':status': 404 });
+                stream.end('Not Found');
+                if (this.metricsTracker)
+                    this.metricsTracker.incrementFailedRequests();
+                return;
+            }
+            // Select backend target
+            const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
+            // Build headers for HTTP/1 proxy
+            const outboundHeaders = {};
+            for (const [key, value] of Object.entries(headers)) {
+                if (typeof key === 'string' && typeof value === 'string' && !key.startsWith(':')) {
+                    outboundHeaders[key] = value;
+                }
+            }
+            if (outboundHeaders.host && proxyConfig.rewriteHostHeader) {
+                outboundHeaders.host = `${destination.host}:${destination.port}`;
+            }
+            // Create HTTP/1 proxy request
+            const proxyReq = plugins.http.request({ hostname: destination.host, port: destination.port, path, method, headers: outboundHeaders }, (proxyRes) => {
+                // Map status and headers back to HTTP/2
+                const responseHeaders = {};
+                for (const [k, v] of Object.entries(proxyRes.headers)) {
+                    if (v !== undefined) {
+                        responseHeaders[k] = v;
+                    }
+                }
+                stream.respond({ ':status': proxyRes.statusCode || 500, ...responseHeaders });
+                proxyRes.pipe(stream);
+                stream.on('close', () => proxyReq.destroy());
+                stream.on('error', () => proxyReq.destroy());
+                if (this.metricsTracker)
+                    stream.on('end', () => this.metricsTracker.incrementRequestsServed());
+            });
+            proxyReq.on('error', (err) => {
+                stream.respond({ ':status': 502 });
+                stream.end(`Bad Gateway: ${err.message}`);
+                if (this.metricsTracker)
+                    this.metricsTracker.incrementFailedRequests();
+            });
+            // Pipe client stream to backend
+            stream.pipe(proxyReq);
+        }
+        catch (err) {
+            stream.respond({ ':status': 500 });
+            stream.end('Internal Server Error');
+            if (this.metricsTracker)
+                this.metricsTracker.incrementFailedRequests();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request-handler.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/request-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/network-proxy/websocket-handler.d.ts

@@ -0,0 +1,38 @@
+import * as plugins from '../../plugins.js';
+import { type INetworkProxyOptions } from './models/types.js';
+import { ConnectionPool } from './connection-pool.js';
+import { ProxyRouter } from '../../http/router/index.js';
+/**
+ * Handles WebSocket connections and proxying
+ */
+export declare class WebSocketHandler {
+    private options;
+    private connectionPool;
+    private router;
+    private heartbeatInterval;
+    private wsServer;
+    private logger;
+    constructor(options: INetworkProxyOptions, connectionPool: ConnectionPool, router: ProxyRouter);
+    /**
+     * Initialize WebSocket server on an existing HTTPS server
+     */
+    initialize(server: plugins.https.Server): void;
+    /**
+     * Start the heartbeat interval to check for inactive WebSocket connections
+     */
+    private startHeartbeat;
+    /**
+     * Handle a new WebSocket connection
+     */
+    private handleWebSocketConnection;
+    /**
+     * Get information about active WebSocket connections
+     */
+    getConnectionInfo(): {
+        activeConnections: number;
+    };
+    /**
+     * Shutdown the WebSocket handler
+     */
+    shutdown(): void;
+}