@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/forwarding/factory/forwarding-factory.js

@@ -0,0 +1,138 @@
+import { ForwardingHandler } from '../handlers/base-handler.js';
+import { HttpForwardingHandler } from '../handlers/http-handler.js';
+import { HttpsPassthroughHandler } from '../handlers/https-passthrough-handler.js';
+import { HttpsTerminateToHttpHandler } from '../handlers/https-terminate-to-http-handler.js';
+import { HttpsTerminateToHttpsHandler } from '../handlers/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/forwarding/factory/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Forwarding factory implementations
+ */
+export { ForwardingHandlerFactory } from './forwarding-factory.js';

package/dist_ts/forwarding/factory/index.js

@@ -0,0 +1,5 @@
+/**
+ * Forwarding factory implementations
+ */
+export { ForwardingHandlerFactory } from './forwarding-factory.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9mb3J3YXJkaW5nL2ZhY3RvcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQyJ9

package/dist_ts/forwarding/handlers/base-handler.d.ts

@@ -0,0 +1,55 @@
+import * as plugins from '../../plugins.js';
+import type { IForwardConfig, IForwardingHandler } from '../config/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/forwarding/handlers/base-handler.js

@@ -0,0 +1,94 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandlerEvents } from '../config/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/forwarding/handlers/http-handler.d.ts

@@ -0,0 +1,30 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './base-handler.js';
+import type { IForwardConfig } from '../config/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);
+    /**
+     * Initialize the handler
+     * HTTP handler doesn't need special initialization
+     */
+    initialize(): Promise<void>;
+    /**
+     * 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/forwarding/handlers/http-handler.js

@@ -0,0 +1,131 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './base-handler.js';
+import { ForwardingHandlerEvents } from '../config/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}`);
+        }
+    }
+    /**
+     * Initialize the handler
+     * HTTP handler doesn't need special initialization
+     */
+    async initialize() {
+        // Basic initialization from parent class
+        await super.initialize();
+    }
+    /**
+     * 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/forwarding/handlers/https-passthrough-handler.d.ts

@@ -0,0 +1,29 @@
+import * as plugins from '../../plugins.js';
+import { ForwardingHandler } from './base-handler.js';
+import type { IForwardConfig } from '../config/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);
+    /**
+     * Initialize the handler
+     * HTTPS passthrough handler doesn't need special initialization
+     */
+    initialize(): Promise<void>;
+    /**
+     * 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;
+}