@push.rocks/smartproxy 13.1.2 → 15.0.0

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

@@ -0,0 +1,127 @@
+import type { IRouteConfig, IRouteMatch, IRouteAction, IRouteTarget, IRouteSecurity } from './models/route-types.js';
+/**
+ * Basic helper function to create a route configuration
+ */
+export declare function createRoute(match: IRouteMatch, action: IRouteAction, metadata?: {
+    name?: string;
+    description?: string;
+    priority?: number;
+    tags?: string[];
+}): IRouteConfig;
+/**
+ * Create a basic HTTP route configuration
+ */
+export declare function createHttpRoute(options: {
+    ports?: number | number[];
+    domains?: string | string[];
+    path?: string;
+    target: IRouteTarget;
+    headers?: Record<string, string>;
+    security?: IRouteSecurity;
+    name?: string;
+    description?: string;
+    priority?: number;
+    tags?: string[];
+}): IRouteConfig;
+/**
+ * Create an HTTPS route configuration with TLS termination
+ */
+export declare function createHttpsRoute(options: {
+    ports?: number | number[];
+    domains: string | string[];
+    path?: string;
+    target: IRouteTarget;
+    tlsMode?: 'terminate' | 'terminate-and-reencrypt';
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    headers?: Record<string, string>;
+    security?: IRouteSecurity;
+    name?: string;
+    description?: string;
+    priority?: number;
+    tags?: string[];
+}): IRouteConfig;
+/**
+ * Create an HTTPS passthrough route configuration
+ */
+export declare function createPassthroughRoute(options: {
+    ports?: number | number[];
+    domains?: string | string[];
+    target: IRouteTarget;
+    security?: IRouteSecurity;
+    name?: string;
+    description?: string;
+    priority?: number;
+    tags?: string[];
+}): IRouteConfig;
+/**
+ * Create a redirect route configuration
+ */
+export declare function createRedirectRoute(options: {
+    ports?: number | number[];
+    domains?: string | string[];
+    path?: string;
+    redirectTo: string;
+    statusCode?: 301 | 302 | 307 | 308;
+    name?: string;
+    description?: string;
+    priority?: number;
+    tags?: string[];
+}): IRouteConfig;
+/**
+ * Create an HTTP to HTTPS redirect route configuration
+ */
+export declare function createHttpToHttpsRedirect(options: {
+    domains: string | string[];
+    statusCode?: 301 | 302 | 307 | 308;
+    name?: string;
+    priority?: number;
+}): IRouteConfig;
+/**
+ * Create a block route configuration
+ */
+export declare function createBlockRoute(options: {
+    ports: number | number[];
+    domains?: string | string[];
+    clientIp?: string[];
+    name?: string;
+    description?: string;
+    priority?: number;
+    tags?: string[];
+}): IRouteConfig;
+/**
+ * Create a load balancer route configuration
+ */
+export declare function createLoadBalancerRoute(options: {
+    ports?: number | number[];
+    domains: string | string[];
+    path?: string;
+    targets: string[];
+    targetPort: number;
+    tlsMode?: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    headers?: Record<string, string>;
+    security?: IRouteSecurity;
+    name?: string;
+    description?: string;
+    tags?: string[];
+}): IRouteConfig;
+/**
+ * Create a complete HTTPS server configuration with HTTP redirect
+ */
+export declare function createHttpsServer(options: {
+    domains: string | string[];
+    target: IRouteTarget;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    security?: IRouteSecurity;
+    addHttpRedirect?: boolean;
+    name?: string;
+}): IRouteConfig[];

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

@@ -0,0 +1,196 @@
+/**
+ * Basic helper function to create a route configuration
+ */
+export function createRoute(match, action, metadata) {
+    return {
+        match,
+        action,
+        ...metadata
+    };
+}
+/**
+ * Create a basic HTTP route configuration
+ */
+export function createHttpRoute(options) {
+    return createRoute({
+        ports: options.ports || 80,
+        ...(options.domains ? { domains: options.domains } : {}),
+        ...(options.path ? { path: options.path } : {})
+    }, {
+        type: 'forward',
+        target: options.target,
+        ...(options.headers || options.security ? {
+            advanced: {
+                ...(options.headers ? { headers: options.headers } : {})
+            },
+            ...(options.security ? { security: options.security } : {})
+        } : {})
+    }, {
+        name: options.name || 'HTTP Route',
+        description: options.description,
+        priority: options.priority,
+        tags: options.tags
+    });
+}
+/**
+ * Create an HTTPS route configuration with TLS termination
+ */
+export function createHttpsRoute(options) {
+    return createRoute({
+        ports: options.ports || 443,
+        domains: options.domains,
+        ...(options.path ? { path: options.path } : {})
+    }, {
+        type: 'forward',
+        target: options.target,
+        tls: {
+            mode: options.tlsMode || 'terminate',
+            certificate: options.certificate || 'auto'
+        },
+        ...(options.headers || options.security ? {
+            advanced: {
+                ...(options.headers ? { headers: options.headers } : {})
+            },
+            ...(options.security ? { security: options.security } : {})
+        } : {})
+    }, {
+        name: options.name || 'HTTPS Route',
+        description: options.description,
+        priority: options.priority,
+        tags: options.tags
+    });
+}
+/**
+ * Create an HTTPS passthrough route configuration
+ */
+export function createPassthroughRoute(options) {
+    return createRoute({
+        ports: options.ports || 443,
+        ...(options.domains ? { domains: options.domains } : {})
+    }, {
+        type: 'forward',
+        target: options.target,
+        tls: {
+            mode: 'passthrough'
+        },
+        ...(options.security ? { security: options.security } : {})
+    }, {
+        name: options.name || 'HTTPS Passthrough Route',
+        description: options.description,
+        priority: options.priority,
+        tags: options.tags
+    });
+}
+/**
+ * Create a redirect route configuration
+ */
+export function createRedirectRoute(options) {
+    return createRoute({
+        ports: options.ports || 80,
+        ...(options.domains ? { domains: options.domains } : {}),
+        ...(options.path ? { path: options.path } : {})
+    }, {
+        type: 'redirect',
+        redirect: {
+            to: options.redirectTo,
+            status: options.statusCode || 301
+        }
+    }, {
+        name: options.name || 'Redirect Route',
+        description: options.description,
+        priority: options.priority,
+        tags: options.tags
+    });
+}
+/**
+ * Create an HTTP to HTTPS redirect route configuration
+ */
+export function createHttpToHttpsRedirect(options) {
+    const domainArray = Array.isArray(options.domains) ? options.domains : [options.domains];
+    return createRedirectRoute({
+        ports: 80,
+        domains: options.domains,
+        redirectTo: 'https://{domain}{path}',
+        statusCode: options.statusCode || 301,
+        name: options.name || `HTTP to HTTPS Redirect for ${domainArray.join(', ')}`,
+        priority: options.priority || 100 // High priority for redirects
+    });
+}
+/**
+ * Create a block route configuration
+ */
+export function createBlockRoute(options) {
+    return createRoute({
+        ports: options.ports,
+        ...(options.domains ? { domains: options.domains } : {}),
+        ...(options.clientIp ? { clientIp: options.clientIp } : {})
+    }, {
+        type: 'block'
+    }, {
+        name: options.name || 'Block Route',
+        description: options.description,
+        priority: options.priority || 1000, // Very high priority for blocks
+        tags: options.tags
+    });
+}
+/**
+ * Create a load balancer route configuration
+ */
+export function createLoadBalancerRoute(options) {
+    const useTls = options.tlsMode !== undefined;
+    const defaultPort = useTls ? 443 : 80;
+    return createRoute({
+        ports: options.ports || defaultPort,
+        domains: options.domains,
+        ...(options.path ? { path: options.path } : {})
+    }, {
+        type: 'forward',
+        target: {
+            host: options.targets,
+            port: options.targetPort
+        },
+        ...(useTls ? {
+            tls: {
+                mode: options.tlsMode,
+                ...(options.tlsMode !== 'passthrough' && options.certificate ? {
+                    certificate: options.certificate
+                } : {})
+            }
+        } : {}),
+        ...(options.headers || options.security ? {
+            advanced: {
+                ...(options.headers ? { headers: options.headers } : {})
+            },
+            ...(options.security ? { security: options.security } : {})
+        } : {})
+    }, {
+        name: options.name || 'Load Balanced Route',
+        description: options.description || `Load balancing across ${options.targets.length} backends`,
+        tags: options.tags
+    });
+}
+/**
+ * Create a complete HTTPS server configuration with HTTP redirect
+ */
+export function createHttpsServer(options) {
+    const routes = [];
+    const domainArray = Array.isArray(options.domains) ? options.domains : [options.domains];
+    // Add HTTPS route
+    routes.push(createHttpsRoute({
+        domains: options.domains,
+        target: options.target,
+        certificate: options.certificate || 'auto',
+        security: options.security,
+        name: options.name || `HTTPS Server for ${domainArray.join(', ')}`
+    }));
+    // Add HTTP to HTTPS redirect if requested
+    if (options.addHttpRedirect !== false) {
+        routes.push(createHttpToHttpsRedirect({
+            domains: options.domains,
+            name: `HTTP to HTTPS Redirect for ${domainArray.join(', ')}`,
+            priority: 100
+        }));
+    }
+    return routes;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-helpers.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/route-helpers.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/route-manager.d.ts

@@ -0,0 +1,103 @@
+import * as plugins from '../../plugins.js';
+import type { IRouteConfig } from './models/route-types.js';
+import type { ISmartProxyOptions, IDomainConfig } from './models/interfaces.js';
+/**
+ * Result of route matching
+ */
+export interface IRouteMatchResult {
+    route: IRouteConfig;
+    params?: Record<string, string>;
+}
+/**
+ * The RouteManager handles all routing decisions based on connections and attributes
+ */
+export declare class RouteManager extends plugins.EventEmitter {
+    private routes;
+    private portMap;
+    private options;
+    constructor(options: ISmartProxyOptions);
+    /**
+     * Update routes with new configuration
+     */
+    updateRoutes(routes?: IRouteConfig[]): void;
+    /**
+     * Rebuild the port mapping for fast lookups
+     */
+    private rebuildPortMap;
+    /**
+     * Expand a port range specification into an array of individual ports
+     */
+    private expandPortRange;
+    /**
+     * Get all ports that should be listened on
+     */
+    getListeningPorts(): number[];
+    /**
+     * Get all routes for a given port
+     */
+    getRoutesForPort(port: number): IRouteConfig[];
+    /**
+     * Test if a pattern matches a domain using glob matching
+     */
+    private matchDomain;
+    /**
+     * Match a domain against all patterns in a route
+     */
+    private matchRouteDomain;
+    /**
+     * Check if a client IP is allowed by a route's security settings
+     */
+    private isClientIpAllowed;
+    /**
+     * Match an IP against a pattern
+     */
+    private matchIpPattern;
+    /**
+     * Match an IP against a CIDR pattern
+     */
+    private matchIpCidr;
+    /**
+     * Convert an IP address to a numeric value
+     */
+    private ipToNumber;
+    /**
+     * Find the matching route for a connection
+     */
+    findMatchingRoute(options: {
+        port: number;
+        domain?: string;
+        clientIp: string;
+        path?: string;
+        tlsVersion?: string;
+    }): IRouteMatchResult | null;
+    /**
+     * Match a path against a pattern
+     */
+    private matchPath;
+    /**
+     * Convert a domain config to routes
+     * (For backward compatibility with code that still uses domainConfigs)
+     */
+    domainConfigToRoutes(domainConfig: IDomainConfig): IRouteConfig[];
+    /**
+     * Update routes based on domain configs
+     * (For backward compatibility with code that still uses domainConfigs)
+     */
+    updateFromDomainConfigs(domainConfigs: IDomainConfig[]): void;
+    /**
+     * Validate the route configuration and return any warnings
+     */
+    validateConfiguration(): string[];
+    /**
+     * Check if two route matches are similar (potential conflict)
+     */
+    private areMatchesSimilar;
+    /**
+     * Check if a route is completely shadowed by a higher priority route
+     */
+    private isRouteShadowed;
+    /**
+     * Check if route1 is more specific than route2
+     */
+    private isRouteMoreSpecific;
+}