@push.rocks/smartproxy 22.4.2 → 22.6.0

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '22.4.2',
+  version: '22.6.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.'
 }

package/ts/index.ts

@@ -5,15 +5,10 @@
 // NFTables proxy exports
 export * from './proxies/nftables-proxy/index.js';
 
-// Export HttpProxy elements
-export { HttpProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './proxies/http-proxy/index.js';
-export type { IMetricsTracker, MetricsTracker } from './proxies/http-proxy/index.js';
-export type { IHttpProxyOptions, ICertificateEntry, ILogger } from './proxies/http-proxy/models/types.js';
-export { SharedRouteManager as HttpProxyRouteManager } from './core/routing/route-manager.js';
-
-// Export SmartProxy elements selectively to avoid RouteManager ambiguity
-export { SmartProxy, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, HttpProxyBridge, RouteConnectionHandler, SmartCertManager } from './proxies/smart-proxy/index.js';
+// Export SmartProxy elements
+export { SmartProxy } from './proxies/smart-proxy/index.js';
 export { SharedRouteManager as RouteManager } from './core/routing/route-manager.js';
+
 // Export smart-proxy models
 export type { ISmartProxyOptions, IConnectionRecord, IRouteConfig, IRouteMatch, IRouteAction, IRouteTls, IRouteContext } from './proxies/smart-proxy/models/index.js';
 export type { TSmartProxyCertProvisionObject } from './proxies/smart-proxy/models/interfaces.js';
@@ -22,8 +17,6 @@ export * from './proxies/smart-proxy/utils/index.js';
 // Original: export * from './smartproxy/classes.pp.snihandler.js'
 // Now we export from the new module
 export { SniHandler } from './tls/sni/sni-handler.js';
-// Original: export * from './smartproxy/classes.pp.interfaces.js'
-// Now we export from the new module (selectively to avoid conflicts)
 
 // Core types and utilities
 export * from './core/models/common-types.js';
@@ -32,8 +25,7 @@ export * from './core/models/common-types.js';
 export type { IAcmeOptions } from './proxies/smart-proxy/models/interfaces.js';
 
 // Modular exports for new architecture
-// Certificate module has been removed - use SmartCertManager instead
 export * as tls from './tls/index.js';
 export * as routing from './routing/index.js';
 export * as detection from './detection/index.js';
-export * as protocols from './protocols/index.js';
+export * as protocols from './protocols/index.js';

package/ts/protocols/common/fragment-handler.ts

@@ -49,6 +49,10 @@ export class FragmentHandler {
         () => this.cleanup(),
         options.cleanupInterval
       );
+      // Don't let this timer prevent process exit
+      if (this.cleanupTimer.unref) {
+        this.cleanupTimer.unref();
+      }
     }
   }
   

package/ts/proxies/index.ts

@@ -2,16 +2,8 @@
  * Proxy implementations module
  */
 
-// Export HttpProxy with selective imports to avoid conflicts
-export { HttpProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './http-proxy/index.js';
-export type { IMetricsTracker, MetricsTracker } from './http-proxy/index.js';
-// Export http-proxy models except IAcmeOptions
-export type { IHttpProxyOptions, ICertificateEntry, ILogger } from './http-proxy/models/types.js';
-// RouteManager has been unified - use SharedRouteManager from core/routing
-export { SharedRouteManager as HttpProxyRouteManager } from '../core/routing/route-manager.js';
-
 // Export SmartProxy with selective imports to avoid conflicts
-export { SmartProxy, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, HttpProxyBridge, RouteConnectionHandler } from './smart-proxy/index.js';
+export { SmartProxy } from './smart-proxy/index.js';
 export { SharedRouteManager as SmartProxyRouteManager } from '../core/routing/route-manager.js';
 export * from './smart-proxy/utils/index.js';
 // Export smart-proxy models except IAcmeOptions

package/ts/proxies/smart-proxy/index.ts

@@ -1,7 +1,7 @@
 /**
  * SmartProxy implementation
  *
- * Version 14.0.0: Unified Route-Based Configuration API
+ * Version 23.0.0: Rust-backed proxy engine
  */
 // Re-export models
 export * from './models/index.js';
@@ -9,21 +9,14 @@ export * from './models/index.js';
 // Export the main SmartProxy class
 export { SmartProxy } from './smart-proxy.js';
 
-// Export core supporting classes
-export { ConnectionManager } from './connection-manager.js';
-export { SecurityManager } from './security-manager.js';
-export { TimeoutManager } from './timeout-manager.js';
-export { TlsManager } from './tls-manager.js';
-export { HttpProxyBridge } from './http-proxy-bridge.js';
+// Export Rust bridge and helpers
+export { RustProxyBridge } from './rust-proxy-bridge.js';
+export { RoutePreprocessor } from './route-preprocessor.js';
+export { SocketHandlerServer } from './socket-handler-server.js';
+export { RustMetricsAdapter } from './rust-metrics-adapter.js';
 
 // Export route-based components
 export { SharedRouteManager as RouteManager } from '../../core/routing/route-manager.js';
-export { RouteConnectionHandler } from './route-connection-handler.js';
-export { NFTablesManager } from './nftables-manager.js';
-export { RouteOrchestrator } from './route-orchestrator.js';
-
-// Export certificate management
-export { SmartCertManager } from './certificate-manager.js';
 
 // Export all helper functions from the utils directory
 export * from './utils/index.js';

package/ts/proxies/smart-proxy/models/interfaces.ts

@@ -99,10 +99,6 @@ export interface ISmartProxyOptions {
   keepAliveInactivityMultiplier?: number; // Multiplier for inactivity timeout for keep-alive connections
   extendedKeepAliveLifetime?: number; // Extended lifetime for keep-alive connections (ms)
 
-  // HttpProxy integration
-  useHttpProxy?: number[]; // Array of ports to forward to HttpProxy
-  httpProxyPort?: number; // Port where HttpProxy is listening (default: 8443)
-
   // Metrics configuration
   metrics?: {
     enabled?: boolean;
@@ -139,6 +135,12 @@ export interface ISmartProxyOptions {
    * Default: true
    */
   certProvisionFallbackToAcme?: boolean;
+
+  /**
+   * Path to the RustProxy binary. If not set, the binary is located
+   * automatically via env var, platform package, local build, or PATH.
+   */
+  rustBinaryPath?: string;
 }
 
 /**

package/ts/proxies/smart-proxy/route-preprocessor.ts

@@ -0,0 +1,122 @@
+import type { IRouteConfig, IRouteAction, IRouteTarget } from './models/route-types.js';
+import { logger } from '../../core/utils/logger.js';
+
+/**
+ * Preprocesses routes before sending them to Rust.
+ *
+ * Strips non-serializable fields (functions, callbacks) and classifies
+ * routes that must be handled by TypeScript (socket-handler, dynamic host/port).
+ */
+export class RoutePreprocessor {
+  /**
+   * Map of route name/id → original route config (with JS functions preserved).
+   * Used by the socket handler server to look up the original handler.
+   */
+  private originalRoutes = new Map<string, IRouteConfig>();
+
+  /**
+   * Preprocess routes for the Rust binary.
+   *
+   * - Routes with `socketHandler` callbacks are marked as socket-handler type
+   *   (Rust will relay these back to TS)
+   * - Routes with dynamic `host`/`port` functions are converted to socket-handler
+   *   type (Rust relays, TS resolves the function)
+   * - Non-serializable fields are stripped
+   * - Original routes are preserved in the local map for handler lookup
+   */
+  public preprocessForRust(routes: IRouteConfig[]): IRouteConfig[] {
+    this.originalRoutes.clear();
+    return routes.map((route, index) => this.preprocessRoute(route, index));
+  }
+
+  /**
+   * Get the original route config (with JS functions) by route name or id.
+   */
+  public getOriginalRoute(routeKey: string): IRouteConfig | undefined {
+    return this.originalRoutes.get(routeKey);
+  }
+
+  /**
+   * Get all original routes that have socket handlers or dynamic functions.
+   */
+  public getHandlerRoutes(): Map<string, IRouteConfig> {
+    return new Map(this.originalRoutes);
+  }
+
+  private preprocessRoute(route: IRouteConfig, index: number): IRouteConfig {
+    const routeKey = route.name || route.id || `route_${index}`;
+
+    // Check if this route needs TS-side handling
+    const needsTsHandling = this.routeNeedsTsHandling(route);
+
+    if (needsTsHandling) {
+      // Store the original route for handler lookup
+      this.originalRoutes.set(routeKey, route);
+    }
+
+    // Create a clean copy for Rust
+    const cleanRoute: IRouteConfig = {
+      ...route,
+      action: this.cleanAction(route.action, routeKey, needsTsHandling),
+    };
+
+    // Ensure we have a name for handler lookup
+    if (!cleanRoute.name && !cleanRoute.id) {
+      cleanRoute.name = routeKey;
+    }
+
+    return cleanRoute;
+  }
+
+  private routeNeedsTsHandling(route: IRouteConfig): boolean {
+    // Socket handler routes always need TS
+    if (route.action.type === 'socket-handler' && route.action.socketHandler) {
+      return true;
+    }
+
+    // Routes with dynamic host/port functions need TS
+    if (route.action.targets) {
+      for (const target of route.action.targets) {
+        if (typeof target.host === 'function' || typeof target.port === 'function') {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  private cleanAction(action: IRouteAction, routeKey: string, needsTsHandling: boolean): IRouteAction {
+    const cleanAction: IRouteAction = { ...action };
+
+    if (needsTsHandling) {
+      // Convert to socket-handler type for Rust (Rust will relay back to TS)
+      cleanAction.type = 'socket-handler';
+      // Remove the JS handler (not serializable)
+      delete (cleanAction as any).socketHandler;
+    }
+
+    // Clean targets - replace functions with static values
+    if (cleanAction.targets) {
+      cleanAction.targets = cleanAction.targets.map(t => this.cleanTarget(t));
+    }
+
+    return cleanAction;
+  }
+
+  private cleanTarget(target: IRouteTarget): IRouteTarget {
+    const clean: IRouteTarget = { ...target };
+
+    // Replace function host with placeholder
+    if (typeof clean.host === 'function') {
+      clean.host = 'localhost';
+    }
+
+    // Replace function port with placeholder
+    if (typeof clean.port === 'function') {
+      clean.port = 0;
+    }
+
+    return clean;
+  }
+}

package/ts/proxies/smart-proxy/rust-binary-locator.ts

@@ -0,0 +1,112 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../core/utils/logger.js';
+
+/**
+ * Locates the RustProxy binary using a priority-ordered search strategy:
+ * 1. SMARTPROXY_RUST_BINARY environment variable
+ * 2. Platform-specific optional npm package
+ * 3. Local development build at ./rust/target/release/rustproxy
+ * 4. System PATH
+ */
+export class RustBinaryLocator {
+  private cachedPath: string | null = null;
+
+  /**
+   * Find the RustProxy binary path.
+   * Returns null if no binary is available.
+   */
+  public async findBinary(): Promise<string | null> {
+    if (this.cachedPath !== null) {
+      return this.cachedPath;
+    }
+
+    const path = await this.searchBinary();
+    this.cachedPath = path;
+    return path;
+  }
+
+  /**
+   * Clear the cached binary path (e.g., after a failed launch).
+   */
+  public clearCache(): void {
+    this.cachedPath = null;
+  }
+
+  private async searchBinary(): Promise<string | null> {
+    // 1. Environment variable override
+    const envPath = process.env.SMARTPROXY_RUST_BINARY;
+    if (envPath) {
+      if (await this.isExecutable(envPath)) {
+        logger.log('info', `RustProxy binary found via SMARTPROXY_RUST_BINARY: ${envPath}`, { component: 'rust-locator' });
+        return envPath;
+      }
+      logger.log('warn', `SMARTPROXY_RUST_BINARY set but not executable: ${envPath}`, { component: 'rust-locator' });
+    }
+
+    // 2. Platform-specific optional npm package
+    const platformBinary = await this.findPlatformPackageBinary();
+    if (platformBinary) {
+      logger.log('info', `RustProxy binary found in platform package: ${platformBinary}`, { component: 'rust-locator' });
+      return platformBinary;
+    }
+
+    // 3. Local development build
+    const localPaths = [
+      plugins.path.resolve(process.cwd(), 'rust/target/release/rustproxy'),
+      plugins.path.resolve(process.cwd(), 'rust/target/debug/rustproxy'),
+    ];
+    for (const localPath of localPaths) {
+      if (await this.isExecutable(localPath)) {
+        logger.log('info', `RustProxy binary found at local path: ${localPath}`, { component: 'rust-locator' });
+        return localPath;
+      }
+    }
+
+    // 4. System PATH
+    const systemPath = await this.findInPath('rustproxy');
+    if (systemPath) {
+      logger.log('info', `RustProxy binary found in system PATH: ${systemPath}`, { component: 'rust-locator' });
+      return systemPath;
+    }
+
+    logger.log('error', 'No RustProxy binary found. Set SMARTPROXY_RUST_BINARY, install the platform package, or build with: cd rust && cargo build --release', { component: 'rust-locator' });
+    return null;
+  }
+
+  private async findPlatformPackageBinary(): Promise<string | null> {
+    const platform = process.platform;
+    const arch = process.arch;
+    const packageName = `@push.rocks/smartproxy-${platform}-${arch}`;
+
+    try {
+      // Try to resolve the platform-specific package
+      const packagePath = require.resolve(`${packageName}/rustproxy`);
+      if (await this.isExecutable(packagePath)) {
+        return packagePath;
+      }
+    } catch {
+      // Package not installed - expected for development
+    }
+    return null;
+  }
+
+  private async isExecutable(filePath: string): Promise<boolean> {
+    try {
+      await plugins.fs.promises.access(filePath, plugins.fs.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async findInPath(binaryName: string): Promise<string | null> {
+    const pathDirs = (process.env.PATH || '').split(plugins.path.delimiter);
+    for (const dir of pathDirs) {
+      const fullPath = plugins.path.join(dir, binaryName);
+      if (await this.isExecutable(fullPath)) {
+        return fullPath;
+      }
+    }
+    return null;
+  }
+}

package/ts/proxies/smart-proxy/rust-metrics-adapter.ts

@@ -0,0 +1,161 @@
+import type { IMetrics, IThroughputData, IThroughputHistoryPoint } from './models/metrics-types.js';
+import type { RustProxyBridge } from './rust-proxy-bridge.js';
+
+/**
+ * Adapts Rust JSON metrics to the IMetrics interface.
+ *
+ * Polls the Rust binary periodically via the bridge and caches the result.
+ * All IMetrics getters read from the cache synchronously.
+ *
+ * Rust Metrics JSON fields (camelCase via serde):
+ *   activeConnections, totalConnections, bytesIn, bytesOut,
+ *   throughputInBytesPerSec, throughputOutBytesPerSec,
+ *   routes: { [routeName]: { activeConnections, totalConnections, bytesIn, bytesOut, ... } }
+ */
+export class RustMetricsAdapter implements IMetrics {
+  private bridge: RustProxyBridge;
+  private cache: any = null;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private pollIntervalMs: number;
+
+  constructor(bridge: RustProxyBridge, pollIntervalMs = 1000) {
+    this.bridge = bridge;
+    this.pollIntervalMs = pollIntervalMs;
+  }
+
+  /**
+   * Poll Rust for metrics once. Can be awaited to ensure cache is fresh.
+   */
+  public async poll(): Promise<void> {
+    try {
+      this.cache = await this.bridge.getMetrics();
+    } catch {
+      // Ignore poll errors (bridge may be shutting down)
+    }
+  }
+
+  public startPolling(): void {
+    if (this.pollTimer) return;
+    // Immediate first poll so cache is populated ASAP
+    this.poll();
+    this.pollTimer = setInterval(() => {
+      this.poll();
+    }, this.pollIntervalMs);
+    if (this.pollTimer.unref) {
+      this.pollTimer.unref();
+    }
+  }
+
+  public stopPolling(): void {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+
+  // --- IMetrics implementation ---
+
+  public connections = {
+    active: (): number => {
+      return this.cache?.activeConnections ?? 0;
+    },
+    total: (): number => {
+      return this.cache?.totalConnections ?? 0;
+    },
+    byRoute: (): Map<string, number> => {
+      const result = new Map<string, number>();
+      if (this.cache?.routes) {
+        for (const [name, rm] of Object.entries(this.cache.routes)) {
+          result.set(name, (rm as any).activeConnections ?? 0);
+        }
+      }
+      return result;
+    },
+    byIP: (): Map<string, number> => {
+      // Per-IP tracking not yet available from Rust
+      return new Map();
+    },
+    topIPs: (_limit?: number): Array<{ ip: string; count: number }> => {
+      // Per-IP tracking not yet available from Rust
+      return [];
+    },
+  };
+
+  public throughput = {
+    instant: (): IThroughputData => {
+      return {
+        in: this.cache?.throughputInBytesPerSec ?? 0,
+        out: this.cache?.throughputOutBytesPerSec ?? 0,
+      };
+    },
+    recent: (): IThroughputData => {
+      return this.throughput.instant();
+    },
+    average: (): IThroughputData => {
+      return this.throughput.instant();
+    },
+    custom: (_seconds: number): IThroughputData => {
+      return this.throughput.instant();
+    },
+    history: (_seconds: number): Array<IThroughputHistoryPoint> => {
+      // Throughput history not yet available from Rust
+      return [];
+    },
+    byRoute: (_windowSeconds?: number): Map<string, IThroughputData> => {
+      const result = new Map<string, IThroughputData>();
+      if (this.cache?.routes) {
+        for (const [name, rm] of Object.entries(this.cache.routes)) {
+          result.set(name, {
+            in: (rm as any).throughputInBytesPerSec ?? 0,
+            out: (rm as any).throughputOutBytesPerSec ?? 0,
+          });
+        }
+      }
+      return result;
+    },
+    byIP: (_windowSeconds?: number): Map<string, IThroughputData> => {
+      return new Map();
+    },
+  };
+
+  public requests = {
+    perSecond: (): number => {
+      // Rust tracks connections, not HTTP requests (TCP-level proxy)
+      return 0;
+    },
+    perMinute: (): number => {
+      return 0;
+    },
+    total: (): number => {
+      // Use total connections as a proxy for total requests
+      return this.cache?.totalConnections ?? 0;
+    },
+  };
+
+  public totals = {
+    bytesIn: (): number => {
+      return this.cache?.bytesIn ?? 0;
+    },
+    bytesOut: (): number => {
+      return this.cache?.bytesOut ?? 0;
+    },
+    connections: (): number => {
+      return this.cache?.totalConnections ?? 0;
+    },
+  };
+
+  public percentiles = {
+    connectionDuration: (): { p50: number; p95: number; p99: number } => {
+      return { p50: 0, p95: 0, p99: 0 };
+    },
+    bytesTransferred: (): {
+      in: { p50: number; p95: number; p99: number };
+      out: { p50: number; p95: number; p99: number };
+    } => {
+      return {
+        in: { p50: 0, p95: 0, p99: 0 },
+        out: { p50: 0, p95: 0, p99: 0 },
+      };
+    },
+  };
+}