@push.rocks/smartproxy 10.2.0 → 12.0.0

package/dist_ts/smartproxy/forwarding/forwarding.factory.js

@@ -0,0 +1,137 @@
+import { HttpForwardingHandler } from './http.handler.js';
+import { HttpsPassthroughHandler } from './https-passthrough.handler.js';
+import { HttpsTerminateToHttpHandler } from './https-terminate-to-http.handler.js';
+import { HttpsTerminateToHttpsHandler } from './https-terminate-to-https.handler.js';
+/**
+ * Factory for creating forwarding handlers based on the configuration type
+ */
+export class ForwardingHandlerFactory {
+    /**
+     * Create a forwarding handler based on the configuration
+     * @param config The forwarding configuration
+     * @returns The appropriate forwarding handler
+     */
+    static createHandler(config) {
+        // Create the appropriate handler based on the forwarding type
+        switch (config.type) {
+            case 'http-only':
+                return new HttpForwardingHandler(config);
+            case 'https-passthrough':
+                return new HttpsPassthroughHandler(config);
+            case 'https-terminate-to-http':
+                return new HttpsTerminateToHttpHandler(config);
+            case 'https-terminate-to-https':
+                return new HttpsTerminateToHttpsHandler(config);
+            default:
+                // Type system should prevent this, but just in case:
+                throw new Error(`Unknown forwarding type: ${config.type}`);
+        }
+    }
+    /**
+     * Apply default values to a forwarding configuration based on its type
+     * @param config The original forwarding configuration
+     * @returns A configuration with defaults applied
+     */
+    static applyDefaults(config) {
+        // Create a deep copy of the configuration
+        const result = JSON.parse(JSON.stringify(config));
+        // Apply defaults based on forwarding type
+        switch (config.type) {
+            case 'http-only':
+                // Set defaults for HTTP-only mode
+                result.http = {
+                    enabled: true,
+                    ...config.http
+                };
+                break;
+            case 'https-passthrough':
+                // Set defaults for HTTPS passthrough
+                result.https = {
+                    forwardSni: true,
+                    ...config.https
+                };
+                // SNI forwarding doesn't do HTTP
+                result.http = {
+                    enabled: false,
+                    ...config.http
+                };
+                break;
+            case 'https-terminate-to-http':
+                // Set defaults for HTTPS termination to HTTP
+                result.https = {
+                    ...config.https
+                };
+                // Support HTTP access by default in this mode
+                result.http = {
+                    enabled: true,
+                    redirectToHttps: true,
+                    ...config.http
+                };
+                // Enable ACME by default
+                result.acme = {
+                    enabled: true,
+                    maintenance: true,
+                    ...config.acme
+                };
+                break;
+            case 'https-terminate-to-https':
+                // Similar to terminate-to-http but with different target handling
+                result.https = {
+                    ...config.https
+                };
+                result.http = {
+                    enabled: true,
+                    redirectToHttps: true,
+                    ...config.http
+                };
+                result.acme = {
+                    enabled: true,
+                    maintenance: true,
+                    ...config.acme
+                };
+                break;
+        }
+        return result;
+    }
+    /**
+     * Validate a forwarding configuration
+     * @param config The configuration to validate
+     * @throws Error if the configuration is invalid
+     */
+    static validateConfig(config) {
+        // Validate common properties
+        if (!config.target) {
+            throw new Error('Forwarding configuration must include a target');
+        }
+        if (!config.target.host || (Array.isArray(config.target.host) && config.target.host.length === 0)) {
+            throw new Error('Target must include a host or array of hosts');
+        }
+        if (!config.target.port || config.target.port <= 0 || config.target.port > 65535) {
+            throw new Error('Target must include a valid port (1-65535)');
+        }
+        // Type-specific validation
+        switch (config.type) {
+            case 'http-only':
+                // HTTP-only needs http.enabled to be true
+                if (config.http?.enabled === false) {
+                    throw new Error('HTTP-only forwarding must have HTTP enabled');
+                }
+                break;
+            case 'https-passthrough':
+                // HTTPS passthrough doesn't support HTTP
+                if (config.http?.enabled === true) {
+                    throw new Error('HTTPS passthrough does not support HTTP');
+                }
+                // HTTPS passthrough doesn't work with ACME
+                if (config.acme?.enabled === true) {
+                    throw new Error('HTTPS passthrough does not support ACME');
+                }
+                break;
+            case 'https-terminate-to-http':
+            case 'https-terminate-to-https':
+                // These modes support all options, nothing specific to validate
+                break;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartproxy/forwarding/forwarding.handler.d.ts

@@ -0,0 +1,55 @@
+import * as plugins from '../../plugins.js';
+import type { IForwardConfig, IForwardingHandler } from '../types/forwarding.types.js';
+/**
+ * Base class for all forwarding handlers
+ */
+export declare abstract class ForwardingHandler extends plugins.EventEmitter implements IForwardingHandler {
+    protected config: IForwardConfig;
+    /**
+     * Create a new ForwardingHandler
+     * @param config The forwarding configuration
+     */
+    constructor(config: IForwardConfig);
+    /**
+     * Initialize the handler
+     * Base implementation does nothing, subclasses should override as needed
+     */
+    initialize(): Promise<void>;
+    /**
+     * Handle a new socket connection
+     * @param socket The incoming socket connection
+     */
+    abstract handleConnection(socket: plugins.net.Socket): void;
+    /**
+     * Handle an HTTP request
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    abstract handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
+    /**
+     * Get a target from the configuration, supporting round-robin selection
+     * @returns A resolved target object with host and port
+     */
+    protected getTargetFromConfig(): {
+        host: string;
+        port: number;
+    };
+    /**
+     * Redirect an HTTP request to HTTPS
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    protected redirectToHttps(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
+    /**
+     * Apply custom headers from configuration
+     * @param headers The original headers
+     * @param variables Variables to replace in the headers
+     * @returns The headers with custom values applied
+     */
+    protected applyCustomHeaders(headers: Record<string, string | string[] | undefined>, variables: Record<string, string>): Record<string, string | string[] | undefined>;
+    /**
+     * Get the timeout for this connection from configuration
+     * @returns Timeout in milliseconds
+     */
+    protected getTimeout(): number;
+}

package/dist_ts/smartproxy/forwarding/forwarding.handler.js

@@ -0,0 +1,94 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandlerEvents } from '../types/forwarding.types.js';
+/**
+ * Base class for all forwarding handlers
+ */
+export class ForwardingHandler extends plugins.EventEmitter {
+    /**
+     * Create a new ForwardingHandler
+     * @param config The forwarding configuration
+     */
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    /**
+     * Initialize the handler
+     * Base implementation does nothing, subclasses should override as needed
+     */
+    async initialize() {
+        // Base implementation - no initialization needed
+    }
+    /**
+     * Get a target from the configuration, supporting round-robin selection
+     * @returns A resolved target object with host and port
+     */
+    getTargetFromConfig() {
+        const { target } = this.config;
+        // Handle round-robin host selection
+        if (Array.isArray(target.host)) {
+            if (target.host.length === 0) {
+                throw new Error('No target hosts specified');
+            }
+            // Simple round-robin selection
+            const randomIndex = Math.floor(Math.random() * target.host.length);
+            return {
+                host: target.host[randomIndex],
+                port: target.port
+            };
+        }
+        // Single host
+        return {
+            host: target.host,
+            port: target.port
+        };
+    }
+    /**
+     * Redirect an HTTP request to HTTPS
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    redirectToHttps(req, res) {
+        const host = req.headers.host || '';
+        const path = req.url || '/';
+        const redirectUrl = `https://${host}${path}`;
+        res.writeHead(301, {
+            'Location': redirectUrl,
+            'Cache-Control': 'no-cache'
+        });
+        res.end(`Redirecting to ${redirectUrl}`);
+        this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
+            statusCode: 301,
+            headers: { 'Location': redirectUrl },
+            size: 0
+        });
+    }
+    /**
+     * Apply custom headers from configuration
+     * @param headers The original headers
+     * @param variables Variables to replace in the headers
+     * @returns The headers with custom values applied
+     */
+    applyCustomHeaders(headers, variables) {
+        const customHeaders = this.config.advanced?.headers || {};
+        const result = { ...headers };
+        // Apply custom headers with variable substitution
+        for (const [key, value] of Object.entries(customHeaders)) {
+            let processedValue = value;
+            // Replace variables in the header value
+            for (const [varName, varValue] of Object.entries(variables)) {
+                processedValue = processedValue.replace(`{${varName}}`, varValue);
+            }
+            result[key] = processedValue;
+        }
+        return result;
+    }
+    /**
+     * Get the timeout for this connection from configuration
+     * @returns Timeout in milliseconds
+     */
+    getTimeout() {
+        return this.config.advanced?.timeout || 60000; // Default: 60 seconds
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartproxy/forwarding/http.handler.d.ts

@@ -0,0 +1,25 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './forwarding.handler.js';
+import type { IForwardConfig } from '../types/forwarding.types.js';
+/**
+ * Handler for HTTP-only forwarding
+ */
+export declare class HttpForwardingHandler extends ForwardingHandler {
+    /**
+     * Create a new HTTP forwarding handler
+     * @param config The forwarding configuration
+     */
+    constructor(config: IForwardConfig);
+    /**
+     * Handle a raw socket connection
+     * HTTP handler doesn't do much with raw sockets as it mainly processes
+     * parsed HTTP requests
+     */
+    handleConnection(socket: plugins.net.Socket): void;
+    /**
+     * Handle an HTTP request
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
+}

package/dist_ts/smartproxy/forwarding/http.handler.js

@@ -0,0 +1,123 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './forwarding.handler.js';
+import { ForwardingHandlerEvents } from '../types/forwarding.types.js';
+/**
+ * Handler for HTTP-only forwarding
+ */
+export class HttpForwardingHandler extends ForwardingHandler {
+    /**
+     * Create a new HTTP forwarding handler
+     * @param config The forwarding configuration
+     */
+    constructor(config) {
+        super(config);
+        // Validate that this is an HTTP-only configuration
+        if (config.type !== 'http-only') {
+            throw new Error(`Invalid configuration type for HttpForwardingHandler: ${config.type}`);
+        }
+    }
+    /**
+     * Handle a raw socket connection
+     * HTTP handler doesn't do much with raw sockets as it mainly processes
+     * parsed HTTP requests
+     */
+    handleConnection(socket) {
+        // For HTTP, we mainly handle parsed requests, but we can still set up
+        // some basic connection tracking
+        const remoteAddress = socket.remoteAddress || 'unknown';
+        socket.on('close', (hadError) => {
+            this.emit(ForwardingHandlerEvents.DISCONNECTED, {
+                remoteAddress,
+                hadError
+            });
+        });
+        socket.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: error.message
+            });
+        });
+        this.emit(ForwardingHandlerEvents.CONNECTED, {
+            remoteAddress
+        });
+    }
+    /**
+     * Handle an HTTP request
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleHttpRequest(req, res) {
+        // Get the target from configuration
+        const target = this.getTargetFromConfig();
+        // Create a custom headers object with variables for substitution
+        const variables = {
+            clientIp: req.socket.remoteAddress || 'unknown'
+        };
+        // Prepare headers, merging with any custom headers from config
+        const headers = this.applyCustomHeaders(req.headers, variables);
+        // Create the proxy request options
+        const options = {
+            hostname: target.host,
+            port: target.port,
+            path: req.url,
+            method: req.method,
+            headers
+        };
+        // Create the proxy request
+        const proxyReq = plugins.http.request(options, (proxyRes) => {
+            // Copy status code and headers from the proxied response
+            res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+            // Pipe the proxy response to the client response
+            proxyRes.pipe(res);
+            // Track bytes for logging
+            let responseSize = 0;
+            proxyRes.on('data', (chunk) => {
+                responseSize += chunk.length;
+            });
+            proxyRes.on('end', () => {
+                this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
+                    statusCode: proxyRes.statusCode,
+                    headers: proxyRes.headers,
+                    size: responseSize
+                });
+            });
+        });
+        // Handle errors in the proxy request
+        proxyReq.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress: req.socket.remoteAddress,
+                error: `Proxy request error: ${error.message}`
+            });
+            // Send an error response if headers haven't been sent yet
+            if (!res.headersSent) {
+                res.writeHead(502, { 'Content-Type': 'text/plain' });
+                res.end(`Error forwarding request: ${error.message}`);
+            }
+            else {
+                // Just end the response if headers have already been sent
+                res.end();
+            }
+        });
+        // Track request details for logging
+        let requestSize = 0;
+        req.on('data', (chunk) => {
+            requestSize += chunk.length;
+        });
+        // Log the request
+        this.emit(ForwardingHandlerEvents.HTTP_REQUEST, {
+            method: req.method,
+            url: req.url,
+            headers: req.headers,
+            remoteAddress: req.socket.remoteAddress,
+            target: `${target.host}:${target.port}`
+        });
+        // Pipe the client request to the proxy request
+        if (req.readable) {
+            req.pipe(proxyReq);
+        }
+        else {
+            proxyReq.end();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartproxy/forwarding/https-passthrough.handler.d.ts

@@ -0,0 +1,24 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './forwarding.handler.js';
+import type { IForwardConfig } from '../types/forwarding.types.js';
+/**
+ * Handler for HTTPS passthrough (SNI forwarding without termination)
+ */
+export declare class HttpsPassthroughHandler extends ForwardingHandler {
+    /**
+     * Create a new HTTPS passthrough handler
+     * @param config The forwarding configuration
+     */
+    constructor(config: IForwardConfig);
+    /**
+     * Handle a TLS/SSL socket connection by forwarding it without termination
+     * @param clientSocket The incoming socket from the client
+     */
+    handleConnection(clientSocket: plugins.net.Socket): void;
+    /**
+     * Handle an HTTP request - HTTPS passthrough doesn't support HTTP
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
+}

package/dist_ts/smartproxy/forwarding/https-passthrough.handler.js

@@ -0,0 +1,154 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './forwarding.handler.js';
+import { ForwardingHandlerEvents } from '../types/forwarding.types.js';
+/**
+ * Handler for HTTPS passthrough (SNI forwarding without termination)
+ */
+export class HttpsPassthroughHandler extends ForwardingHandler {
+    /**
+     * Create a new HTTPS passthrough handler
+     * @param config The forwarding configuration
+     */
+    constructor(config) {
+        super(config);
+        // Validate that this is an HTTPS passthrough configuration
+        if (config.type !== 'https-passthrough') {
+            throw new Error(`Invalid configuration type for HttpsPassthroughHandler: ${config.type}`);
+        }
+    }
+    /**
+     * Handle a TLS/SSL socket connection by forwarding it without termination
+     * @param clientSocket The incoming socket from the client
+     */
+    handleConnection(clientSocket) {
+        // Get the target from configuration
+        const target = this.getTargetFromConfig();
+        // Log the connection
+        const remoteAddress = clientSocket.remoteAddress || 'unknown';
+        const remotePort = clientSocket.remotePort || 0;
+        this.emit(ForwardingHandlerEvents.CONNECTED, {
+            remoteAddress,
+            remotePort,
+            target: `${target.host}:${target.port}`
+        });
+        // Create a connection to the target server
+        const serverSocket = plugins.net.connect(target.port, target.host);
+        // Handle errors on the server socket
+        serverSocket.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: `Target connection error: ${error.message}`
+            });
+            // Close the client socket if it's still open
+            if (!clientSocket.destroyed) {
+                clientSocket.destroy();
+            }
+        });
+        // Handle errors on the client socket
+        clientSocket.on('error', (error) => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: `Client connection error: ${error.message}`
+            });
+            // Close the server socket if it's still open
+            if (!serverSocket.destroyed) {
+                serverSocket.destroy();
+            }
+        });
+        // Track data transfer for logging
+        let bytesSent = 0;
+        let bytesReceived = 0;
+        // Forward data from client to server
+        clientSocket.on('data', (data) => {
+            bytesSent += data.length;
+            // Check if server socket is writable
+            if (serverSocket.writable) {
+                const flushed = serverSocket.write(data);
+                // Handle backpressure
+                if (!flushed) {
+                    clientSocket.pause();
+                    serverSocket.once('drain', () => {
+                        clientSocket.resume();
+                    });
+                }
+            }
+            this.emit(ForwardingHandlerEvents.DATA_FORWARDED, {
+                direction: 'outbound',
+                bytes: data.length,
+                total: bytesSent
+            });
+        });
+        // Forward data from server to client
+        serverSocket.on('data', (data) => {
+            bytesReceived += data.length;
+            // Check if client socket is writable
+            if (clientSocket.writable) {
+                const flushed = clientSocket.write(data);
+                // Handle backpressure
+                if (!flushed) {
+                    serverSocket.pause();
+                    clientSocket.once('drain', () => {
+                        serverSocket.resume();
+                    });
+                }
+            }
+            this.emit(ForwardingHandlerEvents.DATA_FORWARDED, {
+                direction: 'inbound',
+                bytes: data.length,
+                total: bytesReceived
+            });
+        });
+        // Handle connection close
+        const handleClose = () => {
+            if (!clientSocket.destroyed) {
+                clientSocket.destroy();
+            }
+            if (!serverSocket.destroyed) {
+                serverSocket.destroy();
+            }
+            this.emit(ForwardingHandlerEvents.DISCONNECTED, {
+                remoteAddress,
+                bytesSent,
+                bytesReceived
+            });
+        };
+        // Set up close handlers
+        clientSocket.on('close', handleClose);
+        serverSocket.on('close', handleClose);
+        // Set timeouts
+        const timeout = this.getTimeout();
+        clientSocket.setTimeout(timeout);
+        serverSocket.setTimeout(timeout);
+        // Handle timeouts
+        clientSocket.on('timeout', () => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: 'Client connection timeout'
+            });
+            handleClose();
+        });
+        serverSocket.on('timeout', () => {
+            this.emit(ForwardingHandlerEvents.ERROR, {
+                remoteAddress,
+                error: 'Server connection timeout'
+            });
+            handleClose();
+        });
+    }
+    /**
+     * Handle an HTTP request - HTTPS passthrough doesn't support HTTP
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    handleHttpRequest(req, res) {
+        // HTTPS passthrough doesn't support HTTP requests
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('HTTP not supported for this domain');
+        this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
+            statusCode: 404,
+            headers: { 'Content-Type': 'text/plain' },
+            size: 'HTTP not supported for this domain'.length
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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