@push.rocks/smartproxy 21.1.6 → 22.4.2

package/dist_ts/proxies/smart-proxy/utils/route-helpers/api-helpers.js

@@ -0,0 +1,108 @@
+/**
+ * API Route Helper Functions
+ *
+ * This module provides utility functions for creating API route configurations.
+ */
+import { mergeRouteConfigs } from '../route-utils.js';
+import { createHttpRoute } from './http-helpers.js';
+import { createHttpsTerminateRoute } from './https-helpers.js';
+/**
+ * Create an API route configuration
+ * @param domains Domain(s) to match
+ * @param apiPath API base path (e.g., "/api")
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createApiRoute(domains, apiPath, target, options = {}) {
+    // Normalize API path
+    const normalizedPath = apiPath.startsWith('/') ? apiPath : `/${apiPath}`;
+    const pathWithWildcard = normalizedPath.endsWith('/')
+        ? `${normalizedPath}*`
+        : `${normalizedPath}/*`;
+    // Create route match
+    const match = {
+        ports: options.useTls
+            ? (options.httpsPort || 443)
+            : (options.httpPort || 80),
+        domains,
+        path: pathWithWildcard
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target]
+    };
+    // Add TLS configuration if using HTTPS
+    if (options.useTls) {
+        action.tls = {
+            mode: 'terminate',
+            certificate: options.certificate || 'auto'
+        };
+    }
+    // Add CORS headers if requested
+    const headers = {};
+    if (options.addCorsHeaders) {
+        headers.response = {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+            'Access-Control-Max-Age': '86400'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        headers: Object.keys(headers).length > 0 ? headers : undefined,
+        name: options.name || `API Route ${normalizedPath} for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        priority: options.priority || 100, // Higher priority for specific path matches
+        ...options
+    };
+}
+/**
+ * Create an API Gateway route pattern
+ * @param domains Domain(s) to match
+ * @param apiBasePath Base path for API endpoints (e.g., '/api')
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns API route configuration
+ */
+export function createApiGatewayRoute(domains, apiBasePath, target, options = {}) {
+    // Normalize apiBasePath to ensure it starts with / and doesn't end with /
+    const normalizedPath = apiBasePath.startsWith('/')
+        ? apiBasePath
+        : `/${apiBasePath}`;
+    // Add wildcard to path to match all API endpoints
+    const apiPath = normalizedPath.endsWith('/')
+        ? `${normalizedPath}*`
+        : `${normalizedPath}/*`;
+    // Create base route
+    const baseRoute = options.useTls
+        ? createHttpsTerminateRoute(domains, target, {
+            certificate: options.certificate || 'auto'
+        })
+        : createHttpRoute(domains, target);
+    // Add API-specific configurations
+    const apiRoute = {
+        match: {
+            ...baseRoute.match,
+            path: apiPath
+        },
+        name: options.name || `API Gateway: ${apiPath} -> ${Array.isArray(target.host) ? target.host.join(', ') : target.host}:${target.port}`,
+        priority: options.priority || 100 // Higher priority for specific path matching
+    };
+    // Add CORS headers if requested
+    if (options.addCorsHeaders) {
+        apiRoute.headers = {
+            response: {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+                'Access-Control-Max-Age': '86400'
+            }
+        };
+    }
+    return mergeRouteConfigs(baseRoute, apiRoute);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLWhlbHBlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3V0aWxzL3JvdXRlLWhlbHBlcnMvYXBpLWhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUdILE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUvRDs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxVQUFVLGNBQWMsQ0FDNUIsT0FBMEIsRUFDMUIsT0FBZSxFQUNmLE1BQWlELEVBQ2pELFVBUUksRUFBRTtJQUVOLHFCQUFxQjtJQUNyQixNQUFNLGNBQWMsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLElBQUksT0FBTyxFQUFFLENBQUM7SUFDekUsTUFBTSxnQkFBZ0IsR0FBRyxjQUFjLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQztRQUNuRCxDQUFDLENBQUMsR0FBRyxjQUFjLEdBQUc7UUFDdEIsQ0FBQyxDQUFDLEdBQUcsY0FBYyxJQUFJLENBQUM7SUFFMUIscUJBQXFCO0lBQ3JCLE1BQU0sS0FBSyxHQUFnQjtRQUN6QixLQUFLLEVBQUUsT0FBTyxDQUFDLE1BQU07WUFDbkIsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFNBQVMsSUFBSSxHQUFHLENBQUM7WUFDNUIsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFFBQVEsSUFBSSxFQUFFLENBQUM7UUFDNUIsT0FBTztRQUNQLElBQUksRUFBRSxnQkFBZ0I7S0FDdkIsQ0FBQztJQUVGLHNCQUFzQjtJQUN0QixNQUFNLE1BQU0sR0FBaUI7UUFDM0IsSUFBSSxFQUFFLFNBQVM7UUFDZixPQUFPLEVBQUUsQ0FBQyxNQUFNLENBQUM7S0FDbEIsQ0FBQztJQUVGLHVDQUF1QztJQUN2QyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNuQixNQUFNLENBQUMsR0FBRyxHQUFHO1lBQ1gsSUFBSSxFQUFFLFdBQVc7WUFDakIsV0FBVyxFQUFFLE9BQU8sQ0FBQyxXQUFXLElBQUksTUFBTTtTQUMzQyxDQUFDO0lBQ0osQ0FBQztJQUVELGdDQUFnQztJQUNoQyxNQUFNLE9BQU8sR0FBMkMsRUFBRSxDQUFDO0lBQzNELElBQUksT0FBTyxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQzNCLE9BQU8sQ0FBQyxRQUFRLEdBQUc7WUFDakIsNkJBQTZCLEVBQUUsR0FBRztZQUNsQyw4QkFBOEIsRUFBRSxpQ0FBaUM7WUFDakUsOEJBQThCLEVBQUUsNkJBQTZCO1lBQzdELHdCQUF3QixFQUFFLE9BQU87U0FDbEMsQ0FBQztJQUNKLENBQUM7SUFFRCwwQkFBMEI7SUFDMUIsT0FBTztRQUNMLEtBQUs7UUFDTCxNQUFNO1FBQ04sT0FBTyxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxTQUFTO1FBQzlELElBQUksRUFBRSxPQUFPLENBQUMsSUFBSSxJQUFJLGFBQWEsY0FBYyxRQUFRLEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sRUFBRTtRQUNoSCxRQUFRLEVBQUUsT0FBTyxDQUFDLFFBQVEsSUFBSSxHQUFHLEVBQUUsNENBQTRDO1FBQy9FLEdBQUcsT0FBTztLQUNYLENBQUM7QUFDSixDQUFDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSxxQkFBcUIsQ0FDbkMsT0FBMEIsRUFDMUIsV0FBbUIsRUFDbkIsTUFBaUQsRUFDakQsVUFLSSxFQUFFO0lBRU4sMEVBQTBFO0lBQzFFLE1BQU0sY0FBYyxHQUFHLFdBQVcsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDO1FBQ2hELENBQUMsQ0FBQyxXQUFXO1FBQ2IsQ0FBQyxDQUFDLElBQUksV0FBVyxFQUFFLENBQUM7SUFFdEIsa0RBQWtEO0lBQ2xELE1BQU0sT0FBTyxHQUFHLGNBQWMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDO1FBQzFDLENBQUMsQ0FBQyxHQUFHLGNBQWMsR0FBRztRQUN0QixDQUFDLENBQUMsR0FBRyxjQUFjLElBQUksQ0FBQztJQUUxQixvQkFBb0I7SUFDcEIsTUFBTSxTQUFTLEdBQUcsT0FBTyxDQUFDLE1BQU07UUFDOUIsQ0FBQyxDQUFDLHlCQUF5QixDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUU7WUFDekMsV0FBVyxFQUFFLE9BQU8sQ0FBQyxXQUFXLElBQUksTUFBTTtTQUMzQyxDQUFDO1FBQ0osQ0FBQyxDQUFDLGVBQWUsQ0FBQyxPQUFPLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFFckMsa0NBQWtDO0lBQ2xDLE1BQU0sUUFBUSxHQUEwQjtRQUN0QyxLQUFLLEVBQUU7WUFDTCxHQUFHLFNBQVMsQ0FBQyxLQUFLO1lBQ2xCLElBQUksRUFBRSxPQUFPO1NBQ2Q7UUFDRCxJQUFJLEVBQUUsT0FBTyxDQUFDLElBQUksSUFBSSxnQkFBZ0IsT0FBTyxPQUFPLEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksSUFBSSxNQUFNLENBQUMsSUFBSSxFQUFFO1FBQ3RJLFFBQVEsRUFBRSxPQUFPLENBQUMsUUFBUSxJQUFJLEdBQUcsQ0FBQyw2Q0FBNkM7S0FDaEYsQ0FBQztJQUVGLGdDQUFnQztJQUNoQyxJQUFJLE9BQU8sQ0FBQyxjQUFjLEVBQUUsQ0FBQztRQUMzQixRQUFRLENBQUMsT0FBTyxHQUFHO1lBQ2pCLFFBQVEsRUFBRTtnQkFDUiw2QkFBNkIsRUFBRSxHQUFHO2dCQUNsQyw4QkFBOEIsRUFBRSxpQ0FBaUM7Z0JBQ2pFLDhCQUE4QixFQUFFLDZCQUE2QjtnQkFDN0Qsd0JBQXdCLEVBQUUsT0FBTzthQUNsQztTQUNGLENBQUM7SUFDSixDQUFDO0lBRUQsT0FBTyxpQkFBaUIsQ0FBQyxTQUFTLEVBQUUsUUFBUSxDQUFDLENBQUM7QUFDaEQsQ0FBQyJ9

package/dist_ts/proxies/smart-proxy/utils/route-helpers/dynamic-helpers.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Dynamic Route Helper Functions
+ *
+ * This module provides utility functions for creating dynamic routes
+ * with context-based host and port mapping.
+ */
+import type { IRouteConfig, TPortRange, IRouteContext } from '../../models/route-types.js';
+/**
+ * Create a helper function that applies a port offset
+ * @param offset The offset to apply to the matched port
+ * @returns A function that adds the offset to the matched port
+ */
+export declare function createPortOffset(offset: number): (context: IRouteContext) => number;
+/**
+ * Create a port mapping route with context-based port function
+ * @param options Port mapping route options
+ * @returns Route configuration object
+ */
+export declare function createPortMappingRoute(options: {
+    sourcePortRange: TPortRange;
+    targetHost: string | string[] | ((context: IRouteContext) => string | string[]);
+    portMapper: (context: IRouteContext) => number;
+    name?: string;
+    domains?: string | string[];
+    priority?: number;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a simple offset port mapping route
+ * @param options Offset port mapping route options
+ * @returns Route configuration object
+ */
+export declare function createOffsetPortMappingRoute(options: {
+    ports: TPortRange;
+    targetHost: string | string[];
+    offset: number;
+    name?: string;
+    domains?: string | string[];
+    priority?: number;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a dynamic route with context-based host and port mapping
+ * @param options Dynamic route options
+ * @returns Route configuration object
+ */
+export declare function createDynamicRoute(options: {
+    ports: TPortRange;
+    targetHost: (context: IRouteContext) => string | string[];
+    portMapper: (context: IRouteContext) => number;
+    name?: string;
+    domains?: string | string[];
+    path?: string;
+    clientIp?: string[];
+    priority?: number;
+    [key: string]: any;
+}): IRouteConfig;

package/dist_ts/proxies/smart-proxy/utils/route-helpers/dynamic-helpers.js

@@ -0,0 +1,89 @@
+/**
+ * Dynamic Route Helper Functions
+ *
+ * This module provides utility functions for creating dynamic routes
+ * with context-based host and port mapping.
+ */
+/**
+ * Create a helper function that applies a port offset
+ * @param offset The offset to apply to the matched port
+ * @returns A function that adds the offset to the matched port
+ */
+export function createPortOffset(offset) {
+    return (context) => context.port + offset;
+}
+/**
+ * Create a port mapping route with context-based port function
+ * @param options Port mapping route options
+ * @returns Route configuration object
+ */
+export function createPortMappingRoute(options) {
+    // Create route match
+    const match = {
+        ports: options.sourcePortRange,
+        domains: options.domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [{
+                host: options.targetHost,
+                port: options.portMapper
+            }]
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Port Mapping Route for ${options.domains || 'all domains'}`,
+        priority: options.priority,
+        ...options
+    };
+}
+/**
+ * Create a simple offset port mapping route
+ * @param options Offset port mapping route options
+ * @returns Route configuration object
+ */
+export function createOffsetPortMappingRoute(options) {
+    return createPortMappingRoute({
+        sourcePortRange: options.ports,
+        targetHost: options.targetHost,
+        portMapper: (context) => context.port + options.offset,
+        name: options.name || `Offset Mapping (${options.offset > 0 ? '+' : ''}${options.offset}) for ${options.domains || 'all domains'}`,
+        domains: options.domains,
+        priority: options.priority,
+        ...options
+    });
+}
+/**
+ * Create a dynamic route with context-based host and port mapping
+ * @param options Dynamic route options
+ * @returns Route configuration object
+ */
+export function createDynamicRoute(options) {
+    // Create route match
+    const match = {
+        ports: options.ports,
+        domains: options.domains,
+        path: options.path,
+        clientIp: options.clientIp
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [{
+                host: options.targetHost,
+                port: options.portMapper
+            }]
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Dynamic Route for ${options.domains || 'all domains'}`,
+        priority: options.priority,
+        ...options
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/utils/route-helpers/http-helpers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * HTTP Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTP route configurations.
+ */
+import type { IRouteConfig } from '../../models/route-types.js';
+/**
+ * Create an HTTP-only route configuration
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: Partial<IRouteConfig>): IRouteConfig;

package/dist_ts/proxies/smart-proxy/utils/route-helpers/http-helpers.js

@@ -0,0 +1,32 @@
+/**
+ * HTTP Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTP route configurations.
+ */
+/**
+ * Create an HTTP-only route configuration
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpRoute(domains, target, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || 80,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target]
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTP Route for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC1oZWxwZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vdHMvcHJveGllcy9zbWFydC1wcm94eS91dGlscy9yb3V0ZS1oZWxwZXJzL2h0dHAtaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBSUg7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLGVBQWUsQ0FDN0IsT0FBMEIsRUFDMUIsTUFBaUQsRUFDakQsVUFBaUMsRUFBRTtJQUVuQyxxQkFBcUI7SUFDckIsTUFBTSxLQUFLLEdBQWdCO1FBQ3pCLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSyxFQUFFLEtBQUssSUFBSSxFQUFFO1FBQ2pDLE9BQU87S0FDUixDQUFDO0lBRUYsc0JBQXNCO0lBQ3RCLE1BQU0sTUFBTSxHQUFpQjtRQUMzQixJQUFJLEVBQUUsU0FBUztRQUNmLE9BQU8sRUFBRSxDQUFDLE1BQU0sQ0FBQztLQUNsQixDQUFDO0lBRUYsMEJBQTBCO0lBQzFCLE9BQU87UUFDTCxLQUFLO1FBQ0wsTUFBTTtRQUNOLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSSxJQUFJLGtCQUFrQixLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUU7UUFDL0YsR0FBRyxPQUFPO0tBQ1gsQ0FBQztBQUNKLENBQUMifQ==

package/dist_ts/proxies/smart-proxy/utils/route-helpers/https-helpers.d.ts

@@ -0,0 +1,68 @@
+/**
+ * HTTPS Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTPS route configurations
+ * including TLS termination and passthrough routes.
+ */
+import type { IRouteConfig } from '../../models/route-types.js';
+/**
+ * Create an HTTPS route with TLS termination
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpsTerminateRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    reencrypt?: boolean;
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create an HTTP to HTTPS redirect route
+ * @param domains Domain(s) to match
+ * @param httpsPort HTTPS port to redirect to (default: 443)
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpToHttpsRedirect(domains: string | string[], httpsPort?: number, options?: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * Create an HTTPS passthrough route (SNI-based forwarding without TLS termination)
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpsPassthroughRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * Create a complete HTTPS server with HTTP to HTTPS redirects
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional configuration options
+ * @returns Array of two route configurations (HTTPS and HTTP redirect)
+ */
+export declare function createCompleteHttpsServer(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    reencrypt?: boolean;
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig[];

package/dist_ts/proxies/smart-proxy/utils/route-helpers/https-helpers.js

@@ -0,0 +1,117 @@
+/**
+ * HTTPS Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTPS route configurations
+ * including TLS termination and passthrough routes.
+ */
+import { SocketHandlers } from './socket-handlers.js';
+/**
+ * Create an HTTPS route with TLS termination
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpsTerminateRoute(domains, target, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.httpsPort || 443,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target],
+        tls: {
+            mode: options.reencrypt ? 'terminate-and-reencrypt' : 'terminate',
+            certificate: options.certificate || 'auto'
+        }
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTPS Route for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create an HTTP to HTTPS redirect route
+ * @param domains Domain(s) to match
+ * @param httpsPort HTTPS port to redirect to (default: 443)
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpToHttpsRedirect(domains, httpsPort = 443, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || 80,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'socket-handler',
+        socketHandler: SocketHandlers.httpRedirect(`https://{domain}:${httpsPort}{path}`, 301)
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTP to HTTPS Redirect for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create an HTTPS passthrough route (SNI-based forwarding without TLS termination)
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpsPassthroughRoute(domains, target, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || 443,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target],
+        tls: {
+            mode: 'passthrough'
+        }
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTPS Passthrough for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create a complete HTTPS server with HTTP to HTTPS redirects
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional configuration options
+ * @returns Array of two route configurations (HTTPS and HTTP redirect)
+ */
+export function createCompleteHttpsServer(domains, target, options = {}) {
+    // Create the HTTPS route
+    const httpsRoute = createHttpsTerminateRoute(domains, target, options);
+    // Create the HTTP redirect route
+    const httpRedirectRoute = createHttpToHttpsRedirect(domains, 
+    // Extract the HTTPS port from the HTTPS route - ensure it's a number
+    typeof options.httpsPort === 'number' ? options.httpsPort :
+        Array.isArray(options.httpsPort) ? options.httpsPort[0] : 443, {
+        // Set the HTTP port
+        match: {
+            ports: options.httpPort || 80,
+            domains
+        },
+        name: `HTTP to HTTPS Redirect for ${Array.isArray(domains) ? domains.join(', ') : domains}`
+    });
+    return [httpsRoute, httpRedirectRoute];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cHMtaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvc21hcnQtcHJveHkvdXRpbHMvcm91dGUtaGVscGVycy9odHRwcy1oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBR0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRXREOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSx5QkFBeUIsQ0FDdkMsT0FBMEIsRUFDMUIsTUFBaUQsRUFDakQsVUFPSSxFQUFFO0lBRU4scUJBQXFCO0lBQ3JCLE1BQU0sS0FBSyxHQUFnQjtRQUN6QixLQUFLLEVBQUUsT0FBTyxDQUFDLFNBQVMsSUFBSSxHQUFHO1FBQy9CLE9BQU87S0FDUixDQUFDO0lBRUYsc0JBQXNCO0lBQ3RCLE1BQU0sTUFBTSxHQUFpQjtRQUMzQixJQUFJLEVBQUUsU0FBUztRQUNmLE9BQU8sRUFBRSxDQUFDLE1BQU0sQ0FBQztRQUNqQixHQUFHLEVBQUU7WUFDSCxJQUFJLEVBQUUsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMseUJBQXlCLENBQUMsQ0FBQyxDQUFDLFdBQVc7WUFDakUsV0FBVyxFQUFFLE9BQU8sQ0FBQyxXQUFXLElBQUksTUFBTTtTQUMzQztLQUNGLENBQUM7SUFFRiwwQkFBMEI7SUFDMUIsT0FBTztRQUNMLEtBQUs7UUFDTCxNQUFNO1FBQ04sSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJLElBQUksbUJBQW1CLEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sRUFBRTtRQUNoRyxHQUFHLE9BQU87S0FDWCxDQUFDO0FBQ0osQ0FBQztBQUVEOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSx5QkFBeUIsQ0FDdkMsT0FBMEIsRUFDMUIsWUFBb0IsR0FBRyxFQUN2QixVQUFpQyxFQUFFO0lBRW5DLHFCQUFxQjtJQUNyQixNQUFNLEtBQUssR0FBZ0I7UUFDekIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDakMsT0FBTztLQUNSLENBQUM7SUFFRixzQkFBc0I7SUFDdEIsTUFBTSxNQUFNLEdBQWlCO1FBQzNCLElBQUksRUFBRSxnQkFBZ0I7UUFDdEIsYUFBYSxFQUFFLGNBQWMsQ0FBQyxZQUFZLENBQUMsb0JBQW9CLFNBQVMsUUFBUSxFQUFFLEdBQUcsQ0FBQztLQUN2RixDQUFDO0lBRUYsMEJBQTBCO0lBQzFCLE9BQU87UUFDTCxLQUFLO1FBQ0wsTUFBTTtRQUNOLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSSxJQUFJLDhCQUE4QixLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUU7UUFDM0csR0FBRyxPQUFPO0tBQ1gsQ0FBQztBQUNKLENBQUM7QUFFRDs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsMkJBQTJCLENBQ3pDLE9BQTBCLEVBQzFCLE1BQWlELEVBQ2pELFVBQWlDLEVBQUU7SUFFbkMscUJBQXFCO0lBQ3JCLE1BQU0sS0FBSyxHQUFnQjtRQUN6QixLQUFLLEVBQUUsT0FBTyxDQUFDLEtBQUssRUFBRSxLQUFLLElBQUksR0FBRztRQUNsQyxPQUFPO0tBQ1IsQ0FBQztJQUVGLHNCQUFzQjtJQUN0QixNQUFNLE1BQU0sR0FBaUI7UUFDM0IsSUFBSSxFQUFFLFNBQVM7UUFDZixPQUFPLEVBQUUsQ0FBQyxNQUFNLENBQUM7UUFDakIsR0FBRyxFQUFFO1lBQ0gsSUFBSSxFQUFFLGFBQWE7U0FDcEI7S0FDRixDQUFDO0lBRUYsMEJBQTBCO0lBQzFCLE9BQU87UUFDTCxLQUFLO1FBQ0wsTUFBTTtRQUNOLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSSxJQUFJLHlCQUF5QixLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUU7UUFDdEcsR0FBRyxPQUFPO0tBQ1gsQ0FBQztBQUNKLENBQUM7QUFFRDs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUseUJBQXlCLENBQ3ZDLE9BQTBCLEVBQzFCLE1BQWlELEVBQ2pELFVBT0ksRUFBRTtJQUVOLHlCQUF5QjtJQUN6QixNQUFNLFVBQVUsR0FBRyx5QkFBeUIsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBRXZFLGlDQUFpQztJQUNqQyxNQUFNLGlCQUFpQixHQUFHLHlCQUF5QixDQUNqRCxPQUFPO0lBQ1AscUVBQXFFO0lBQ3JFLE9BQU8sT0FBTyxDQUFDLFNBQVMsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUN6RCxLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxFQUMvRDtRQUNFLG9CQUFvQjtRQUNwQixLQUFLLEVBQUU7WUFDTCxLQUFLLEVBQUUsT0FBTyxDQUFDLFFBQVEsSUFBSSxFQUFFO1lBQzdCLE9BQU87U0FDUjtRQUNELElBQUksRUFBRSw4QkFBOEIsS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxFQUFFO0tBQzVGLENBQ0YsQ0FBQztJQUVGLE9BQU8sQ0FBQyxVQUFVLEVBQUUsaUJBQWlCLENBQUMsQ0FBQztBQUN6QyxDQUFDIn0=

package/dist_ts/proxies/smart-proxy/utils/route-helpers/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Route Helper Functions
+ *
+ * This module provides utility functions for creating route configurations for common scenarios.
+ * These functions aim to simplify the creation of route configurations for typical use cases.
+ *
+ * This barrel file re-exports all helper functions for backwards compatibility.
+ */
+export { createHttpRoute } from './http-helpers.js';
+export { createHttpsTerminateRoute, createHttpToHttpsRedirect, createHttpsPassthroughRoute, createCompleteHttpsServer } from './https-helpers.js';
+export { createWebSocketRoute } from './websocket-helpers.js';
+export { createLoadBalancerRoute, createSmartLoadBalancer } from './load-balancer-helpers.js';
+export { createNfTablesRoute, createNfTablesTerminateRoute, createCompleteNfTablesHttpsServer } from './nftables-helpers.js';
+export { createPortOffset, createPortMappingRoute, createOffsetPortMappingRoute, createDynamicRoute } from './dynamic-helpers.js';
+export { createApiRoute, createApiGatewayRoute } from './api-helpers.js';
+export { addRateLimiting, addBasicAuth, addJwtAuth } from './security-helpers.js';
+export { SocketHandlers, createSocketHandlerRoute } from './socket-handlers.js';

package/dist_ts/proxies/smart-proxy/utils/route-helpers/index.js

@@ -0,0 +1,27 @@
+/**
+ * Route Helper Functions
+ *
+ * This module provides utility functions for creating route configurations for common scenarios.
+ * These functions aim to simplify the creation of route configurations for typical use cases.
+ *
+ * This barrel file re-exports all helper functions for backwards compatibility.
+ */
+// HTTP helpers
+export { createHttpRoute } from './http-helpers.js';
+// HTTPS helpers
+export { createHttpsTerminateRoute, createHttpToHttpsRedirect, createHttpsPassthroughRoute, createCompleteHttpsServer } from './https-helpers.js';
+// WebSocket helpers
+export { createWebSocketRoute } from './websocket-helpers.js';
+// Load balancer helpers
+export { createLoadBalancerRoute, createSmartLoadBalancer } from './load-balancer-helpers.js';
+// NFTables helpers
+export { createNfTablesRoute, createNfTablesTerminateRoute, createCompleteNfTablesHttpsServer } from './nftables-helpers.js';
+// Dynamic routing helpers
+export { createPortOffset, createPortMappingRoute, createOffsetPortMappingRoute, createDynamicRoute } from './dynamic-helpers.js';
+// API helpers
+export { createApiRoute, createApiGatewayRoute } from './api-helpers.js';
+// Security helpers
+export { addRateLimiting, addBasicAuth, addJwtAuth } from './security-helpers.js';
+// Socket handlers
+export { SocketHandlers, createSocketHandlerRoute } from './socket-handlers.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3V0aWxzL3JvdXRlLWhlbHBlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVILGVBQWU7QUFDZixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFcEQsZ0JBQWdCO0FBQ2hCLE9BQU8sRUFDTCx5QkFBeUIsRUFDekIseUJBQXlCLEVBQ3pCLDJCQUEyQixFQUMzQix5QkFBeUIsRUFDMUIsTUFBTSxvQkFBb0IsQ0FBQztBQUU1QixvQkFBb0I7QUFDcEIsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFOUQsd0JBQXdCO0FBQ3hCLE9BQU8sRUFDTCx1QkFBdUIsRUFDdkIsdUJBQXVCLEVBQ3hCLE1BQU0sNEJBQTRCLENBQUM7QUFFcEMsbUJBQW1CO0FBQ25CLE9BQU8sRUFDTCxtQkFBbUIsRUFDbkIsNEJBQTRCLEVBQzVCLGlDQUFpQyxFQUNsQyxNQUFNLHVCQUF1QixDQUFDO0FBRS9CLDBCQUEwQjtBQUMxQixPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLHNCQUFzQixFQUN0Qiw0QkFBNEIsRUFDNUIsa0JBQWtCLEVBQ25CLE1BQU0sc0JBQXNCLENBQUM7QUFFOUIsY0FBYztBQUNkLE9BQU8sRUFDTCxjQUFjLEVBQ2QscUJBQXFCLEVBQ3RCLE1BQU0sa0JBQWtCLENBQUM7QUFFMUIsbUJBQW1CO0FBQ25CLE9BQU8sRUFDTCxlQUFlLEVBQ2YsWUFBWSxFQUNaLFVBQVUsRUFDWCxNQUFNLHVCQUF1QixDQUFDO0FBRS9CLGtCQUFrQjtBQUNsQixPQUFPLEVBQ0wsY0FBYyxFQUNkLHdCQUF3QixFQUN6QixNQUFNLHNCQUFzQixDQUFDIn0=

package/dist_ts/proxies/smart-proxy/utils/route-helpers/load-balancer-helpers.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Load Balancer Route Helper Functions
+ *
+ * This module provides utility functions for creating load balancer route configurations.
+ */
+import type { IRouteConfig, TPortRange, IRouteContext } from '../../models/route-types.js';
+/**
+ * Create a load balancer route (round-robin between multiple backend hosts)
+ * @param domains Domain(s) to match
+ * @param backendsOrHosts Array of backend servers OR array of host strings (legacy)
+ * @param portOrOptions Port number (legacy) OR options object
+ * @param options Additional route options (legacy)
+ * @returns Route configuration object
+ */
+export declare function createLoadBalancerRoute(domains: string | string[], backendsOrHosts: Array<{
+    host: string;
+    port: number;
+}> | string[], portOrOptions?: number | {
+    tls?: {
+        mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+        certificate?: 'auto' | {
+            key: string;
+            cert: string;
+        };
+    };
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    algorithm?: 'round-robin' | 'least-connections' | 'ip-hash';
+    healthCheck?: {
+        path: string;
+        interval: number;
+        timeout: number;
+        unhealthyThreshold: number;
+        healthyThreshold: number;
+    };
+    [key: string]: any;
+}, options?: {
+    tls?: {
+        mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+        certificate?: 'auto' | {
+            key: string;
+            cert: string;
+        };
+    };
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a smart load balancer with dynamic domain-based backend selection
+ * @param options Smart load balancer options
+ * @returns Route configuration object
+ */
+export declare function createSmartLoadBalancer(options: {
+    ports: TPortRange;
+    domainTargets: Record<string, string | string[]>;
+    portMapper: (context: IRouteContext) => number;
+    name?: string;
+    defaultTarget?: string | string[];
+    priority?: number;
+    [key: string]: any;
+}): IRouteConfig;