@push.rocks/smartproxy 16.0.2 → 16.0.4

package/dist_ts/proxies/network-proxy/models/types.d.ts

@@ -1,5 +1,7 @@
 import * as plugins from '../../../plugins.js';
 import type { IAcmeOptions } from '../../../certificate/models/certificate-types.js';
+import type { IRouteConfig } from '../../smart-proxy/models/route-types.js';
+import type { IRouteContext } from '../../../core/models/route-context.js';
 /**
  * Configuration options for NetworkProxy
  */
@@ -19,7 +21,10 @@ export interface INetworkProxyOptions {
     portProxyIntegration?: boolean;
     useExternalPort80Handler?: boolean;
     backendProtocol?: 'http1' | 'http2';
+    functionCacheSize?: number;
+    functionCacheTtl?: number;
     acme?: IAcmeOptions;
+    routes?: IRouteConfig[];
 }
 /**
  * Interface for a certificate entry in the cache
@@ -30,19 +35,31 @@ export interface ICertificateEntry {
     expires?: Date;
 }
 /**
- * Interface for reverse proxy configuration
+ * @deprecated Use IRouteConfig instead. This interface will be removed in a future release.
+ *
+ * IMPORTANT: This is a legacy interface maintained only for backward compatibility.
+ * New code should use IRouteConfig for all configuration purposes.
+ *
+ * @see IRouteConfig for the modern, recommended configuration format
  */
 export interface IReverseProxyConfig {
+    /** Target hostnames/IPs to proxy requests to */
     destinationIps: string[];
+    /** Target ports to proxy requests to */
     destinationPorts: number[];
+    /** Hostname to match for routing */
     hostName: string;
+    /** SSL private key for this host (PEM format) */
     privateKey: string;
+    /** SSL public key/certificate for this host (PEM format) */
     publicKey: string;
+    /** Basic authentication configuration */
     authentication?: {
         type: 'Basic';
         user: string;
         pass: string;
     };
+    /** Whether to rewrite the Host header to match the target */
     rewriteHostHeader?: boolean;
     /**
      * Protocol to use when proxying to this backend: 'http1' or 'http2'.
@@ -50,6 +67,61 @@ export interface IReverseProxyConfig {
      */
     backendProtocol?: 'http1' | 'http2';
 }
+/**
+ * Convert a legacy IReverseProxyConfig to the modern IRouteConfig format
+ *
+ * @deprecated This function is maintained for backward compatibility.
+ * New code should create IRouteConfig objects directly.
+ *
+ * @param legacyConfig The legacy configuration to convert
+ * @param proxyPort The port the proxy listens on
+ * @returns A modern route configuration equivalent to the legacy config
+ */
+export declare function convertLegacyConfigToRouteConfig(legacyConfig: IReverseProxyConfig, proxyPort: number): IRouteConfig;
+/**
+ * Route manager for NetworkProxy
+ * Handles route matching and configuration
+ */
+export declare class RouteManager {
+    private routes;
+    private logger;
+    constructor(logger: ILogger);
+    /**
+     * Update the routes configuration
+     */
+    updateRoutes(routes: IRouteConfig[]): void;
+    /**
+     * Get all routes
+     */
+    getRoutes(): IRouteConfig[];
+    /**
+     * Find the first matching route for a context
+     */
+    findMatchingRoute(context: IRouteContext): IRouteConfig | null;
+    /**
+     * Check if a route matches the given context
+     */
+    private matchesRoute;
+    /**
+     * Match a domain pattern against a domain
+     */
+    private matchDomain;
+    /**
+     * Match a path pattern against a path
+     */
+    private matchPath;
+    /**
+     * Match an IP pattern against an IP
+     * Supports exact matches, wildcard patterns, and CIDR notation
+     */
+    private matchIp;
+    /**
+     * Convert an IP address to its binary representation
+     * @param ip The IP address to convert
+     * @returns Binary string representation or null if invalid
+     */
+    private ipToBinary;
+}
 /**
  * Interface for connection tracking in the pool
  */

package/dist_ts/proxies/network-proxy/models/types.js

@@ -1,4 +1,245 @@
 import * as plugins from '../../../plugins.js';
+/**
+ * Convert a legacy IReverseProxyConfig to the modern IRouteConfig format
+ *
+ * @deprecated This function is maintained for backward compatibility.
+ * New code should create IRouteConfig objects directly.
+ *
+ * @param legacyConfig The legacy configuration to convert
+ * @param proxyPort The port the proxy listens on
+ * @returns A modern route configuration equivalent to the legacy config
+ */
+export function convertLegacyConfigToRouteConfig(legacyConfig, proxyPort) {
+    // Create basic route configuration
+    const routeConfig = {
+        // Match properties
+        match: {
+            ports: proxyPort,
+            domains: legacyConfig.hostName
+        },
+        // Action properties
+        action: {
+            type: 'forward',
+            target: {
+                host: legacyConfig.destinationIps,
+                port: legacyConfig.destinationPorts[0]
+            },
+            // TLS mode is always 'terminate' for legacy configs
+            tls: {
+                mode: 'terminate',
+                certificate: {
+                    key: legacyConfig.privateKey,
+                    cert: legacyConfig.publicKey
+                }
+            },
+            // Advanced options
+            advanced: {
+                // Rewrite host header if specified
+                headers: legacyConfig.rewriteHostHeader ? { 'host': '{domain}' } : {}
+            }
+        },
+        // Metadata
+        name: `Legacy Config - ${legacyConfig.hostName}`,
+        priority: 0, // Default priority
+        enabled: true
+    };
+    // Add authentication if present
+    if (legacyConfig.authentication) {
+        routeConfig.action.security = {
+            authentication: {
+                type: 'basic',
+                credentials: [{
+                        username: legacyConfig.authentication.user,
+                        password: legacyConfig.authentication.pass
+                    }]
+            }
+        };
+    }
+    // Add backend protocol if specified
+    if (legacyConfig.backendProtocol) {
+        if (!routeConfig.action.options) {
+            routeConfig.action.options = {};
+        }
+        routeConfig.action.options.backendProtocol = legacyConfig.backendProtocol;
+    }
+    return routeConfig;
+}
+/**
+ * Route manager for NetworkProxy
+ * Handles route matching and configuration
+ */
+export class RouteManager {
+    constructor(logger) {
+        this.routes = [];
+        this.logger = logger;
+    }
+    /**
+     * Update the routes configuration
+     */
+    updateRoutes(routes) {
+        // Sort routes by priority (higher first)
+        this.routes = [...routes].sort((a, b) => {
+            const priorityA = a.priority ?? 0;
+            const priorityB = b.priority ?? 0;
+            return priorityB - priorityA;
+        });
+        this.logger.info(`Updated RouteManager with ${this.routes.length} routes`);
+    }
+    /**
+     * Get all routes
+     */
+    getRoutes() {
+        return [...this.routes];
+    }
+    /**
+     * Find the first matching route for a context
+     */
+    findMatchingRoute(context) {
+        for (const route of this.routes) {
+            if (this.matchesRoute(route, context)) {
+                return route;
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if a route matches the given context
+     */
+    matchesRoute(route, context) {
+        // Skip disabled routes
+        if (route.enabled === false) {
+            return false;
+        }
+        // Check domain match if specified
+        if (route.match.domains && context.domain) {
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            if (!domains.some(domainPattern => this.matchDomain(domainPattern, context.domain))) {
+                return false;
+            }
+        }
+        // Check path match if specified
+        if (route.match.path && context.path) {
+            if (!this.matchPath(route.match.path, context.path)) {
+                return false;
+            }
+        }
+        // Check client IP match if specified
+        if (route.match.clientIp && context.clientIp) {
+            if (!route.match.clientIp.some(ip => this.matchIp(ip, context.clientIp))) {
+                return false;
+            }
+        }
+        // Check TLS version match if specified
+        if (route.match.tlsVersion && context.tlsVersion) {
+            if (!route.match.tlsVersion.includes(context.tlsVersion)) {
+                return false;
+            }
+        }
+        // All criteria matched
+        return true;
+    }
+    /**
+     * Match a domain pattern against a domain
+     */
+    matchDomain(pattern, domain) {
+        if (pattern === domain) {
+            return true;
+        }
+        if (pattern.includes('*')) {
+            const regexPattern = pattern
+                .replace(/\./g, '\\.')
+                .replace(/\*/g, '.*');
+            const regex = new RegExp(`^${regexPattern}$`, 'i');
+            return regex.test(domain);
+        }
+        return false;
+    }
+    /**
+     * Match a path pattern against a path
+     */
+    matchPath(pattern, path) {
+        if (pattern === path) {
+            return true;
+        }
+        if (pattern.endsWith('*')) {
+            const prefix = pattern.slice(0, -1);
+            return path.startsWith(prefix);
+        }
+        return false;
+    }
+    /**
+     * Match an IP pattern against an IP
+     * Supports exact matches, wildcard patterns, and CIDR notation
+     */
+    matchIp(pattern, ip) {
+        // Exact match
+        if (pattern === ip) {
+            return true;
+        }
+        // Wildcard matching (e.g., 192.168.0.*)
+        if (pattern.includes('*')) {
+            const regexPattern = pattern
+                .replace(/\./g, '\\.')
+                .replace(/\*/g, '.*');
+            const regex = new RegExp(`^${regexPattern}$`);
+            return regex.test(ip);
+        }
+        // CIDR matching (e.g., 192.168.0.0/24)
+        if (pattern.includes('/')) {
+            try {
+                const [subnet, bits] = pattern.split('/');
+                // Convert IP addresses to numeric format for comparison
+                const ipBinary = this.ipToBinary(ip);
+                const subnetBinary = this.ipToBinary(subnet);
+                if (!ipBinary || !subnetBinary) {
+                    return false;
+                }
+                // Get the subnet mask from CIDR notation
+                const mask = parseInt(bits, 10);
+                if (isNaN(mask) || mask < 0 || mask > 32) {
+                    return false;
+                }
+                // Check if the first 'mask' bits match between IP and subnet
+                return ipBinary.slice(0, mask) === subnetBinary.slice(0, mask);
+            }
+            catch (error) {
+                // If we encounter any error during CIDR matching, return false
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Convert an IP address to its binary representation
+     * @param ip The IP address to convert
+     * @returns Binary string representation or null if invalid
+     */
+    ipToBinary(ip) {
+        // Handle IPv4 addresses only for now
+        const parts = ip.split('.');
+        // Validate IP format
+        if (parts.length !== 4) {
+            return null;
+        }
+        // Convert each octet to 8-bit binary and concatenate
+        try {
+            return parts
+                .map(part => {
+                const num = parseInt(part, 10);
+                if (isNaN(num) || num < 0 || num > 255) {
+                    throw new Error('Invalid IP octet');
+                }
+                return num.toString(2).padStart(8, '0');
+            })
+                .join('');
+        }
+        catch (error) {
+            return null;
+        }
+    }
+}
 /**
  * Creates a logger based on the specified log level
  */
@@ -32,4 +273,4 @@ export function createLogger(logLevel = 'info') {
         }
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL25ldHdvcmstcHJveHkvbW9kZWxzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUF3Ri9DOztHQUVHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxXQUFtQixNQUFNO0lBQ3BELE1BQU0sU0FBUyxHQUFHO1FBQ2hCLEtBQUssRUFBRSxDQUFDO1FBQ1IsSUFBSSxFQUFFLENBQUM7UUFDUCxJQUFJLEVBQUUsQ0FBQztRQUNQLEtBQUssRUFBRSxDQUFDO0tBQ1QsQ0FBQztJQUVGLE9BQU87UUFDTCxLQUFLLEVBQUUsQ0FBQyxPQUFlLEVBQUUsSUFBVSxFQUFFLEVBQUU7WUFDckMsSUFBSSxTQUFTLENBQUMsUUFBUSxDQUFDLElBQUksU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUMzQyxPQUFPLENBQUMsR0FBRyxDQUFDLFdBQVcsT0FBTyxFQUFFLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQ2hELENBQUM7UUFDSCxDQUFDO1FBQ0QsSUFBSSxFQUFFLENBQUMsT0FBZSxFQUFFLElBQVUsRUFBRSxFQUFFO1lBQ3BDLElBQUksU0FBUyxDQUFDLFFBQVEsQ0FBQyxJQUFJLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztnQkFDMUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLE9BQU8sRUFBRSxFQUFFLElBQUksSUFBSSxFQUFFLENBQUMsQ0FBQztZQUMvQyxDQUFDO1FBQ0gsQ0FBQztRQUNELElBQUksRUFBRSxDQUFDLE9BQWUsRUFBRSxJQUFVLEVBQUUsRUFBRTtZQUNwQyxJQUFJLFNBQVMsQ0FBQyxRQUFRLENBQUMsSUFBSSxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7Z0JBQzFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsVUFBVSxPQUFPLEVBQUUsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLENBQUM7WUFDaEQsQ0FBQztRQUNILENBQUM7UUFDRCxLQUFLLEVBQUUsQ0FBQyxPQUFlLEVBQUUsSUFBVSxFQUFFLEVBQUU7WUFDckMsSUFBSSxTQUFTLENBQUMsUUFBUSxDQUFDLElBQUksU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUMzQyxPQUFPLENBQUMsS0FBSyxDQUFDLFdBQVcsT0FBTyxFQUFFLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQ2xELENBQUM7UUFDSCxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../ts/proxies/network-proxy/models/types.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/network-proxy/network-proxy.d.ts

@@ -1,5 +1,6 @@
 import * as plugins from '../../plugins.js';
-import type { INetworkProxyOptions, IReverseProxyConfig } from './models/types.js';
+import type { INetworkProxyOptions } from './models/types.js';
+import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
 import { type IMetricsTracker } from './request-handler.js';
 import { Port80Handler } from '../../http/port80/port80-handler.js';
 /**
@@ -9,13 +10,16 @@ import { Port80Handler } from '../../http/port80/port80-handler.js';
 export declare class NetworkProxy implements IMetricsTracker {
     toJSON(): any;
     options: INetworkProxyOptions;
-    proxyConfigs: IReverseProxyConfig[];
+    routes: IRouteConfig[];
     httpsServer: any;
     private certificateManager;
     private connectionPool;
     private requestHandler;
     private webSocketHandler;
+    private legacyRouter;
     private router;
+    private routeManager;
+    private functionCache;
     socketMap: plugins.lik.ObjectMap<plugins.net.Socket>;
     activeContexts: Set<string>;
     connectedClients: number;
@@ -77,23 +81,10 @@ export declare class NetworkProxy implements IMetricsTracker {
      */
     private setupMetricsCollection;
     /**
-     * Updates proxy configurations
+     * Updates the route configurations - this is the primary method for configuring NetworkProxy
+     * @param routes The new route configurations to use
      */
-    updateProxyConfigs(proxyConfigsArg: IReverseProxyConfig[]): Promise<void>;
-    /**
-     * Converts SmartProxy domain configurations to NetworkProxy configs
-     * @param domainConfigs SmartProxy domain configs
-     * @param sslKeyPair Default SSL key pair to use if not specified
-     * @returns Array of NetworkProxy configs
-     */
-    convertSmartProxyConfigs(domainConfigs: Array<{
-        domains: string[];
-        targetIPs?: string[];
-        allowedIPs?: string[];
-    }>, sslKeyPair?: {
-        key: string;
-        cert: string;
-    }): IReverseProxyConfig[];
+    updateRouteConfigs(routes: IRouteConfig[]): Promise<void>;
     /**
      * Adds default headers to be included in all responses
      */
@@ -112,7 +103,19 @@ export declare class NetworkProxy implements IMetricsTracker {
      */
     requestCertificate(domain: string): Promise<boolean>;
     /**
-     * Gets all proxy configurations currently in use
+     * Update certificate for a domain
+     *
+     * This method allows direct updates of certificates from external sources
+     * like Port80Handler or custom certificate providers.
+     *
+     * @param domain The domain to update certificate for
+     * @param certificate The new certificate (public key)
+     * @param privateKey The new private key
+     * @param expiryDate Optional expiry date
+     */
+    updateCertificate(domain: string, certificate: string, privateKey: string, expiryDate?: Date): void;
+    /**
+     * Gets all route configurations currently in use
      */
-    getProxyConfigs(): IReverseProxyConfig[];
+    getRouteConfigs(): IRouteConfig[];
 }