@push.rocks/smartproxy 19.3.2 → 19.3.4

package/dist_ts/smartproxy/forwarding/domain-manager.d.ts

@@ -1,86 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IDomainConfig } from './domain-config.js';
-import type { IForwardingHandler } from '../types/forwarding.types.js';
-/**
- * Events emitted by the DomainManager
- */
-export declare enum DomainManagerEvents {
-    DOMAIN_ADDED = "domain-added",
-    DOMAIN_REMOVED = "domain-removed",
-    DOMAIN_MATCHED = "domain-matched",
-    DOMAIN_MATCH_FAILED = "domain-match-failed",
-    CERTIFICATE_NEEDED = "certificate-needed",
-    CERTIFICATE_LOADED = "certificate-loaded",
-    ERROR = "error"
-}
-/**
- * Manages domains and their forwarding handlers
- */
-export declare class DomainManager extends plugins.EventEmitter {
-    private domainConfigs;
-    private domainHandlers;
-    /**
-     * Create a new DomainManager
-     * @param initialDomains Optional initial domain configurations
-     */
-    constructor(initialDomains?: IDomainConfig[]);
-    /**
-     * Set or replace all domain configurations
-     * @param configs Array of domain configurations
-     */
-    setDomainConfigs(configs: IDomainConfig[]): Promise<void>;
-    /**
-     * Add a new domain configuration
-     * @param config The domain configuration to add
-     */
-    addDomainConfig(config: IDomainConfig): Promise<void>;
-    /**
-     * Remove a domain configuration
-     * @param domain The domain to remove
-     * @returns True if the domain was found and removed
-     */
-    removeDomainConfig(domain: string): boolean;
-    /**
-     * Find the handler for a domain
-     * @param domain The domain to find a handler for
-     * @returns The handler or undefined if no match
-     */
-    findHandlerForDomain(domain: string): IForwardingHandler | undefined;
-    /**
-     * Handle a connection for a domain
-     * @param domain The domain
-     * @param socket The client socket
-     * @returns True if the connection was handled
-     */
-    handleConnection(domain: string, socket: plugins.net.Socket): boolean;
-    /**
-     * Handle an HTTP request for a domain
-     * @param domain The domain
-     * @param req The HTTP request
-     * @param res The HTTP response
-     * @returns True if the request was handled
-     */
-    handleHttpRequest(domain: string, req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): boolean;
-    /**
-     * Create handlers for a domain configuration
-     * @param config The domain configuration
-     */
-    private createHandlersForDomain;
-    /**
-     * Set up event forwarding from a handler
-     * @param handler The handler
-     * @param config The domain configuration for this handler
-     */
-    private setupHandlerEvents;
-    /**
-     * Find a handler for a domain using wildcard matching
-     * @param domain The domain to find a handler for
-     * @returns The handler or undefined if no match
-     */
-    private findWildcardHandler;
-    /**
-     * Get all domain configurations
-     * @returns Array of domain configurations
-     */
-    getDomainConfigs(): IDomainConfig[];
-}

package/dist_ts/smartproxy/forwarding/domain-manager.js

@@ -1,241 +0,0 @@
-import * as plugins from '../../plugins.js';
-import { ForwardingHandlerEvents } from '../types/forwarding.types.js';
-import { ForwardingHandlerFactory } from './forwarding.factory.js';
-/**
- * Events emitted by the DomainManager
- */
-export var DomainManagerEvents;
-(function (DomainManagerEvents) {
-    DomainManagerEvents["DOMAIN_ADDED"] = "domain-added";
-    DomainManagerEvents["DOMAIN_REMOVED"] = "domain-removed";
-    DomainManagerEvents["DOMAIN_MATCHED"] = "domain-matched";
-    DomainManagerEvents["DOMAIN_MATCH_FAILED"] = "domain-match-failed";
-    DomainManagerEvents["CERTIFICATE_NEEDED"] = "certificate-needed";
-    DomainManagerEvents["CERTIFICATE_LOADED"] = "certificate-loaded";
-    DomainManagerEvents["ERROR"] = "error";
-})(DomainManagerEvents || (DomainManagerEvents = {}));
-/**
- * Manages domains and their forwarding handlers
- */
-export class DomainManager extends plugins.EventEmitter {
-    /**
-     * Create a new DomainManager
-     * @param initialDomains Optional initial domain configurations
-     */
-    constructor(initialDomains) {
-        super();
-        this.domainConfigs = [];
-        this.domainHandlers = new Map();
-        if (initialDomains) {
-            this.setDomainConfigs(initialDomains);
-        }
-    }
-    /**
-     * Set or replace all domain configurations
-     * @param configs Array of domain configurations
-     */
-    async setDomainConfigs(configs) {
-        // Clear existing handlers
-        this.domainHandlers.clear();
-        // Store new configurations
-        this.domainConfigs = [...configs];
-        // Initialize handlers for each domain
-        for (const config of this.domainConfigs) {
-            await this.createHandlersForDomain(config);
-        }
-    }
-    /**
-     * Add a new domain configuration
-     * @param config The domain configuration to add
-     */
-    async addDomainConfig(config) {
-        // Check if any of these domains already exist
-        for (const domain of config.domains) {
-            if (this.domainHandlers.has(domain)) {
-                // Remove existing handler for this domain
-                this.domainHandlers.delete(domain);
-            }
-        }
-        // Add the new configuration
-        this.domainConfigs.push(config);
-        // Create handlers for the new domain
-        await this.createHandlersForDomain(config);
-        this.emit(DomainManagerEvents.DOMAIN_ADDED, {
-            domains: config.domains,
-            forwardingType: config.forwarding.type
-        });
-    }
-    /**
-     * Remove a domain configuration
-     * @param domain The domain to remove
-     * @returns True if the domain was found and removed
-     */
-    removeDomainConfig(domain) {
-        // Find the config that includes this domain
-        const index = this.domainConfigs.findIndex(config => config.domains.includes(domain));
-        if (index === -1) {
-            return false;
-        }
-        // Get the config
-        const config = this.domainConfigs[index];
-        // Remove all handlers for this config
-        for (const domainName of config.domains) {
-            this.domainHandlers.delete(domainName);
-        }
-        // Remove the config
-        this.domainConfigs.splice(index, 1);
-        this.emit(DomainManagerEvents.DOMAIN_REMOVED, {
-            domains: config.domains
-        });
-        return true;
-    }
-    /**
-     * Find the handler for a domain
-     * @param domain The domain to find a handler for
-     * @returns The handler or undefined if no match
-     */
-    findHandlerForDomain(domain) {
-        // Try exact match
-        if (this.domainHandlers.has(domain)) {
-            return this.domainHandlers.get(domain);
-        }
-        // Try wildcard matches
-        const wildcardHandler = this.findWildcardHandler(domain);
-        if (wildcardHandler) {
-            return wildcardHandler;
-        }
-        // No match found
-        return undefined;
-    }
-    /**
-     * Handle a connection for a domain
-     * @param domain The domain
-     * @param socket The client socket
-     * @returns True if the connection was handled
-     */
-    handleConnection(domain, socket) {
-        const handler = this.findHandlerForDomain(domain);
-        if (!handler) {
-            this.emit(DomainManagerEvents.DOMAIN_MATCH_FAILED, {
-                domain,
-                remoteAddress: socket.remoteAddress
-            });
-            return false;
-        }
-        this.emit(DomainManagerEvents.DOMAIN_MATCHED, {
-            domain,
-            handlerType: handler.constructor.name,
-            remoteAddress: socket.remoteAddress
-        });
-        // Handle the connection
-        handler.handleConnection(socket);
-        return true;
-    }
-    /**
-     * Handle an HTTP request for a domain
-     * @param domain The domain
-     * @param req The HTTP request
-     * @param res The HTTP response
-     * @returns True if the request was handled
-     */
-    handleHttpRequest(domain, req, res) {
-        const handler = this.findHandlerForDomain(domain);
-        if (!handler) {
-            this.emit(DomainManagerEvents.DOMAIN_MATCH_FAILED, {
-                domain,
-                remoteAddress: req.socket.remoteAddress
-            });
-            return false;
-        }
-        this.emit(DomainManagerEvents.DOMAIN_MATCHED, {
-            domain,
-            handlerType: handler.constructor.name,
-            remoteAddress: req.socket.remoteAddress
-        });
-        // Handle the request
-        handler.handleHttpRequest(req, res);
-        return true;
-    }
-    /**
-     * Create handlers for a domain configuration
-     * @param config The domain configuration
-     */
-    async createHandlersForDomain(config) {
-        try {
-            // Create a handler for this forwarding configuration
-            const handler = ForwardingHandlerFactory.createHandler(config.forwarding);
-            // Initialize the handler
-            await handler.initialize();
-            // Set up event forwarding
-            this.setupHandlerEvents(handler, config);
-            // Store the handler for each domain in the config
-            for (const domain of config.domains) {
-                this.domainHandlers.set(domain, handler);
-            }
-        }
-        catch (error) {
-            this.emit(DomainManagerEvents.ERROR, {
-                domains: config.domains,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
-    /**
-     * Set up event forwarding from a handler
-     * @param handler The handler
-     * @param config The domain configuration for this handler
-     */
-    setupHandlerEvents(handler, config) {
-        // Forward relevant events
-        handler.on(ForwardingHandlerEvents.CERTIFICATE_NEEDED, (data) => {
-            this.emit(DomainManagerEvents.CERTIFICATE_NEEDED, {
-                ...data,
-                domains: config.domains
-            });
-        });
-        handler.on(ForwardingHandlerEvents.CERTIFICATE_LOADED, (data) => {
-            this.emit(DomainManagerEvents.CERTIFICATE_LOADED, {
-                ...data,
-                domains: config.domains
-            });
-        });
-        handler.on(ForwardingHandlerEvents.ERROR, (data) => {
-            this.emit(DomainManagerEvents.ERROR, {
-                ...data,
-                domains: config.domains
-            });
-        });
-    }
-    /**
-     * Find a handler for a domain using wildcard matching
-     * @param domain The domain to find a handler for
-     * @returns The handler or undefined if no match
-     */
-    findWildcardHandler(domain) {
-        // Exact match already checked in findHandlerForDomain
-        // Try subdomain wildcard (*.example.com)
-        if (domain.includes('.')) {
-            const parts = domain.split('.');
-            if (parts.length > 2) {
-                const wildcardDomain = `*.${parts.slice(1).join('.')}`;
-                if (this.domainHandlers.has(wildcardDomain)) {
-                    return this.domainHandlers.get(wildcardDomain);
-                }
-            }
-        }
-        // Try full wildcard
-        if (this.domainHandlers.has('*')) {
-            return this.domainHandlers.get('*');
-        }
-        // No match found
-        return undefined;
-    }
-    /**
-     * Get all domain configurations
-     * @returns Array of domain configurations
-     */
-    getDomainConfigs() {
-        return [...this.domainConfigs];
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,24 +0,0 @@
-import type { IForwardConfig, IForwardingHandler } from '../types/forwarding.types.js';
-/**
- * Factory for creating forwarding handlers based on the configuration type
- */
-export declare class ForwardingHandlerFactory {
-    /**
-     * Create a forwarding handler based on the configuration
-     * @param config The forwarding configuration
-     * @returns The appropriate forwarding handler
-     */
-    static createHandler(config: IForwardConfig): IForwardingHandler;
-    /**
-     * 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: IForwardConfig): IForwardConfig;
-    /**
-     * Validate a forwarding configuration
-     * @param config The configuration to validate
-     * @throws Error if the configuration is invalid
-     */
-    static validateConfig(config: IForwardConfig): void;
-}

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

@@ -1,137 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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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