@push.rocks/smartproxy 15.0.2 → 16.0.3

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

@@ -0,0 +1,451 @@
+/**
+ * Route Helper Functions
+ *
+ * This file 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 module includes helper functions for creating:
+ * - HTTP routes (createHttpRoute)
+ * - HTTPS routes with TLS termination (createHttpsTerminateRoute)
+ * - HTTP to HTTPS redirects (createHttpToHttpsRedirect)
+ * - HTTPS passthrough routes (createHttpsPassthroughRoute)
+ * - Complete HTTPS servers with redirects (createCompleteHttpsServer)
+ * - Load balancer routes (createLoadBalancerRoute)
+ * - Static file server routes (createStaticFileRoute)
+ * - API routes (createApiRoute)
+ * - WebSocket routes (createWebSocketRoute)
+ * - Port mapping routes (createPortMappingRoute, createOffsetPortMappingRoute)
+ * - Dynamic routing (createDynamicRoute, createSmartLoadBalancer)
+ */
+/**
+ * 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',
+        target
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTP Route for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create an HTTPS route with TLS termination (including HTTP redirect to HTTPS)
+ * @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',
+        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: 'redirect',
+        redirect: {
+            to: `https://{domain}:${httpsPort}{path}`,
+            status: 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',
+        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];
+}
+/**
+ * Create a load balancer route (round-robin between multiple backend hosts)
+ * @param domains Domain(s) to match
+ * @param hosts Array of backend hosts to load balance between
+ * @param port Backend port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createLoadBalancerRoute(domains, hosts, port, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || (options.tls ? 443 : 80),
+        domains
+    };
+    // Create route target
+    const target = {
+        host: hosts,
+        port
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target
+    };
+    // Add TLS configuration if provided
+    if (options.tls) {
+        action.tls = {
+            mode: options.tls.mode,
+            certificate: options.tls.certificate || 'auto'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Load Balancer for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create a static file server route
+ * @param domains Domain(s) to match
+ * @param rootDir Root directory path for static files
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createStaticFileRoute(domains, rootDir, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.serveOnHttps
+            ? (options.httpsPort || 443)
+            : (options.httpPort || 80),
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'static',
+        static: {
+            root: rootDir,
+            index: options.indexFiles || ['index.html', 'index.htm']
+        }
+    };
+    // Add TLS configuration if serving on HTTPS
+    if (options.serveOnHttps) {
+        action.tls = {
+            mode: 'terminate',
+            certificate: options.certificate || 'auto'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Static Files for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * 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',
+        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 a WebSocket route configuration
+ * @param domains Domain(s) to match
+ * @param wsPath WebSocket path (e.g., "/ws")
+ * @param target Target WebSocket server host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createWebSocketRoute(domains, wsPath, target, options = {}) {
+    // Normalize WebSocket path
+    const normalizedPath = wsPath.startsWith('/') ? wsPath : `/${wsPath}`;
+    // Create route match
+    const match = {
+        ports: options.useTls
+            ? (options.httpsPort || 443)
+            : (options.httpPort || 80),
+        domains,
+        path: normalizedPath
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target,
+        websocket: {
+            enabled: true,
+            pingInterval: options.pingInterval || 30000, // 30 seconds
+            pingTimeout: options.pingTimeout || 5000 // 5 seconds
+        }
+    };
+    // Add TLS configuration if using HTTPS
+    if (options.useTls) {
+        action.tls = {
+            mode: 'terminate',
+            certificate: options.certificate || 'auto'
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `WebSocket Route ${normalizedPath} for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        priority: options.priority || 100, // Higher priority for WebSocket routes
+        ...options
+    };
+}
+/**
+ * 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',
+        target: {
+            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',
+        target: {
+            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
+    };
+}
+/**
+ * Create a smart load balancer with dynamic domain-based backend selection
+ * @param options Smart load balancer options
+ * @returns Route configuration object
+ */
+export function createSmartLoadBalancer(options) {
+    // Extract all domain keys to create the match criteria
+    const domains = Object.keys(options.domainTargets);
+    // Create the smart host selector function
+    const hostSelector = (context) => {
+        const domain = context.domain || '';
+        return options.domainTargets[domain] || options.defaultTarget || 'localhost';
+    };
+    // Create route match
+    const match = {
+        ports: options.ports,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target: {
+            host: hostSelector,
+            port: options.portMapper
+        }
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Smart Load Balancer for ${domains.join(', ')}`,
+        priority: options.priority,
+        ...options
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-helpers.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/route-helpers.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,51 @@
+/**
+ * Route Migration Utilities
+ *
+ * This file provides utility functions for migrating from legacy domain-based
+ * configuration to the new route-based configuration system. These functions
+ * are temporary and will be removed after the migration is complete.
+ */
+import type { TForwardingType } from '../../../forwarding/config/forwarding-types.js';
+import type { IRouteConfig } from '../models/route-types.js';
+/**
+ * Legacy domain config interface (for migration only)
+ * @deprecated This interface will be removed in a future version
+ */
+export interface ILegacyDomainConfig {
+    domains: string[];
+    forwarding: {
+        type: TForwardingType;
+        target: {
+            host: string | string[];
+            port: number;
+        };
+        [key: string]: any;
+    };
+}
+/**
+ * Convert a legacy domain config to a route-based config
+ * @param domainConfig Legacy domain configuration
+ * @param additionalOptions Additional options to add to the route
+ * @returns Route configuration
+ * @deprecated This function will be removed in a future version
+ */
+export declare function domainConfigToRouteConfig(domainConfig: ILegacyDomainConfig, additionalOptions?: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * Convert an array of legacy domain configs to route configurations
+ * @param domainConfigs Array of legacy domain configurations
+ * @returns Array of route configurations
+ * @deprecated This function will be removed in a future version
+ */
+export declare function domainConfigsToRouteConfigs(domainConfigs: ILegacyDomainConfig[]): IRouteConfig[];
+/**
+ * Extract domains from a route configuration
+ * @param route Route configuration
+ * @returns Array of domains
+ */
+export declare function extractDomainsFromRoute(route: IRouteConfig): string[];
+/**
+ * Extract domains from an array of route configurations
+ * @param routes Array of route configurations
+ * @returns Array of unique domains
+ */
+export declare function extractDomainsFromRoutes(routes: IRouteConfig[]): string[];

package/dist_ts/proxies/smart-proxy/utils/route-migration-utils.js

@@ -0,0 +1,124 @@
+/**
+ * Route Migration Utilities
+ *
+ * This file provides utility functions for migrating from legacy domain-based
+ * configuration to the new route-based configuration system. These functions
+ * are temporary and will be removed after the migration is complete.
+ */
+/**
+ * Convert a legacy domain config to a route-based config
+ * @param domainConfig Legacy domain configuration
+ * @param additionalOptions Additional options to add to the route
+ * @returns Route configuration
+ * @deprecated This function will be removed in a future version
+ */
+export function domainConfigToRouteConfig(domainConfig, additionalOptions = {}) {
+    // Default port based on forwarding type
+    let defaultPort = 80;
+    let tlsMode;
+    switch (domainConfig.forwarding.type) {
+        case 'http-only':
+            defaultPort = 80;
+            break;
+        case 'https-passthrough':
+            defaultPort = 443;
+            tlsMode = 'passthrough';
+            break;
+        case 'https-terminate-to-http':
+            defaultPort = 443;
+            tlsMode = 'terminate';
+            break;
+        case 'https-terminate-to-https':
+            defaultPort = 443;
+            tlsMode = 'terminate-and-reencrypt';
+            break;
+    }
+    // Create route match criteria
+    const match = {
+        ports: additionalOptions.match?.ports || defaultPort,
+        domains: domainConfig.domains
+    };
+    // Create route target
+    const target = {
+        host: domainConfig.forwarding.target.host,
+        port: domainConfig.forwarding.target.port
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        target
+    };
+    // Add TLS configuration if needed
+    if (tlsMode) {
+        action.tls = {
+            mode: tlsMode,
+            certificate: 'auto'
+        };
+        // If the legacy config has custom certificates, use them
+        if (domainConfig.forwarding.https?.customCert) {
+            action.tls.certificate = {
+                key: domainConfig.forwarding.https.customCert.key,
+                cert: domainConfig.forwarding.https.customCert.cert
+            };
+        }
+    }
+    // Add security options if present
+    if (domainConfig.forwarding.security) {
+        action.security = domainConfig.forwarding.security;
+    }
+    // Create the route config
+    const routeConfig = {
+        match,
+        action,
+        // Include a name based on domains if not provided
+        name: additionalOptions.name || `Legacy route for ${domainConfig.domains.join(', ')}`,
+        // Include a note that this was converted from a legacy config
+        description: additionalOptions.description || 'Converted from legacy domain configuration'
+    };
+    // Add optional properties if provided
+    if (additionalOptions.priority !== undefined) {
+        routeConfig.priority = additionalOptions.priority;
+    }
+    if (additionalOptions.tags) {
+        routeConfig.tags = additionalOptions.tags;
+    }
+    return routeConfig;
+}
+/**
+ * Convert an array of legacy domain configs to route configurations
+ * @param domainConfigs Array of legacy domain configurations
+ * @returns Array of route configurations
+ * @deprecated This function will be removed in a future version
+ */
+export function domainConfigsToRouteConfigs(domainConfigs) {
+    return domainConfigs.map(config => domainConfigToRouteConfig(config));
+}
+/**
+ * Extract domains from a route configuration
+ * @param route Route configuration
+ * @returns Array of domains
+ */
+export function extractDomainsFromRoute(route) {
+    if (!route.match.domains) {
+        return [];
+    }
+    return Array.isArray(route.match.domains)
+        ? route.match.domains
+        : [route.match.domains];
+}
+/**
+ * Extract domains from an array of route configurations
+ * @param routes Array of route configurations
+ * @returns Array of unique domains
+ */
+export function extractDomainsFromRoutes(routes) {
+    const domains = new Set();
+    for (const route of routes) {
+        const routeDomains = extractDomainsFromRoute(route);
+        for (const domain of routeDomains) {
+            domains.add(domain);
+        }
+    }
+    return Array.from(domains);
+}
+//# sourceMappingURL=data:application/json;base64,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