@push.rocks/smartproxy 13.1.3 → 15.0.0

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/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 - now always assume route-based config
+ */
+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,11 @@
 import * as plugins from '../../../plugins.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvc21hcnQtcHJveHkvbW9kZWxzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQyJ9
+/**
+ * Helper functions for type checking - now always assume route-based config
+ */
+export function isLegacyOptions(options) {
+    return false; // No longer supporting legacy options
+}
+export function isRoutedOptions(options) {
+    return true; // Always assume routed options
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvc21hcnQtcHJveHkvbW9kZWxzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQStEL0M7O0dBRUc7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUFDLE9BQVk7SUFDMUMsT0FBTyxLQUFLLENBQUMsQ0FBQyxzQ0FBc0M7QUFDdEQsQ0FBQztBQUVELE1BQU0sVUFBVSxlQUFlLENBQUMsT0FBWTtJQUMxQyxPQUFPLElBQUksQ0FBQyxDQUFDLCtCQUErQjtBQUM5QyxDQUFDIn0=

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=

package/dist_ts/proxies/smart-proxy/route-connection-handler.d.ts

@@ -0,0 +1,55 @@
+import * as plugins from '../../plugins.js';
+import type { ISmartProxyOptions } from './models/interfaces.js';
+import { ConnectionManager } from './connection-manager.js';
+import { SecurityManager } from './security-manager.js';
+import { DomainConfigManager } from './domain-config-manager.js';
+import { TlsManager } from './tls-manager.js';
+import { NetworkProxyBridge } from './network-proxy-bridge.js';
+import { TimeoutManager } from './timeout-manager.js';
+import { RouteManager } from './route-manager.js';
+/**
+ * Handles new connection processing and setup logic with support for route-based configuration
+ */
+export declare class RouteConnectionHandler {
+    private connectionManager;
+    private securityManager;
+    private domainConfigManager;
+    private tlsManager;
+    private networkProxyBridge;
+    private timeoutManager;
+    private routeManager;
+    private settings;
+    constructor(settings: ISmartProxyOptions, connectionManager: ConnectionManager, securityManager: SecurityManager, domainConfigManager: DomainConfigManager, tlsManager: TlsManager, networkProxyBridge: NetworkProxyBridge, timeoutManager: TimeoutManager, routeManager: RouteManager);
+    /**
+     * Handle a new incoming connection
+     */
+    handleConnection(socket: plugins.net.Socket): void;
+    /**
+     * Handle a connection and wait for TLS handshake for SNI extraction if needed
+     */
+    private handleTlsConnection;
+    /**
+     * Route the connection based on match criteria
+     */
+    private routeConnection;
+    /**
+     * Handle a forward action for a route
+     */
+    private handleForwardAction;
+    /**
+     * Handle a redirect action for a route
+     */
+    private handleRedirectAction;
+    /**
+     * Handle a block action for a route
+     */
+    private handleBlockAction;
+    /**
+     * Handle a connection using legacy domain configuration
+     */
+    private handleLegacyConnection;
+    /**
+     * Sets up a direct connection to the target
+     */
+    private setupDirectConnection;
+}