@push.rocks/smartproxy 16.0.2 → 16.0.4

package/dist_ts/proxies/network-proxy/http-request-handler.d.ts

@@ -0,0 +1,40 @@
+import * as plugins from '../../plugins.js';
+import '../../core/models/socket-augmentation.js';
+import type { IHttpRouteContext } from '../../core/models/route-context.js';
+import type { ILogger } from './models/types.js';
+import type { IMetricsTracker } from './request-handler.js';
+import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
+/**
+ * HTTP Request Handler Helper - handles requests with specific destinations
+ * This is a helper class for the main RequestHandler
+ */
+export declare class HttpRequestHandler {
+    /**
+     * Handle HTTP request with a specific destination
+     */
+    static handleHttpRequestWithDestination(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse, destination: {
+        host: string;
+        port: number;
+    }, routeContext: IHttpRouteContext, startTime: number, logger: ILogger, metricsTracker?: IMetricsTracker | null, route?: IRouteConfig): Promise<void>;
+    /**
+     * Apply URL rewriting based on route configuration
+     * Implements Phase 5.2: URL rewriting using route context
+     *
+     * @param req The request with the URL to rewrite
+     * @param route The route configuration containing rewrite rules
+     * @param routeContext Context for template variable resolution
+     * @param logger Logger for debugging information
+     * @returns True if URL was rewritten, false otherwise
+     */
+    private static applyUrlRewriting;
+    /**
+     * Apply header modifications from route configuration to request headers
+     * Implements Phase 5.1: Route-based header manipulation for requests
+     */
+    private static applyRouteHeaderModifications;
+    /**
+     * Apply header modifications from route configuration to response headers
+     * Implements Phase 5.1: Route-based header manipulation for responses
+     */
+    private static applyResponseHeaderModifications;
+}

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

@@ -0,0 +1,256 @@
+import * as plugins from '../../plugins.js';
+import '../../core/models/socket-augmentation.js';
+import { TemplateUtils } from '../../core/utils/template-utils.js';
+/**
+ * HTTP Request Handler Helper - handles requests with specific destinations
+ * This is a helper class for the main RequestHandler
+ */
+export class HttpRequestHandler {
+    /**
+     * Handle HTTP request with a specific destination
+     */
+    static async handleHttpRequestWithDestination(req, res, destination, routeContext, startTime, logger, metricsTracker, route) {
+        try {
+            // Apply URL rewriting if route config is provided
+            if (route) {
+                HttpRequestHandler.applyUrlRewriting(req, route, routeContext, logger);
+                HttpRequestHandler.applyRouteHeaderModifications(route, req, res, logger);
+            }
+            // Create options for the proxy request
+            const options = {
+                hostname: destination.host,
+                port: destination.port,
+                path: req.url,
+                method: req.method,
+                headers: { ...req.headers }
+            };
+            // Optionally rewrite host header to match target
+            if (options.headers && options.headers.host) {
+                // Only apply if host header rewrite is enabled or not explicitly disabled
+                const shouldRewriteHost = route?.action.options?.rewriteHostHeader !== false;
+                if (shouldRewriteHost) {
+                    options.headers.host = `${destination.host}:${destination.port}`;
+                }
+            }
+            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);
+                    }
+                }
+                // Apply response header modifications if route config is provided
+                if (route && route.headers?.response) {
+                    HttpRequestHandler.applyResponseHeaderModifications(route, res, logger, routeContext);
+                }
+                // Pipe proxy response to client response
+                proxyRes.pipe(res);
+                // Increment served requests counter when the response finishes
+                res.on('finish', () => {
+                    if (metricsTracker) {
+                        metricsTracker.incrementRequestsServed();
+                    }
+                    // Log the completed request
+                    const duration = Date.now() - startTime;
+                    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;
+                logger.error(`Proxy error for ${req.method} ${req.url}: ${error.message}`, { duration, error: error.message });
+                // Increment failed requests counter
+                if (metricsTracker) {
+                    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) => {
+                logger.debug(`Client connection error: ${error.message}`);
+                proxyReq.destroy();
+                // Increment failed requests counter on client errors
+                if (metricsTracker) {
+                    metricsTracker.incrementFailedRequests();
+                }
+            });
+            // Handle response errors
+            res.on('error', (error) => {
+                logger.debug(`Response error: ${error.message}`);
+                proxyReq.destroy();
+                // Increment failed requests counter on response errors
+                if (metricsTracker) {
+                    metricsTracker.incrementFailedRequests();
+                }
+            });
+        }
+        catch (error) {
+            // Handle any unexpected errors
+            logger.error(`Unexpected error handling request: ${error.message}`, { error: error.stack });
+            // Increment failed requests counter
+            if (metricsTracker) {
+                metricsTracker.incrementFailedRequests();
+            }
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.end('Internal Server Error');
+            }
+            else {
+                res.end();
+            }
+        }
+    }
+    /**
+     * Apply URL rewriting based on route configuration
+     * Implements Phase 5.2: URL rewriting using route context
+     *
+     * @param req The request with the URL to rewrite
+     * @param route The route configuration containing rewrite rules
+     * @param routeContext Context for template variable resolution
+     * @param logger Logger for debugging information
+     * @returns True if URL was rewritten, false otherwise
+     */
+    static applyUrlRewriting(req, route, routeContext, logger) {
+        // Check if route has URL rewriting configuration
+        if (!route.action.advanced?.urlRewrite) {
+            return false;
+        }
+        const rewriteConfig = route.action.advanced.urlRewrite;
+        // Store original URL for logging
+        const originalUrl = req.url;
+        if (rewriteConfig.pattern && rewriteConfig.target) {
+            try {
+                // Create a RegExp from the pattern with optional flags
+                const regex = new RegExp(rewriteConfig.pattern, rewriteConfig.flags || '');
+                // Apply rewriting with template variable resolution
+                let target = rewriteConfig.target;
+                // Replace template variables in target with values from context
+                target = TemplateUtils.resolveTemplateVariables(target, routeContext);
+                // If onlyRewritePath is set, split URL into path and query parts
+                if (rewriteConfig.onlyRewritePath && req.url) {
+                    const [path, query] = req.url.split('?');
+                    const rewrittenPath = path.replace(regex, target);
+                    req.url = query ? `${rewrittenPath}?${query}` : rewrittenPath;
+                }
+                else {
+                    // Perform the replacement on the entire URL
+                    req.url = req.url?.replace(regex, target);
+                }
+                logger.debug(`URL rewritten: ${originalUrl} -> ${req.url}`);
+                return true;
+            }
+            catch (err) {
+                logger.error(`Error in URL rewriting: ${err}`);
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Apply header modifications from route configuration to request headers
+     * Implements Phase 5.1: Route-based header manipulation for requests
+     */
+    static applyRouteHeaderModifications(route, req, res, logger) {
+        // Check if route has header modifications
+        if (!route.headers) {
+            return;
+        }
+        // Apply request header modifications (these will be sent to the backend)
+        if (route.headers.request && req.headers) {
+            // Create routing context for template resolution
+            const routeContext = {
+                domain: req.headers.host || '',
+                path: req.url || '',
+                clientIp: req.socket.remoteAddress?.replace('::ffff:', '') || '',
+                serverIp: req.socket.localAddress?.replace('::ffff:', '') || '',
+                port: parseInt(req.socket.localPort?.toString() || '0', 10),
+                isTls: !!req.socket.encrypted,
+                headers: req.headers,
+                timestamp: Date.now(),
+                connectionId: `${Date.now()}-${Math.floor(Math.random() * 10000)}`,
+            };
+            for (const [key, value] of Object.entries(route.headers.request)) {
+                // Skip if header already exists and we're not overriding
+                if (req.headers[key.toLowerCase()] && !value.startsWith('!')) {
+                    continue;
+                }
+                // Handle special delete directive (!delete)
+                if (value === '!delete') {
+                    delete req.headers[key.toLowerCase()];
+                    logger.debug(`Deleted request header: ${key}`);
+                    continue;
+                }
+                // Handle forced override (!value)
+                let finalValue;
+                if (value.startsWith('!')) {
+                    // Keep the ! but resolve any templates in the rest
+                    const templateValue = value.substring(1);
+                    finalValue = '!' + TemplateUtils.resolveTemplateVariables(templateValue, routeContext);
+                }
+                else {
+                    // Resolve templates in the entire value
+                    finalValue = TemplateUtils.resolveTemplateVariables(value, routeContext);
+                }
+                // Set the header
+                req.headers[key.toLowerCase()] = finalValue;
+                logger.debug(`Modified request header: ${key}=${finalValue}`);
+            }
+        }
+    }
+    /**
+     * Apply header modifications from route configuration to response headers
+     * Implements Phase 5.1: Route-based header manipulation for responses
+     */
+    static applyResponseHeaderModifications(route, res, logger, routeContext) {
+        // Check if route has response header modifications
+        if (!route.headers?.response) {
+            return;
+        }
+        // Apply response header modifications
+        for (const [key, value] of Object.entries(route.headers.response)) {
+            // Skip if header already exists and we're not overriding
+            if (res.hasHeader(key) && !value.startsWith('!')) {
+                continue;
+            }
+            // Handle special delete directive (!delete)
+            if (value === '!delete') {
+                res.removeHeader(key);
+                logger.debug(`Deleted response header: ${key}`);
+                continue;
+            }
+            // Handle forced override (!value)
+            let finalValue;
+            if (value.startsWith('!') && value !== '!delete') {
+                // Keep the ! but resolve any templates in the rest
+                const templateValue = value.substring(1);
+                finalValue = routeContext
+                    ? '!' + TemplateUtils.resolveTemplateVariables(templateValue, routeContext)
+                    : '!' + templateValue;
+            }
+            else {
+                // Resolve templates in the entire value
+                finalValue = routeContext
+                    ? TemplateUtils.resolveTemplateVariables(value, routeContext)
+                    : value;
+            }
+            // Set the header
+            res.setHeader(key, finalValue);
+            logger.debug(`Modified response header: ${key}=${finalValue}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-request-handler.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/http-request-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/network-proxy/http2-request-handler.d.ts

@@ -0,0 +1,24 @@
+import * as plugins from '../../plugins.js';
+import type { IHttpRouteContext } from '../../core/models/route-context.js';
+import type { ILogger } from './models/types.js';
+import type { IMetricsTracker } from './request-handler.js';
+/**
+ * HTTP/2 Request Handler Helper - handles HTTP/2 streams with specific destinations
+ * This is a helper class for the main RequestHandler
+ */
+export declare class Http2RequestHandler {
+    /**
+     * Handle HTTP/2 stream with direct HTTP/2 backend
+     */
+    static handleHttp2WithHttp2Destination(stream: plugins.http2.ServerHttp2Stream, headers: plugins.http2.IncomingHttpHeaders, destination: {
+        host: string;
+        port: number;
+    }, routeContext: IHttpRouteContext, sessions: Map<string, plugins.http2.ClientHttp2Session>, logger: ILogger, metricsTracker?: IMetricsTracker | null): Promise<void>;
+    /**
+     * Handle HTTP/2 stream with HTTP/1 backend
+     */
+    static handleHttp2WithHttp1Destination(stream: plugins.http2.ServerHttp2Stream, headers: plugins.http2.IncomingHttpHeaders, destination: {
+        host: string;
+        port: number;
+    }, routeContext: IHttpRouteContext, logger: ILogger, metricsTracker?: IMetricsTracker | null): Promise<void>;
+}

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

@@ -0,0 +1,201 @@
+import * as plugins from '../../plugins.js';
+/**
+ * HTTP/2 Request Handler Helper - handles HTTP/2 streams with specific destinations
+ * This is a helper class for the main RequestHandler
+ */
+export class Http2RequestHandler {
+    /**
+     * Handle HTTP/2 stream with direct HTTP/2 backend
+     */
+    static async handleHttp2WithHttp2Destination(stream, headers, destination, routeContext, sessions, logger, metricsTracker) {
+        const key = `${destination.host}:${destination.port}`;
+        // Get or create a client HTTP/2 session
+        let session = sessions.get(key);
+        if (!session || session.closed || session.destroyed) {
+            try {
+                // Connect to the backend HTTP/2 server
+                session = plugins.http2.connect(`http://${destination.host}:${destination.port}`);
+                sessions.set(key, session);
+                // Handle session errors and cleanup
+                session.on('error', (err) => {
+                    logger.error(`HTTP/2 session error to ${key}: ${err.message}`);
+                    sessions.delete(key);
+                });
+                session.on('close', () => {
+                    logger.debug(`HTTP/2 session closed to ${key}`);
+                    sessions.delete(key);
+                });
+            }
+            catch (err) {
+                logger.error(`Failed to establish HTTP/2 session to ${key}: ${err.message}`);
+                stream.respond({ ':status': 502 });
+                stream.end('Bad Gateway: Failed to establish connection to backend');
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+                return;
+            }
+        }
+        try {
+            // Build headers for backend HTTP/2 request
+            const h2Headers = {
+                ':method': headers[':method'],
+                ':path': headers[':path'],
+                ':authority': `${destination.host}:${destination.port}`
+            };
+            // Copy other headers, excluding pseudo-headers
+            for (const [key, value] of Object.entries(headers)) {
+                if (!key.startsWith(':') && typeof value === 'string') {
+                    h2Headers[key] = value;
+                }
+            }
+            logger.debug(`Proxying HTTP/2 request to ${destination.host}:${destination.port}${headers[':path']}`, { method: headers[':method'] });
+            // Create HTTP/2 request stream to the backend
+            const h2Stream = session.request(h2Headers);
+            // Pipe client stream to backend stream
+            stream.pipe(h2Stream);
+            // Handle responses from the backend
+            h2Stream.on('response', (responseHeaders) => {
+                // Map status and headers to client response
+                const resp = {
+                    ':status': responseHeaders[':status']
+                };
+                // Copy non-pseudo headers
+                for (const [key, value] of Object.entries(responseHeaders)) {
+                    if (!key.startsWith(':') && value !== undefined) {
+                        resp[key] = value;
+                    }
+                }
+                // Send headers to client
+                stream.respond(resp);
+                // Pipe backend response to client
+                h2Stream.pipe(stream);
+                // Track successful requests
+                stream.on('end', () => {
+                    if (metricsTracker)
+                        metricsTracker.incrementRequestsServed();
+                    logger.debug(`HTTP/2 request completed: ${headers[':method']} ${headers[':path']} ${responseHeaders[':status']}`, { method: headers[':method'], status: responseHeaders[':status'] });
+                });
+            });
+            // Handle backend errors
+            h2Stream.on('error', (err) => {
+                logger.error(`HTTP/2 stream error: ${err.message}`);
+                // Only send error response if headers haven't been sent
+                if (!stream.headersSent) {
+                    stream.respond({ ':status': 502 });
+                    stream.end(`Bad Gateway: ${err.message}`);
+                }
+                else {
+                    stream.end();
+                }
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+            });
+            // Handle client stream errors
+            stream.on('error', (err) => {
+                logger.debug(`Client HTTP/2 stream error: ${err.message}`);
+                h2Stream.destroy();
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+            });
+        }
+        catch (err) {
+            logger.error(`Error handling HTTP/2 request: ${err.message}`);
+            // Only send error response if headers haven't been sent
+            if (!stream.headersSent) {
+                stream.respond({ ':status': 500 });
+                stream.end('Internal Server Error');
+            }
+            else {
+                stream.end();
+            }
+            if (metricsTracker)
+                metricsTracker.incrementFailedRequests();
+        }
+    }
+    /**
+     * Handle HTTP/2 stream with HTTP/1 backend
+     */
+    static async handleHttp2WithHttp1Destination(stream, headers, destination, routeContext, logger, metricsTracker) {
+        try {
+            // Build headers for HTTP/1 proxy request, excluding HTTP/2 pseudo-headers
+            const outboundHeaders = {};
+            for (const [key, value] of Object.entries(headers)) {
+                if (typeof key === 'string' && typeof value === 'string' && !key.startsWith(':')) {
+                    outboundHeaders[key] = value;
+                }
+            }
+            // Always rewrite host header to match target
+            outboundHeaders.host = `${destination.host}:${destination.port}`;
+            logger.debug(`Proxying HTTP/2 request to HTTP/1 backend ${destination.host}:${destination.port}${headers[':path']}`, { method: headers[':method'] });
+            // Create HTTP/1 proxy request
+            const proxyReq = plugins.http.request({
+                hostname: destination.host,
+                port: destination.port,
+                path: headers[':path'],
+                method: headers[':method'],
+                headers: outboundHeaders
+            }, (proxyRes) => {
+                // Map status and headers back to HTTP/2
+                const responseHeaders = {
+                    ':status': proxyRes.statusCode || 500
+                };
+                // Copy headers from HTTP/1 response to HTTP/2 response
+                for (const [key, value] of Object.entries(proxyRes.headers)) {
+                    if (value !== undefined) {
+                        responseHeaders[key] = value;
+                    }
+                }
+                // Send headers to client
+                stream.respond(responseHeaders);
+                // Pipe HTTP/1 response to HTTP/2 stream
+                proxyRes.pipe(stream);
+                // Clean up when client disconnects
+                stream.on('close', () => proxyReq.destroy());
+                stream.on('error', () => proxyReq.destroy());
+                // Track successful requests
+                stream.on('end', () => {
+                    if (metricsTracker)
+                        metricsTracker.incrementRequestsServed();
+                    logger.debug(`HTTP/2 to HTTP/1 request completed: ${headers[':method']} ${headers[':path']} ${proxyRes.statusCode}`, { method: headers[':method'], status: proxyRes.statusCode });
+                });
+            });
+            // Handle proxy request errors
+            proxyReq.on('error', (err) => {
+                logger.error(`HTTP/1 proxy error: ${err.message}`);
+                // Only send error response if headers haven't been sent
+                if (!stream.headersSent) {
+                    stream.respond({ ':status': 502 });
+                    stream.end(`Bad Gateway: ${err.message}`);
+                }
+                else {
+                    stream.end();
+                }
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+            });
+            // Pipe client stream to proxy request
+            stream.pipe(proxyReq);
+            // Handle client stream errors
+            stream.on('error', (err) => {
+                logger.debug(`Client HTTP/2 stream error: ${err.message}`);
+                proxyReq.destroy();
+                if (metricsTracker)
+                    metricsTracker.incrementFailedRequests();
+            });
+        }
+        catch (err) {
+            logger.error(`Error handling HTTP/2 to HTTP/1 request: ${err.message}`);
+            // Only send error response if headers haven't been sent
+            if (!stream.headersSent) {
+                stream.respond({ ':status': 500 });
+                stream.end('Internal Server Error');
+            }
+            else {
+                stream.end();
+            }
+            if (metricsTracker)
+                metricsTracker.incrementFailedRequests();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http2-request-handler.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/http2-request-handler.ts"],"names":[],"mappings":"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"}