@push.rocks/smartproxy 12.0.0 → 13.1.2

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

@@ -0,0 +1,86 @@
+import * as plugins from '../../plugins.js';
+import type { IDomainConfig } from './domain-config.js';
+import { ForwardingHandler } from '../handlers/base-handler.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): ForwardingHandler | 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/forwarding/config/domain-manager.js

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

@@ -0,0 +1,104 @@
+import type * as plugins from '../../plugins.js';
+/**
+ * The primary forwarding types supported by SmartProxy
+ */
+export type TForwardingType = 'http-only' | 'https-passthrough' | 'https-terminate-to-http' | 'https-terminate-to-https';
+/**
+ * Target configuration for forwarding
+ */
+export interface ITargetConfig {
+    host: string | string[];
+    port: number;
+}
+/**
+ * HTTP-specific options for forwarding
+ */
+export interface IHttpOptions {
+    enabled?: boolean;
+    redirectToHttps?: boolean;
+    headers?: Record<string, string>;
+}
+/**
+ * HTTPS-specific options for forwarding
+ */
+export interface IHttpsOptions {
+    customCert?: {
+        key: string;
+        cert: string;
+    };
+    forwardSni?: boolean;
+}
+/**
+ * ACME certificate handling options
+ */
+export interface IAcmeForwardingOptions {
+    enabled?: boolean;
+    maintenance?: boolean;
+    production?: boolean;
+    forwardChallenges?: {
+        host: string;
+        port: number;
+        useTls?: boolean;
+    };
+}
+/**
+ * Security options for forwarding
+ */
+export interface ISecurityOptions {
+    allowedIps?: string[];
+    blockedIps?: string[];
+    maxConnections?: number;
+}
+/**
+ * Advanced options for forwarding
+ */
+export interface IAdvancedOptions {
+    portRanges?: Array<{
+        from: number;
+        to: number;
+    }>;
+    networkProxyPort?: number;
+    keepAlive?: boolean;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+/**
+ * Unified forwarding configuration interface
+ */
+export interface IForwardConfig {
+    type: TForwardingType;
+    target: ITargetConfig;
+    http?: IHttpOptions;
+    https?: IHttpsOptions;
+    acme?: IAcmeForwardingOptions;
+    security?: ISecurityOptions;
+    advanced?: IAdvancedOptions;
+}
+/**
+ * Event types emitted by forwarding handlers
+ */
+export declare enum ForwardingHandlerEvents {
+    CONNECTED = "connected",
+    DISCONNECTED = "disconnected",
+    ERROR = "error",
+    DATA_FORWARDED = "data-forwarded",
+    HTTP_REQUEST = "http-request",
+    HTTP_RESPONSE = "http-response",
+    CERTIFICATE_NEEDED = "certificate-needed",
+    CERTIFICATE_LOADED = "certificate-loaded"
+}
+/**
+ * Base interface for forwarding handlers
+ */
+export interface IForwardingHandler extends plugins.EventEmitter {
+    initialize(): Promise<void>;
+    handleConnection(socket: plugins.net.Socket): void;
+    handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
+}
+/**
+ * Helper function types for common forwarding patterns
+ */
+export declare const httpOnly: (partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, "target">) => IForwardConfig;
+export declare const tlsTerminateToHttp: (partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, "target">) => IForwardConfig;
+export declare const tlsTerminateToHttps: (partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, "target">) => IForwardConfig;
+export declare const httpsPassthrough: (partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, "target">) => IForwardConfig;

package/dist_ts/forwarding/config/forwarding-types.js

@@ -0,0 +1,50 @@
+/**
+ * Event types emitted by forwarding handlers
+ */
+export var ForwardingHandlerEvents;
+(function (ForwardingHandlerEvents) {
+    ForwardingHandlerEvents["CONNECTED"] = "connected";
+    ForwardingHandlerEvents["DISCONNECTED"] = "disconnected";
+    ForwardingHandlerEvents["ERROR"] = "error";
+    ForwardingHandlerEvents["DATA_FORWARDED"] = "data-forwarded";
+    ForwardingHandlerEvents["HTTP_REQUEST"] = "http-request";
+    ForwardingHandlerEvents["HTTP_RESPONSE"] = "http-response";
+    ForwardingHandlerEvents["CERTIFICATE_NEEDED"] = "certificate-needed";
+    ForwardingHandlerEvents["CERTIFICATE_LOADED"] = "certificate-loaded";
+})(ForwardingHandlerEvents || (ForwardingHandlerEvents = {}));
+/**
+ * Helper function types for common forwarding patterns
+ */
+export const httpOnly = (partialConfig) => ({
+    type: 'http-only',
+    target: partialConfig.target,
+    http: { enabled: true, ...(partialConfig.http || {}) },
+    ...(partialConfig.security ? { security: partialConfig.security } : {}),
+    ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+});
+export const tlsTerminateToHttp = (partialConfig) => ({
+    type: 'https-terminate-to-http',
+    target: partialConfig.target,
+    https: { ...(partialConfig.https || {}) },
+    acme: { enabled: true, maintenance: true, ...(partialConfig.acme || {}) },
+    http: { enabled: true, redirectToHttps: true, ...(partialConfig.http || {}) },
+    ...(partialConfig.security ? { security: partialConfig.security } : {}),
+    ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+});
+export const tlsTerminateToHttps = (partialConfig) => ({
+    type: 'https-terminate-to-https',
+    target: partialConfig.target,
+    https: { ...(partialConfig.https || {}) },
+    acme: { enabled: true, maintenance: true, ...(partialConfig.acme || {}) },
+    http: { enabled: true, redirectToHttps: true, ...(partialConfig.http || {}) },
+    ...(partialConfig.security ? { security: partialConfig.security } : {}),
+    ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+});
+export const httpsPassthrough = (partialConfig) => ({
+    type: 'https-passthrough',
+    target: partialConfig.target,
+    https: { forwardSni: true, ...(partialConfig.https || {}) },
+    ...(partialConfig.security ? { security: partialConfig.security } : {}),
+    ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/forwarding/config/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Forwarding configuration exports
+ */
+export * from './forwarding-types.js';
+export * from './domain-config.js';
+export * from './domain-manager.js';

package/dist_ts/forwarding/config/index.js

@@ -0,0 +1,7 @@
+/**
+ * Forwarding configuration exports
+ */
+export * from './forwarding-types.js';
+export * from './domain-config.js';
+export * from './domain-manager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9mb3J3YXJkaW5nL2NvbmZpZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHFCQUFxQixDQUFDIn0=

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

@@ -0,0 +1,25 @@
+import type { IForwardConfig } from '../config/forwarding-types.js';
+import { ForwardingHandler } from '../handlers/base-handler.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): ForwardingHandler;
+    /**
+     * 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;
+}