@push.rocks/smartproxy 13.1.3 → 15.0.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '13.1.3',
-    description: 'A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, dynamic routing with authentication options, and automatic ACME certificate management.'
+    version: '15.0.0',
+    description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLG1PQUFtTztDQUNqUCxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=

package/dist_ts/proxies/smart-proxy/domain-config-manager.d.ts

@@ -1,6 +1,7 @@
 import type { IDomainConfig, ISmartProxyOptions } from './models/interfaces.js';
 import type { TForwardingType } from '../../forwarding/config/forwarding-types.js';
 import type { ForwardingHandler } from '../../forwarding/handlers/base-handler.js';
+import { RouteManager } from './route-manager.js';
 /**
  * Manages domain configurations and target selection
  */
@@ -8,7 +9,21 @@ export declare class DomainConfigManager {
     private settings;
     private domainTargetIndices;
     private forwardingHandlers;
+    private derivedDomainConfigs;
+    private routeManager?;
     constructor(settings: ISmartProxyOptions);
+    /**
+     * Set the route manager reference for route-based queries
+     */
+    setRouteManager(routeManager: RouteManager): void;
+    /**
+     * Generate domain configs from routes
+     */
+    generateDomainConfigsFromRoutes(): void;
+    /**
+     * Convert a route to a domain config
+     */
+    private routeToDomainConfig;
     /**
      * Updates the domain configurations
      */

package/dist_ts/proxies/smart-proxy/domain-config-manager.js

@@ -1,5 +1,6 @@
 import * as plugins from '../../plugins.js';
 import { ForwardingHandlerFactory } from '../../forwarding/factory/forwarding-factory.js';
+import { RouteManager } from './route-manager.js';
 /**
  * Manages domain configurations and target selection
  */
@@ -10,12 +11,100 @@ export class DomainConfigManager {
         this.domainTargetIndices = new Map();
         // Cache forwarding handlers for each domain config
         this.forwardingHandlers = new Map();
+        // Store derived domain configs from routes
+        this.derivedDomainConfigs = [];
+        // Initialize with derived domain configs if using route-based configuration
+        if (settings.routes && !settings.domainConfigs) {
+            this.generateDomainConfigsFromRoutes();
+        }
+    }
+    /**
+     * Set the route manager reference for route-based queries
+     */
+    setRouteManager(routeManager) {
+        this.routeManager = routeManager;
+        // Regenerate domain configs from routes if needed
+        if (this.settings.routes && (!this.settings.domainConfigs || this.settings.domainConfigs.length === 0)) {
+            this.generateDomainConfigsFromRoutes();
+        }
+    }
+    /**
+     * Generate domain configs from routes
+     */
+    generateDomainConfigsFromRoutes() {
+        this.derivedDomainConfigs = [];
+        if (!this.settings.routes)
+            return;
+        for (const route of this.settings.routes) {
+            if (route.action.type !== 'forward' || !route.match.domains)
+                continue;
+            // Convert route to domain config
+            const domainConfig = this.routeToDomainConfig(route);
+            if (domainConfig) {
+                this.derivedDomainConfigs.push(domainConfig);
+            }
+        }
+    }
+    /**
+     * Convert a route to a domain config
+     */
+    routeToDomainConfig(route) {
+        if (route.action.type !== 'forward' || !route.action.target)
+            return null;
+        // Get domains from route
+        const domains = Array.isArray(route.match.domains) ?
+            route.match.domains :
+            (route.match.domains ? [route.match.domains] : []);
+        if (domains.length === 0)
+            return null;
+        // Determine forwarding type based on TLS mode
+        let forwardingType = 'http-only';
+        if (route.action.tls) {
+            switch (route.action.tls.mode) {
+                case 'passthrough':
+                    forwardingType = 'https-passthrough';
+                    break;
+                case 'terminate':
+                    forwardingType = 'https-terminate-to-http';
+                    break;
+                case 'terminate-and-reencrypt':
+                    forwardingType = 'https-terminate-to-https';
+                    break;
+            }
+        }
+        // Create domain config
+        return {
+            domains,
+            forwarding: {
+                type: forwardingType,
+                target: {
+                    host: route.action.target.host,
+                    port: route.action.target.port
+                },
+                security: route.action.security ? {
+                    allowedIps: route.action.security.allowedIps,
+                    blockedIps: route.action.security.blockedIps,
+                    maxConnections: route.action.security.maxConnections
+                } : undefined,
+                https: route.action.tls && route.action.tls.certificate !== 'auto' ? {
+                    customCert: route.action.tls.certificate
+                } : undefined,
+                advanced: route.action.advanced
+            }
+        };
     }
     /**
      * Updates the domain configurations
      */
     updateDomainConfigs(newDomainConfigs) {
-        this.settings.domainConfigs = newDomainConfigs;
+        // If we're using domainConfigs property, update it
+        if (this.settings.domainConfigs) {
+            this.settings.domainConfigs = newDomainConfigs;
+        }
+        else {
+            // Otherwise update our derived configs
+            this.derivedDomainConfigs = newDomainConfigs;
+        }
         // Reset target indices for removed configs
         const currentConfigSet = new Set(newDomainConfigs);
         for (const [config] of this.domainTargetIndices) {
@@ -51,7 +140,8 @@ export class DomainConfigManager {
      * Get all domain configurations
      */
     getDomainConfigs() {
-        return this.settings.domainConfigs;
+        // Use domainConfigs from settings if available, otherwise use derived configs
+        return this.settings.domainConfigs || this.derivedDomainConfigs;
     }
     /**
      * Find domain config matching a server name
@@ -59,18 +149,59 @@ export class DomainConfigManager {
     findDomainConfig(serverName) {
         if (!serverName)
             return undefined;
-        return this.settings.domainConfigs.find((config) => config.domains.some((d) => plugins.minimatch(serverName, d)));
+        // Get domain configs from the appropriate source
+        const domainConfigs = this.getDomainConfigs();
+        // Check for direct match
+        for (const config of domainConfigs) {
+            if (config.domains.some(d => plugins.minimatch(serverName, d))) {
+                return config;
+            }
+        }
+        // No match found
+        return undefined;
     }
     /**
      * Find domain config for a specific port
      */
     findDomainConfigForPort(port) {
-        return this.settings.domainConfigs.find((domain) => {
+        // Get domain configs from the appropriate source
+        const domainConfigs = this.getDomainConfigs();
+        // Check if any domain config has a matching port range
+        for (const domain of domainConfigs) {
             const portRanges = domain.forwarding?.advanced?.portRanges;
-            return portRanges &&
-                portRanges.length > 0 &&
-                this.isPortInRanges(port, portRanges);
-        });
+            if (portRanges && portRanges.length > 0 && this.isPortInRanges(port, portRanges)) {
+                return domain;
+            }
+        }
+        // If we're in route-based mode, also check routes for this port
+        if (this.settings.routes && (!this.settings.domainConfigs || this.settings.domainConfigs.length === 0)) {
+            const routesForPort = this.settings.routes.filter(route => {
+                // Check if this port is in the route's ports
+                if (typeof route.match.ports === 'number') {
+                    return route.match.ports === port;
+                }
+                else if (Array.isArray(route.match.ports)) {
+                    return route.match.ports.some(p => {
+                        if (typeof p === 'number') {
+                            return p === port;
+                        }
+                        else if (p.from && p.to) {
+                            return port >= p.from && port <= p.to;
+                        }
+                        return false;
+                    });
+                }
+                return false;
+            });
+            // If we found any routes for this port, convert the first one to a domain config
+            if (routesForPort.length > 0 && routesForPort[0].action.type === 'forward') {
+                const domainConfig = this.routeToDomainConfig(routesForPort[0]);
+                if (domainConfig) {
+                    return domainConfig;
+                }
+            }
+        }
+        return undefined;
     }
     /**
      * Check if a port is within any of the given ranges
@@ -252,4 +383,4 @@ export class DomainConfigManager {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"domain-config-manager.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/domain-config-manager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"domain-config-manager.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/domain-config-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/index.d.ts

@@ -1,13 +1,15 @@
 /**
  * SmartProxy implementation
+ *
+ * Version 14.0.0: Unified Route-Based Configuration API
  */
 export * from './models/index.js';
 export { SmartProxy } from './smart-proxy.js';
 export { ConnectionManager } from './connection-manager.js';
 export { SecurityManager } from './security-manager.js';
-export { DomainConfigManager } from './domain-config-manager.js';
 export { TimeoutManager } from './timeout-manager.js';
 export { TlsManager } from './tls-manager.js';
 export { NetworkProxyBridge } from './network-proxy-bridge.js';
-export { PortRangeManager } from './port-range-manager.js';
-export { ConnectionHandler } from './connection-handler.js';
+export { RouteManager } from './route-manager.js';
+export { RouteConnectionHandler } from './route-connection-handler.js';
+export { createRoute, createHttpRoute, createHttpsRoute, createPassthroughRoute, createRedirectRoute, createHttpToHttpsRedirect, createBlockRoute, createLoadBalancerRoute, createHttpsServer } from './route-helpers.js';

package/dist_ts/proxies/smart-proxy/index.js

@@ -1,17 +1,21 @@
 /**
  * SmartProxy implementation
+ *
+ * Version 14.0.0: Unified Route-Based Configuration API
  */
 // Re-export models
 export * from './models/index.js';
 // Export the main SmartProxy class
 export { SmartProxy } from './smart-proxy.js';
-// Export supporting classes
+// Export core supporting classes
 export { ConnectionManager } from './connection-manager.js';
 export { SecurityManager } from './security-manager.js';
-export { DomainConfigManager } from './domain-config-manager.js';
 export { TimeoutManager } from './timeout-manager.js';
 export { TlsManager } from './tls-manager.js';
 export { NetworkProxyBridge } from './network-proxy-bridge.js';
-export { PortRangeManager } from './port-range-manager.js';
-export { ConnectionHandler } from './connection-handler.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsbUJBQW1CO0FBQ25CLGNBQWMsbUJBQW1CLENBQUM7QUFFbEMsbUNBQW1DO0FBQ25DLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU5Qyw0QkFBNEI7QUFDNUIsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDNUQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3hELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDOUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDL0QsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUMifQ==
+// Export route-based components
+export { RouteManager } from './route-manager.js';
+export { RouteConnectionHandler } from './route-connection-handler.js';
+// Export route helpers for configuration
+export { createRoute, createHttpRoute, createHttpsRoute, createPassthroughRoute, createRedirectRoute, createHttpToHttpsRedirect, createBlockRoute, createLoadBalancerRoute, createHttpsServer } from './route-helpers.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxtQkFBbUI7QUFDbkIsY0FBYyxtQkFBbUIsQ0FBQztBQUVsQyxtQ0FBbUM7QUFDbkMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTlDLGlDQUFpQztBQUNqQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM5QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUUvRCxnQ0FBZ0M7QUFDaEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRXZFLHlDQUF5QztBQUN6QyxPQUFPLEVBQ0wsV0FBVyxFQUNYLGVBQWUsRUFDZixnQkFBZ0IsRUFDaEIsc0JBQXNCLEVBQ3RCLG1CQUFtQixFQUNuQix5QkFBeUIsRUFDekIsZ0JBQWdCLEVBQ2hCLHVCQUF1QixFQUN2QixpQkFBaUIsRUFDbEIsTUFBTSxvQkFBb0IsQ0FBQyJ9

package/dist_ts/proxies/smart-proxy/models/index.d.ts

@@ -2,3 +2,5 @@
  * SmartProxy models
  */
 export * from './interfaces.js';
+export * from './route-types.js';
+export type { ISmartProxyOptions as IRoutedSmartProxyOptions } from './interfaces.js';

package/dist_ts/proxies/smart-proxy/models/index.js

@@ -2,4 +2,5 @@
  * SmartProxy models
  */
 export * from './interfaces.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILGNBQWMsaUJBQWlCLENBQUMifQ==
+export * from './route-types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxrQkFBa0IsQ0FBQyJ9

package/dist_ts/proxies/smart-proxy/models/interfaces.d.ts

@@ -1,29 +1,100 @@
 import * as plugins from '../../../plugins.js';
-import type { IForwardConfig } from '../../../forwarding/config/forwarding-types.js';
+import type { IAcmeOptions } from '../../../certificate/models/certificate-types.js';
+import type { IRouteConfig } from './route-types.js';
+import type { TForwardingType } from '../../../forwarding/config/forwarding-types.js';
 /**
  * Provision object for static or HTTP-01 certificate
  */
 export type TSmartProxyCertProvisionObject = plugins.tsclass.network.ICert | 'http01';
 /**
- * Domain configuration with forwarding configuration
+ * Alias for backward compatibility with code that uses IRoutedSmartProxyOptions
+ */
+export type IRoutedSmartProxyOptions = ISmartProxyOptions;
+/**
+ * Legacy domain configuration interface for backward compatibility
  */
 export interface IDomainConfig {
     domains: string[];
-    forwarding: IForwardConfig;
+    forwarding: {
+        type: TForwardingType;
+        target: {
+            host: string | string[];
+            port: number;
+        };
+        acme?: {
+            enabled?: boolean;
+            maintenance?: boolean;
+            production?: boolean;
+            forwardChallenges?: {
+                host: string;
+                port: number;
+                useTls?: boolean;
+            };
+        };
+        http?: {
+            enabled?: boolean;
+            redirectToHttps?: boolean;
+            headers?: Record<string, string>;
+        };
+        https?: {
+            customCert?: {
+                key: string;
+                cert: string;
+            };
+            forwardSni?: boolean;
+        };
+        security?: {
+            allowedIps?: string[];
+            blockedIps?: string[];
+            maxConnections?: number;
+        };
+        advanced?: {
+            portRanges?: Array<{
+                from: number;
+                to: number;
+            }>;
+            networkProxyPort?: number;
+            keepAlive?: boolean;
+            timeout?: number;
+            headers?: Record<string, string>;
+        };
+    };
 }
 /**
- * Configuration options for the SmartProxy
+ * Helper functions for type checking configuration types
+ */
+export declare function isLegacyOptions(options: any): boolean;
+export declare function isRoutedOptions(options: any): boolean;
+/**
+ * SmartProxy configuration options
  */
-import type { IAcmeOptions } from '../../../certificate/models/certificate-types.js';
 export interface ISmartProxyOptions {
-    fromPort: number;
-    toPort: number;
-    targetIP?: string;
-    domainConfigs: IDomainConfig[];
+    routes: IRouteConfig[];
+    fromPort?: number;
+    toPort?: number;
     sniEnabled?: boolean;
+    domainConfigs?: IDomainConfig[];
+    targetIP?: string;
     defaultAllowedIPs?: string[];
     defaultBlockedIPs?: string[];
+    globalPortRanges?: Array<{
+        from: number;
+        to: number;
+    }>;
+    forwardAllGlobalRanges?: boolean;
     preserveSourceIP?: boolean;
+    defaults?: {
+        target?: {
+            host: string;
+            port: number;
+        };
+        security?: {
+            allowedIPs?: string[];
+            blockedIPs?: string[];
+            maxConnections?: number;
+        };
+        preserveSourceIP?: boolean;
+    };
     pfx?: Buffer;
     key?: string | Buffer | Array<Buffer | string>;
     passphrase?: string;
@@ -42,11 +113,6 @@ export interface ISmartProxyOptions {
     maxConnectionLifetime?: number;
     inactivityTimeout?: number;
     gracefulShutdownTimeout?: number;
-    globalPortRanges: Array<{
-        from: number;
-        to: number;
-    }>;
-    forwardAllGlobalRanges?: boolean;
     noDelay?: boolean;
     keepAlive?: boolean;
     keepAliveInitialDelay?: number;
@@ -88,6 +154,7 @@ export interface IConnectionRecord {
     lastActivity: number;
     pendingData: Buffer[];
     pendingDataSize: number;
+    domainConfig?: IDomainConfig;
     bytesReceived: number;
     bytesSent: number;
     remoteIP: string;
@@ -95,7 +162,7 @@ export interface IConnectionRecord {
     isTLS: boolean;
     tlsHandshakeComplete: boolean;
     hasReceivedInitialData: boolean;
-    domainConfig?: IDomainConfig;
+    routeConfig?: IRouteConfig;
     hasKeepAlive: boolean;
     inactivityWarningIssued?: boolean;
     incomingTerminationReason?: string | null;

package/dist_ts/proxies/smart-proxy/models/interfaces.js

@@ -1,2 +1,12 @@
 import * as plugins from '../../../plugins.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvc21hcnQtcHJveHkvbW9kZWxzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQyJ9
+/**
+ * Helper functions for type checking configuration types
+ */
+export function isLegacyOptions(options) {
+    return !!(options.domainConfigs && options.domainConfigs.length > 0 &&
+        (!options.routes || options.routes.length === 0));
+}
+export function isRoutedOptions(options) {
+    return !!(options.routes && options.routes.length > 0);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvc21hcnQtcHJveHkvbW9kZWxzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQStEL0M7O0dBRUc7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUFDLE9BQVk7SUFDMUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsYUFBYSxJQUFJLE9BQU8sQ0FBQyxhQUFhLENBQUMsTUFBTSxHQUFHLENBQUM7UUFDMUQsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxNQUFNLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUM3RCxDQUFDO0FBRUQsTUFBTSxVQUFVLGVBQWUsQ0FBQyxPQUFZO0lBQzFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sSUFBSSxPQUFPLENBQUMsTUFBTSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQztBQUN6RCxDQUFDIn0=

package/dist_ts/proxies/smart-proxy/models/route-types.d.ts

@@ -0,0 +1,133 @@
+import type { IAcmeOptions } from '../../../certificate/models/certificate-types.js';
+/**
+ * Supported action types for route configurations
+ */
+export type TRouteActionType = 'forward' | 'redirect' | 'block';
+/**
+ * TLS handling modes for route configurations
+ */
+export type TTlsMode = 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+/**
+ * Port range specification format
+ */
+export type TPortRange = number | number[] | Array<{
+    from: number;
+    to: number;
+}>;
+/**
+ * Route match criteria for incoming requests
+ */
+export interface IRouteMatch {
+    ports: TPortRange;
+    domains?: string | string[];
+    path?: string;
+    clientIp?: string[];
+    tlsVersion?: string[];
+}
+/**
+ * Target configuration for forwarding
+ */
+export interface IRouteTarget {
+    host: string | string[];
+    port: number;
+    preservePort?: boolean;
+}
+/**
+ * TLS configuration for route actions
+ */
+export interface IRouteTls {
+    mode: TTlsMode;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+}
+/**
+ * Redirect configuration for route actions
+ */
+export interface IRouteRedirect {
+    to: string;
+    status: 301 | 302 | 307 | 308;
+}
+/**
+ * Security options for route actions
+ */
+export interface IRouteSecurity {
+    allowedIps?: string[];
+    blockedIps?: string[];
+    maxConnections?: number;
+    authentication?: {
+        type: 'basic' | 'digest' | 'oauth';
+    };
+}
+/**
+ * Advanced options for route actions
+ */
+export interface IRouteAdvanced {
+    timeout?: number;
+    headers?: Record<string, string>;
+    keepAlive?: boolean;
+}
+/**
+ * Action configuration for route handling
+ */
+export interface IRouteAction {
+    type: TRouteActionType;
+    target?: IRouteTarget;
+    tls?: IRouteTls;
+    redirect?: IRouteRedirect;
+    security?: IRouteSecurity;
+    advanced?: IRouteAdvanced;
+}
+/**
+ * The core unified configuration interface
+ */
+export interface IRouteConfig {
+    match: IRouteMatch;
+    action: IRouteAction;
+    name?: string;
+    description?: string;
+    priority?: number;
+    tags?: string[];
+}
+/**
+ * Unified SmartProxy options with routes-based configuration
+ */
+export interface IRoutedSmartProxyOptions {
+    routes: IRouteConfig[];
+    defaults?: {
+        target?: {
+            host: string;
+            port: number;
+        };
+        security?: IRouteSecurity;
+        tls?: IRouteTls;
+    };
+    acme?: IAcmeOptions;
+    initialDataTimeout?: number;
+    socketTimeout?: number;
+    inactivityCheckInterval?: number;
+    maxConnectionLifetime?: number;
+    inactivityTimeout?: number;
+    gracefulShutdownTimeout?: number;
+    noDelay?: boolean;
+    keepAlive?: boolean;
+    keepAliveInitialDelay?: number;
+    maxPendingDataSize?: number;
+    disableInactivityCheck?: boolean;
+    enableKeepAliveProbes?: boolean;
+    enableDetailedLogging?: boolean;
+    enableTlsDebugLogging?: boolean;
+    enableRandomizedTimeouts?: boolean;
+    allowSessionTicket?: boolean;
+    maxConnectionsPerIP?: number;
+    connectionRateLimitPerMinute?: number;
+    keepAliveTreatment?: 'standard' | 'extended' | 'immortal';
+    keepAliveInactivityMultiplier?: number;
+    extendedKeepAliveLifetime?: number;
+    /**
+     * Optional certificate provider callback. Return 'http01' to use HTTP-01 challenges,
+     * or a static certificate object for immediate provisioning.
+     */
+    certProvisionFunction?: (domain: string) => Promise<any>;
+}

package/dist_ts/proxies/smart-proxy/models/route-types.js

@@ -0,0 +1,2 @@
+import * as plugins from '../../../plugins.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9yb3V0ZS10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDIn0=