@push.rocks/smartproxy 22.4.2 → 22.6.0

package/changelog.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 2026-02-09 - 22.6.0 - feat(smart-proxy)
+add socket-handler relay, fast-path port-only forwarding, metrics and bridge improvements, and various TS/Rust integration fixes
+
+- Add Unix-domain socket relay for socket-handler routes so Rust can hand off matched connections to TypeScript handlers (metadata JSON + initial bytes, relay implementation in Rust and SocketHandlerServer in TS).
+- Implement fast-path port-only forwarding in the TCP accept/handler path to forward simple non-TLS, port-only routes immediately without peeking at client data (improves server-speaks-first protocol handling).
+- Use ArcSwap for route manager hot-reload visibility in accept loops and share socket_handler_relay via Arc<RwLock> so listeners see relay path updates immediately.
+- Enhance SNI/HTTP parsing: add extract_http_path and extract_http_host to aid domain/path matching from initial data.
+- Improve RustProxy shutdown/kill handling: remove listeners, reject pending requests, destroy stdio pipes and unref process to avoid leaking handles.
+- Enhance Rust <-> TS metrics bridge and adapter: add immediate poll(), map Rust JSON fields to IMetrics (per-route active/throughput/totals), and use safer polling/unref timers.
+- SocketHandlerServer enhancements: track active sockets, destroy on stop, pause/resume to prevent data loss, support async socketHandler callbacks and dynamic function-based target forwarding (resolve host/port functions and forward).
+- TypeScript smart-proxy lifecycle tweaks: only set bridge relay after Rust starts, guard unexpected-exit emission when intentionally stopping, stop polling and remove listeners on stop, add stopping flag.
+- Misc: README and API ergonomics updates (nft proxy option renames and config comments), various test updates to use stable http.request helper, adjust timeouts/metrics sampling and assertions, and multiple small bugfixes in listeners, timeouts and TLS typings. 
+
+## 2026-02-09 - 22.5.0 - feat(rustproxy)
+introduce a Rust-powered proxy engine and workspace with core crates for proxy functionality, ACME/TLS support, passthrough and HTTP proxies, metrics, nftables integration, routing/security, management IPC, tests, and README updates
+
+- Add Rust workspace and multiple crates: rustproxy, rustproxy-config, rustproxy-routing, rustproxy-tls, rustproxy-passthrough, rustproxy-http, rustproxy-nftables, rustproxy-metrics, rustproxy-security
+- Implement ACME integration (instant-acme) and an HTTP-01 challenge server with certificate lifecycle management
+- Add TLS management: cert store, cert manager, SNI resolver, TLS acceptor/connector and certificate hot-swap support
+- Implement TCP/TLS passthrough engine with ClientHello SNI parsing, PROXY v1 support, connection tracking and bidirectional forwarder
+- Add Hyper-based HTTP proxy components: request/response filtering, CORS, auth, header templating and upstream selection with load balancing
+- Introduce metrics (throughput tracker, metrics collector) and log deduplication utilities
+- Implement nftables manager and rule builder (safe no-op behavior when not running as root)
+- Add route types, validation, helpers, route manager and matchers (domain/path/header/ip)
+- Provide management IPC (JSON over stdin/stdout) for TypeScript wrapper control (start/stop/add/remove ports, load certificates, etc.)
+- Include extensive unit and integration tests, test helpers, and an example Rust config.json
+- Update README to document the Rust-powered engine, new features and rustBinaryPath lookup
+
 ## 2026-01-31 - 22.4.2 - fix(tests)
 shorten long-lived connection test timeouts and update certificate metadata timestamps
 

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 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.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -2,11 +2,7 @@
  * SmartProxy main module exports
  */
 export * from './proxies/nftables-proxy/index.js';
-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, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, HttpProxyBridge, RouteConnectionHandler, SmartCertManager } from './proxies/smart-proxy/index.js';
+export { SmartProxy } from './proxies/smart-proxy/index.js';
 export { SharedRouteManager as RouteManager } from './core/routing/route-manager.js';
 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';

package/dist_ts/index.js

@@ -3,24 +3,18 @@
  */
 // 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 { 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 * 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';
 // 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';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHlCQUF5QjtBQUN6QixjQUFjLG1DQUFtQyxDQUFDO0FBRWxELDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsU0FBUyxFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBRSxjQUFjLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUdoSSxPQUFPLEVBQUUsa0JBQWtCLElBQUkscUJBQXFCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5Rix5RUFBeUU7QUFDekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxpQkFBaUIsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsc0JBQXNCLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN2TCxPQUFPLEVBQUUsa0JBQWtCLElBQUksWUFBWSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFJckYsY0FBYyxzQ0FBc0MsQ0FBQztBQUVyRCxrRUFBa0U7QUFDbEUsb0NBQW9DO0FBQ3BDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN0RCxrRUFBa0U7QUFDbEUscUVBQXFFO0FBRXJFLDJCQUEyQjtBQUMzQixjQUFjLCtCQUErQixDQUFDO0FBSzlDLHVDQUF1QztBQUN2QyxxRUFBcUU7QUFDckUsT0FBTyxLQUFLLEdBQUcsTUFBTSxnQkFBZ0IsQ0FBQztBQUN0QyxPQUFPLEtBQUssT0FBTyxNQUFNLG9CQUFvQixDQUFDO0FBQzlDLE9BQU8sS0FBSyxTQUFTLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxLQUFLLFNBQVMsTUFBTSxzQkFBc0IsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHlCQUF5QjtBQUN6QixjQUFjLG1DQUFtQyxDQUFDO0FBRWxELDZCQUE2QjtBQUM3QixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDNUQsT0FBTyxFQUFFLGtCQUFrQixJQUFJLFlBQVksRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBS3JGLGNBQWMsc0NBQXNDLENBQUM7QUFFckQsa0VBQWtFO0FBQ2xFLG9DQUFvQztBQUNwQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFdEQsMkJBQTJCO0FBQzNCLGNBQWMsK0JBQStCLENBQUM7QUFLOUMsdUNBQXVDO0FBQ3ZDLE9BQU8sS0FBSyxHQUFHLE1BQU0sZ0JBQWdCLENBQUM7QUFDdEMsT0FBTyxLQUFLLE9BQU8sTUFBTSxvQkFBb0IsQ0FBQztBQUM5QyxPQUFPLEtBQUssU0FBUyxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sS0FBSyxTQUFTLE1BQU0sc0JBQXNCLENBQUMifQ==

package/dist_ts/protocols/common/fragment-handler.js

@@ -15,6 +15,10 @@ export class FragmentHandler {
         // Start cleanup timer if not already running
         if (options.cleanupInterval && !this.cleanupTimer) {
             this.cleanupTimer = setInterval(() => this.cleanup(), options.cleanupInterval);
+            // Don't let this timer prevent process exit
+            if (this.cleanupTimer.unref) {
+                this.cleanupTimer.unref();
+            }
         }
     }
     /**
@@ -114,4 +118,4 @@ export class FragmentHandler {
         return this.fragments.size;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/index.d.ts

@@ -1,11 +1,7 @@
 /**
  * Proxy implementations module
  */
-export { HttpProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './http-proxy/index.js';
-export type { IMetricsTracker, MetricsTracker } from './http-proxy/index.js';
-export type { IHttpProxyOptions, ICertificateEntry, ILogger } from './http-proxy/models/types.js';
-export { SharedRouteManager as HttpProxyRouteManager } from '../core/routing/route-manager.js';
-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 type { ISmartProxyOptions, IConnectionRecord, IRouteConfig, IRouteMatch, IRouteAction, IRouteTls, IRouteContext } from './smart-proxy/models/index.js';

package/dist_ts/proxies/index.js

@@ -1,14 +1,10 @@
 /**
  * Proxy implementations module
  */
-// Export HttpProxy with selective imports to avoid conflicts
-export { HttpProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './http-proxy/index.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 NFTables proxy (no conflicts)
 export * from './nftables-proxy/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wcm94aWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsNkRBQTZEO0FBQzdELE9BQU8sRUFBRSxTQUFTLEVBQUUsa0JBQWtCLEVBQUUsY0FBYyxFQUFFLGNBQWMsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBSXhILDJFQUEyRTtBQUMzRSxPQUFPLEVBQUUsa0JBQWtCLElBQUkscUJBQXFCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUUvRiw4REFBOEQ7QUFDOUQsT0FBTyxFQUFFLFVBQVUsRUFBRSxpQkFBaUIsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM3SixPQUFPLEVBQUUsa0JBQWtCLElBQUksc0JBQXNCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUNoRyxjQUFjLDhCQUE4QixDQUFDO0FBSTdDLHVDQUF1QztBQUN2QyxjQUFjLDJCQUEyQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wcm94aWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsOERBQThEO0FBQzlELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNwRCxPQUFPLEVBQUUsa0JBQWtCLElBQUksc0JBQXNCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUNoRyxjQUFjLDhCQUE4QixDQUFDO0FBSTdDLHVDQUF1QztBQUN2QyxjQUFjLDJCQUEyQixDQUFDIn0=

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

@@ -1,18 +1,13 @@
 /**
  * SmartProxy implementation
  *
- * Version 14.0.0: Unified Route-Based Configuration API
+ * Version 23.0.0: Rust-backed proxy engine
  */
 export * from './models/index.js';
 export { SmartProxy } from './smart-proxy.js';
-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 { 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 { 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 { SmartCertManager } from './certificate-manager.js';
 export * from './utils/index.js';

package/dist_ts/proxies/smart-proxy/index.js

@@ -1,25 +1,19 @@
 /**
  * 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';
 // 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';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxtQkFBbUI7QUFDbkIsY0FBYyxtQkFBbUIsQ0FBQztBQUVsQyxtQ0FBbUM7QUFDbkMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTlDLGlDQUFpQztBQUNqQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM5QyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFekQsZ0NBQWdDO0FBQ2hDLE9BQU8sRUFBRSxrQkFBa0IsSUFBSSxZQUFZLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUN6RixPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN2RSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFNUQsZ0NBQWdDO0FBQ2hDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTVELHVEQUF1RDtBQUN2RCxjQUFjLGtCQUFrQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxtQkFBbUI7QUFDbkIsY0FBYyxtQkFBbUIsQ0FBQztBQUVsQyxtQ0FBbUM7QUFDbkMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTlDLGlDQUFpQztBQUNqQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDekQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDNUQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDakUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFL0QsZ0NBQWdDO0FBQ2hDLE9BQU8sRUFBRSxrQkFBa0IsSUFBSSxZQUFZLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUV6Rix1REFBdUQ7QUFDdkQsY0FBYyxrQkFBa0IsQ0FBQyJ9

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

@@ -73,8 +73,6 @@ export interface ISmartProxyOptions {
     keepAliveTreatment?: 'standard' | 'extended' | 'immortal';
     keepAliveInactivityMultiplier?: number;
     extendedKeepAliveLifetime?: number;
-    useHttpProxy?: number[];
-    httpProxyPort?: number;
     metrics?: {
         enabled?: boolean;
         sampleIntervalMs?: number;
@@ -107,6 +105,11 @@ 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;
 }
 /**
  * Enhanced connection record

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

@@ -0,0 +1,37 @@
+import type { IRouteConfig } from './models/route-types.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 declare 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;
+    /**
+     * 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
+     */
+    preprocessForRust(routes: IRouteConfig[]): IRouteConfig[];
+    /**
+     * Get the original route config (with JS functions) by route name or id.
+     */
+    getOriginalRoute(routeKey: string): IRouteConfig | undefined;
+    /**
+     * Get all original routes that have socket handlers or dynamic functions.
+     */
+    getHandlerRoutes(): Map<string, IRouteConfig>;
+    private preprocessRoute;
+    private routeNeedsTsHandling;
+    private cleanAction;
+    private cleanTarget;
+}

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

@@ -0,0 +1,103 @@
+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 {
+    constructor() {
+        /**
+         * Map of route name/id → original route config (with JS functions preserved).
+         * Used by the socket handler server to look up the original handler.
+         */
+        this.originalRoutes = new Map();
+    }
+    /**
+     * 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
+     */
+    preprocessForRust(routes) {
+        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.
+     */
+    getOriginalRoute(routeKey) {
+        return this.originalRoutes.get(routeKey);
+    }
+    /**
+     * Get all original routes that have socket handlers or dynamic functions.
+     */
+    getHandlerRoutes() {
+        return new Map(this.originalRoutes);
+    }
+    preprocessRoute(route, index) {
+        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 = {
+            ...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;
+    }
+    routeNeedsTsHandling(route) {
+        // 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;
+    }
+    cleanAction(action, routeKey, needsTsHandling) {
+        const cleanAction = { ...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.socketHandler;
+        }
+        // Clean targets - replace functions with static values
+        if (cleanAction.targets) {
+            cleanAction.targets = cleanAction.targets.map(t => this.cleanTarget(t));
+        }
+        return cleanAction;
+    }
+    cleanTarget(target) {
+        const clean = { ...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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+/**
+ * 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 declare class RustBinaryLocator {
+    private cachedPath;
+    /**
+     * Find the RustProxy binary path.
+     * Returns null if no binary is available.
+     */
+    findBinary(): Promise<string | null>;
+    /**
+     * Clear the cached binary path (e.g., after a failed launch).
+     */
+    clearCache(): void;
+    private searchBinary;
+    private findPlatformPackageBinary;
+    private isExecutable;
+    private findInPath;
+}

package/dist_ts/proxies/smart-proxy/rust-binary-locator.js

@@ -0,0 +1,104 @@
+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 {
+    constructor() {
+        this.cachedPath = null;
+    }
+    /**
+     * Find the RustProxy binary path.
+     * Returns null if no binary is available.
+     */
+    async findBinary() {
+        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).
+     */
+    clearCache() {
+        this.cachedPath = null;
+    }
+    async searchBinary() {
+        // 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;
+    }
+    async findPlatformPackageBinary() {
+        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;
+    }
+    async isExecutable(filePath) {
+        try {
+            await plugins.fs.promises.access(filePath, plugins.fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async findInPath(binaryName) {
+        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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,74 @@
+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 declare class RustMetricsAdapter implements IMetrics {
+    private bridge;
+    private cache;
+    private pollTimer;
+    private pollIntervalMs;
+    constructor(bridge: RustProxyBridge, pollIntervalMs?: number);
+    /**
+     * Poll Rust for metrics once. Can be awaited to ensure cache is fresh.
+     */
+    poll(): Promise<void>;
+    startPolling(): void;
+    stopPolling(): void;
+    connections: {
+        active: () => number;
+        total: () => number;
+        byRoute: () => Map<string, number>;
+        byIP: () => Map<string, number>;
+        topIPs: (_limit?: number) => Array<{
+            ip: string;
+            count: number;
+        }>;
+    };
+    throughput: {
+        instant: () => IThroughputData;
+        recent: () => IThroughputData;
+        average: () => IThroughputData;
+        custom: (_seconds: number) => IThroughputData;
+        history: (_seconds: number) => Array<IThroughputHistoryPoint>;
+        byRoute: (_windowSeconds?: number) => Map<string, IThroughputData>;
+        byIP: (_windowSeconds?: number) => Map<string, IThroughputData>;
+    };
+    requests: {
+        perSecond: () => number;
+        perMinute: () => number;
+        total: () => number;
+    };
+    totals: {
+        bytesIn: () => number;
+        bytesOut: () => number;
+        connections: () => number;
+    };
+    percentiles: {
+        connectionDuration: () => {
+            p50: number;
+            p95: number;
+            p99: number;
+        };
+        bytesTransferred: () => {
+            in: {
+                p50: number;
+                p95: number;
+                p99: number;
+            };
+            out: {
+                p50: number;
+                p95: number;
+                p99: number;
+            };
+        };
+    };
+}