@push.rocks/smartproxy 21.1.7 → 22.6.0

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;
+            };
+        };
+    };
+}

package/dist_ts/proxies/smart-proxy/rust-metrics-adapter.js

@@ -0,0 +1,146 @@
+/**
+ * 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 {
+    constructor(bridge, pollIntervalMs = 1000) {
+        this.cache = null;
+        this.pollTimer = null;
+        // --- IMetrics implementation ---
+        this.connections = {
+            active: () => {
+                return this.cache?.activeConnections ?? 0;
+            },
+            total: () => {
+                return this.cache?.totalConnections ?? 0;
+            },
+            byRoute: () => {
+                const result = new Map();
+                if (this.cache?.routes) {
+                    for (const [name, rm] of Object.entries(this.cache.routes)) {
+                        result.set(name, rm.activeConnections ?? 0);
+                    }
+                }
+                return result;
+            },
+            byIP: () => {
+                // Per-IP tracking not yet available from Rust
+                return new Map();
+            },
+            topIPs: (_limit) => {
+                // Per-IP tracking not yet available from Rust
+                return [];
+            },
+        };
+        this.throughput = {
+            instant: () => {
+                return {
+                    in: this.cache?.throughputInBytesPerSec ?? 0,
+                    out: this.cache?.throughputOutBytesPerSec ?? 0,
+                };
+            },
+            recent: () => {
+                return this.throughput.instant();
+            },
+            average: () => {
+                return this.throughput.instant();
+            },
+            custom: (_seconds) => {
+                return this.throughput.instant();
+            },
+            history: (_seconds) => {
+                // Throughput history not yet available from Rust
+                return [];
+            },
+            byRoute: (_windowSeconds) => {
+                const result = new Map();
+                if (this.cache?.routes) {
+                    for (const [name, rm] of Object.entries(this.cache.routes)) {
+                        result.set(name, {
+                            in: rm.throughputInBytesPerSec ?? 0,
+                            out: rm.throughputOutBytesPerSec ?? 0,
+                        });
+                    }
+                }
+                return result;
+            },
+            byIP: (_windowSeconds) => {
+                return new Map();
+            },
+        };
+        this.requests = {
+            perSecond: () => {
+                // Rust tracks connections, not HTTP requests (TCP-level proxy)
+                return 0;
+            },
+            perMinute: () => {
+                return 0;
+            },
+            total: () => {
+                // Use total connections as a proxy for total requests
+                return this.cache?.totalConnections ?? 0;
+            },
+        };
+        this.totals = {
+            bytesIn: () => {
+                return this.cache?.bytesIn ?? 0;
+            },
+            bytesOut: () => {
+                return this.cache?.bytesOut ?? 0;
+            },
+            connections: () => {
+                return this.cache?.totalConnections ?? 0;
+            },
+        };
+        this.percentiles = {
+            connectionDuration: () => {
+                return { p50: 0, p95: 0, p99: 0 };
+            },
+            bytesTransferred: () => {
+                return {
+                    in: { p50: 0, p95: 0, p99: 0 },
+                    out: { p50: 0, p95: 0, p99: 0 },
+                };
+            },
+        };
+        this.bridge = bridge;
+        this.pollIntervalMs = pollIntervalMs;
+    }
+    /**
+     * Poll Rust for metrics once. Can be awaited to ensure cache is fresh.
+     */
+    async poll() {
+        try {
+            this.cache = await this.bridge.getMetrics();
+        }
+        catch {
+            // Ignore poll errors (bridge may be shutting down)
+        }
+    }
+    startPolling() {
+        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();
+        }
+    }
+    stopPolling() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVzdC1tZXRyaWNzLWFkYXB0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3J1c3QtbWV0cmljcy1hZGFwdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLE9BQU8sa0JBQWtCO0lBTTdCLFlBQVksTUFBdUIsRUFBRSxjQUFjLEdBQUcsSUFBSTtRQUpsRCxVQUFLLEdBQVEsSUFBSSxDQUFDO1FBQ2xCLGNBQVMsR0FBMEMsSUFBSSxDQUFDO1FBc0NoRSxrQ0FBa0M7UUFFM0IsZ0JBQVcsR0FBRztZQUNuQixNQUFNLEVBQUUsR0FBVyxFQUFFO2dCQUNuQixPQUFPLElBQUksQ0FBQyxLQUFLLEVBQUUsaUJBQWlCLElBQUksQ0FBQyxDQUFDO1lBQzVDLENBQUM7WUFDRCxLQUFLLEVBQUUsR0FBVyxFQUFFO2dCQUNsQixPQUFPLElBQUksQ0FBQyxLQUFLLEVBQUUsZ0JBQWdCLElBQUksQ0FBQyxDQUFDO1lBQzNDLENBQUM7WUFDRCxPQUFPLEVBQUUsR0FBd0IsRUFBRTtnQkFDakMsTUFBTSxNQUFNLEdBQUcsSUFBSSxHQUFHLEVBQWtCLENBQUM7Z0JBQ3pDLElBQUksSUFBSSxDQUFDLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBQztvQkFDdkIsS0FBSyxNQUFNLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO3dCQUMzRCxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksRUFBRyxFQUFVLENBQUMsaUJBQWlCLElBQUksQ0FBQyxDQUFDLENBQUM7b0JBQ3ZELENBQUM7Z0JBQ0gsQ0FBQztnQkFDRCxPQUFPLE1BQU0sQ0FBQztZQUNoQixDQUFDO1lBQ0QsSUFBSSxFQUFFLEdBQXdCLEVBQUU7Z0JBQzlCLDhDQUE4QztnQkFDOUMsT0FBTyxJQUFJLEdBQUcsRUFBRSxDQUFDO1lBQ25CLENBQUM7WUFDRCxNQUFNLEVBQUUsQ0FBQyxNQUFlLEVBQXdDLEVBQUU7Z0JBQ2hFLDhDQUE4QztnQkFDOUMsT0FBTyxFQUFFLENBQUM7WUFDWixDQUFDO1NBQ0YsQ0FBQztRQUVLLGVBQVUsR0FBRztZQUNsQixPQUFPLEVBQUUsR0FBb0IsRUFBRTtnQkFDN0IsT0FBTztvQkFDTCxFQUFFLEVBQUUsSUFBSSxDQUFDLEtBQUssRUFBRSx1QkFBdUIsSUFBSSxDQUFDO29CQUM1QyxHQUFHLEVBQUUsSUFBSSxDQUFDLEtBQUssRUFBRSx3QkFBd0IsSUFBSSxDQUFDO2lCQUMvQyxDQUFDO1lBQ0osQ0FBQztZQUNELE1BQU0sRUFBRSxHQUFvQixFQUFFO2dCQUM1QixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDbkMsQ0FBQztZQUNELE9BQU8sRUFBRSxHQUFvQixFQUFFO2dCQUM3QixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDbkMsQ0FBQztZQUNELE1BQU0sRUFBRSxDQUFDLFFBQWdCLEVBQW1CLEVBQUU7Z0JBQzVDLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNuQyxDQUFDO1lBQ0QsT0FBTyxFQUFFLENBQUMsUUFBZ0IsRUFBa0MsRUFBRTtnQkFDNUQsaURBQWlEO2dCQUNqRCxPQUFPLEVBQUUsQ0FBQztZQUNaLENBQUM7WUFDRCxPQUFPLEVBQUUsQ0FBQyxjQUF1QixFQUFnQyxFQUFFO2dCQUNqRSxNQUFNLE1BQU0sR0FBRyxJQUFJLEdBQUcsRUFBMkIsQ0FBQztnQkFDbEQsSUFBSSxJQUFJLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxDQUFDO29CQUN2QixLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7d0JBQzNELE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFOzRCQUNmLEVBQUUsRUFBRyxFQUFVLENBQUMsdUJBQXVCLElBQUksQ0FBQzs0QkFDNUMsR0FBRyxFQUFHLEVBQVUsQ0FBQyx3QkFBd0IsSUFBSSxDQUFDO3lCQUMvQyxDQUFDLENBQUM7b0JBQ0wsQ0FBQztnQkFDSCxDQUFDO2dCQUNELE9BQU8sTUFBTSxDQUFDO1lBQ2hCLENBQUM7WUFDRCxJQUFJLEVBQUUsQ0FBQyxjQUF1QixFQUFnQyxFQUFFO2dCQUM5RCxPQUFPLElBQUksR0FBRyxFQUFFLENBQUM7WUFDbkIsQ0FBQztTQUNGLENBQUM7UUFFSyxhQUFRLEdBQUc7WUFDaEIsU0FBUyxFQUFFLEdBQVcsRUFBRTtnQkFDdEIsK0RBQStEO2dCQUMvRCxPQUFPLENBQUMsQ0FBQztZQUNYLENBQUM7WUFDRCxTQUFTLEVBQUUsR0FBVyxFQUFFO2dCQUN0QixPQUFPLENBQUMsQ0FBQztZQUNYLENBQUM7WUFDRCxLQUFLLEVBQUUsR0FBVyxFQUFFO2dCQUNsQixzREFBc0Q7Z0JBQ3RELE9BQU8sSUFBSSxDQUFDLEtBQUssRUFBRSxnQkFBZ0IsSUFBSSxDQUFDLENBQUM7WUFDM0MsQ0FBQztTQUNGLENBQUM7UUFFSyxXQUFNLEdBQUc7WUFDZCxPQUFPLEVBQUUsR0FBVyxFQUFFO2dCQUNwQixPQUFPLElBQUksQ0FBQyxLQUFLLEVBQUUsT0FBTyxJQUFJLENBQUMsQ0FBQztZQUNsQyxDQUFDO1lBQ0QsUUFBUSxFQUFFLEdBQVcsRUFBRTtnQkFDckIsT0FBTyxJQUFJLENBQUMsS0FBSyxFQUFFLFFBQVEsSUFBSSxDQUFDLENBQUM7WUFDbkMsQ0FBQztZQUNELFdBQVcsRUFBRSxHQUFXLEVBQUU7Z0JBQ3hCLE9BQU8sSUFBSSxDQUFDLEtBQUssRUFBRSxnQkFBZ0IsSUFBSSxDQUFDLENBQUM7WUFDM0MsQ0FBQztTQUNGLENBQUM7UUFFSyxnQkFBVyxHQUFHO1lBQ25CLGtCQUFrQixFQUFFLEdBQThDLEVBQUU7Z0JBQ2xFLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxFQUFFLEdBQUcsRUFBRSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsRUFBRSxDQUFDO1lBQ3BDLENBQUM7WUFDRCxnQkFBZ0IsRUFBRSxHQUdoQixFQUFFO2dCQUNGLE9BQU87b0JBQ0wsRUFBRSxFQUFFLEVBQUUsR0FBRyxFQUFFLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQyxFQUFFLEdBQUcsRUFBRSxDQUFDLEVBQUU7b0JBQzlCLEdBQUcsRUFBRSxFQUFFLEdBQUcsRUFBRSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQyxFQUFFO2lCQUNoQyxDQUFDO1lBQ0osQ0FBQztTQUNGLENBQUM7UUExSUEsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7UUFDckIsSUFBSSxDQUFDLGNBQWMsR0FBRyxjQUFjLENBQUM7SUFDdkMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLElBQUk7UUFDZixJQUFJLENBQUM7WUFDSCxJQUFJLENBQUMsS0FBSyxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUM5QyxDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQ1AsbURBQW1EO1FBQ3JELENBQUM7SUFDSCxDQUFDO0lBRU0sWUFBWTtRQUNqQixJQUFJLElBQUksQ0FBQyxTQUFTO1lBQUUsT0FBTztRQUMzQixrREFBa0Q7UUFDbEQsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ1osSUFBSSxDQUFDLFNBQVMsR0FBRyxXQUFXLENBQUMsR0FBRyxFQUFFO1lBQ2hDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNkLENBQUMsRUFBRSxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDeEIsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ3pCLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDekIsQ0FBQztJQUNILENBQUM7SUFFTSxXQUFXO1FBQ2hCLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ25CLGFBQWEsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDOUIsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7UUFDeEIsQ0FBQztJQUNILENBQUM7Q0EyR0YifQ==

package/dist_ts/proxies/smart-proxy/rust-proxy-bridge.d.ts

@@ -0,0 +1,49 @@
+import * as plugins from '../../plugins.js';
+import type { IRouteConfig } from './models/route-types.js';
+/**
+ * Bridge between TypeScript SmartProxy and the Rust binary.
+ * Communicates via JSON-over-stdin/stdout IPC protocol.
+ */
+export declare class RustProxyBridge extends plugins.EventEmitter {
+    private locator;
+    private process;
+    private readline;
+    private pendingRequests;
+    private requestCounter;
+    private isRunning;
+    private binaryPath;
+    private readonly requestTimeoutMs;
+    /**
+     * Spawn the Rust binary in management mode.
+     * Returns true if the binary was found and spawned successfully.
+     */
+    spawn(): Promise<boolean>;
+    /**
+     * Send a management command to the Rust process and wait for the response.
+     */
+    sendCommand(method: string, params?: Record<string, any>): Promise<any>;
+    startProxy(config: any): Promise<void>;
+    stopProxy(): Promise<void>;
+    updateRoutes(routes: IRouteConfig[]): Promise<void>;
+    getMetrics(): Promise<any>;
+    getStatistics(): Promise<any>;
+    provisionCertificate(routeName: string): Promise<void>;
+    renewCertificate(routeName: string): Promise<void>;
+    getCertificateStatus(routeName: string): Promise<any>;
+    getListeningPorts(): Promise<number[]>;
+    getNftablesStatus(): Promise<any>;
+    setSocketHandlerRelay(socketPath: string): Promise<void>;
+    addListeningPort(port: number): Promise<void>;
+    removeListeningPort(port: number): Promise<void>;
+    loadCertificate(domain: string, cert: string, key: string, ca?: string): Promise<void>;
+    /**
+     * Kill the Rust process and clean up all stdio streams.
+     */
+    kill(): void;
+    /**
+     * Whether the bridge is currently running.
+     */
+    get running(): boolean;
+    private handleLine;
+    private cleanup;
+}

package/dist_ts/proxies/smart-proxy/rust-proxy-bridge.js

@@ -0,0 +1,259 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../core/utils/logger.js';
+import { RustBinaryLocator } from './rust-binary-locator.js';
+import { ChildProcess, spawn } from 'child_process';
+import { createInterface, Interface as ReadlineInterface } from 'readline';
+/**
+ * Bridge between TypeScript SmartProxy and the Rust binary.
+ * Communicates via JSON-over-stdin/stdout IPC protocol.
+ */
+export class RustProxyBridge extends plugins.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.locator = new RustBinaryLocator();
+        this.process = null;
+        this.readline = null;
+        this.pendingRequests = new Map();
+        this.requestCounter = 0;
+        this.isRunning = false;
+        this.binaryPath = null;
+        this.requestTimeoutMs = 30000;
+    }
+    /**
+     * Spawn the Rust binary in management mode.
+     * Returns true if the binary was found and spawned successfully.
+     */
+    async spawn() {
+        this.binaryPath = await this.locator.findBinary();
+        if (!this.binaryPath) {
+            return false;
+        }
+        return new Promise((resolve) => {
+            try {
+                this.process = spawn(this.binaryPath, ['--management'], {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    env: { ...process.env },
+                });
+                // Handle stderr (logging from Rust goes here)
+                const stderrHandler = (data) => {
+                    const lines = data.toString().split('\n').filter(l => l.trim());
+                    for (const line of lines) {
+                        logger.log('debug', `[rustproxy] ${line}`, { component: 'rust-bridge' });
+                    }
+                };
+                this.process.stderr?.on('data', stderrHandler);
+                // Handle stdout (JSON IPC)
+                this.readline = createInterface({ input: this.process.stdout });
+                this.readline.on('line', (line) => {
+                    this.handleLine(line.trim());
+                });
+                // Handle process exit
+                this.process.on('exit', (code, signal) => {
+                    logger.log('info', `RustProxy process exited (code=${code}, signal=${signal})`, { component: 'rust-bridge' });
+                    this.cleanup();
+                    this.emit('exit', code, signal);
+                });
+                this.process.on('error', (err) => {
+                    logger.log('error', `RustProxy process error: ${err.message}`, { component: 'rust-bridge' });
+                    this.cleanup();
+                    resolve(false);
+                });
+                // Wait for the 'ready' event from Rust
+                const readyTimeout = setTimeout(() => {
+                    logger.log('error', 'RustProxy did not send ready event within 10s', { component: 'rust-bridge' });
+                    this.kill();
+                    resolve(false);
+                }, 10000);
+                this.once('management:ready', () => {
+                    clearTimeout(readyTimeout);
+                    this.isRunning = true;
+                    logger.log('info', 'RustProxy bridge connected', { component: 'rust-bridge' });
+                    resolve(true);
+                });
+            }
+            catch (err) {
+                logger.log('error', `Failed to spawn RustProxy: ${err.message}`, { component: 'rust-bridge' });
+                resolve(false);
+            }
+        });
+    }
+    /**
+     * Send a management command to the Rust process and wait for the response.
+     */
+    async sendCommand(method, params = {}) {
+        if (!this.process || !this.isRunning) {
+            throw new Error('RustProxy bridge is not running');
+        }
+        const id = `req_${++this.requestCounter}`;
+        const request = { id, method, params };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`RustProxy command '${method}' timed out after ${this.requestTimeoutMs}ms`));
+            }, this.requestTimeoutMs);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            const json = JSON.stringify(request) + '\n';
+            this.process.stdin.write(json, (err) => {
+                if (err) {
+                    clearTimeout(timer);
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`Failed to write to RustProxy stdin: ${err.message}`));
+                }
+            });
+        });
+    }
+    // Convenience methods for each management command
+    async startProxy(config) {
+        await this.sendCommand('start', { config });
+    }
+    async stopProxy() {
+        await this.sendCommand('stop');
+    }
+    async updateRoutes(routes) {
+        await this.sendCommand('updateRoutes', { routes });
+    }
+    async getMetrics() {
+        return this.sendCommand('getMetrics');
+    }
+    async getStatistics() {
+        return this.sendCommand('getStatistics');
+    }
+    async provisionCertificate(routeName) {
+        await this.sendCommand('provisionCertificate', { routeName });
+    }
+    async renewCertificate(routeName) {
+        await this.sendCommand('renewCertificate', { routeName });
+    }
+    async getCertificateStatus(routeName) {
+        return this.sendCommand('getCertificateStatus', { routeName });
+    }
+    async getListeningPorts() {
+        const result = await this.sendCommand('getListeningPorts');
+        return result?.ports ?? [];
+    }
+    async getNftablesStatus() {
+        return this.sendCommand('getNftablesStatus');
+    }
+    async setSocketHandlerRelay(socketPath) {
+        await this.sendCommand('setSocketHandlerRelay', { socketPath });
+    }
+    async addListeningPort(port) {
+        await this.sendCommand('addListeningPort', { port });
+    }
+    async removeListeningPort(port) {
+        await this.sendCommand('removeListeningPort', { port });
+    }
+    async loadCertificate(domain, cert, key, ca) {
+        await this.sendCommand('loadCertificate', { domain, cert, key, ca });
+    }
+    /**
+     * Kill the Rust process and clean up all stdio streams.
+     */
+    kill() {
+        if (this.process) {
+            const proc = this.process;
+            this.process = null;
+            this.isRunning = false;
+            // Close readline (reads from stdout)
+            if (this.readline) {
+                this.readline.close();
+                this.readline = null;
+            }
+            // Reject pending requests
+            for (const [, pending] of this.pendingRequests) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error('RustProxy process killed'));
+            }
+            this.pendingRequests.clear();
+            // Remove all listeners so nothing keeps references
+            proc.removeAllListeners();
+            proc.stdout?.removeAllListeners();
+            proc.stderr?.removeAllListeners();
+            proc.stdin?.removeAllListeners();
+            // Kill the process
+            try {
+                proc.kill('SIGTERM');
+            }
+            catch { /* already dead */ }
+            // Destroy all stdio pipes to free handles
+            try {
+                proc.stdin?.destroy();
+            }
+            catch { /* ignore */ }
+            try {
+                proc.stdout?.destroy();
+            }
+            catch { /* ignore */ }
+            try {
+                proc.stderr?.destroy();
+            }
+            catch { /* ignore */ }
+            // Unref process so Node doesn't wait for it
+            try {
+                proc.unref();
+            }
+            catch { /* ignore */ }
+            // Force kill after 5 seconds
+            setTimeout(() => {
+                try {
+                    proc.kill('SIGKILL');
+                }
+                catch { /* already dead */ }
+            }, 5000).unref();
+        }
+    }
+    /**
+     * Whether the bridge is currently running.
+     */
+    get running() {
+        return this.isRunning;
+    }
+    handleLine(line) {
+        if (!line)
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            logger.log('warn', `Non-JSON output from RustProxy: ${line}`, { component: 'rust-bridge' });
+            return;
+        }
+        // Check if it's an event (has 'event' field)
+        if ('event' in parsed) {
+            const event = parsed;
+            this.emit(`management:${event.event}`, event.data);
+            return;
+        }
+        // Otherwise it's a response (has 'id' field)
+        if ('id' in parsed) {
+            const response = parsed;
+            const pending = this.pendingRequests.get(response.id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(response.id);
+                if (response.success) {
+                    pending.resolve(response.result);
+                }
+                else {
+                    pending.reject(new Error(response.error || 'Unknown error from RustProxy'));
+                }
+            }
+        }
+    }
+    cleanup() {
+        this.isRunning = false;
+        this.process = null;
+        if (this.readline) {
+            this.readline.close();
+            this.readline = null;
+        }
+        // Reject all pending requests
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('RustProxy process exited'));
+        }
+        this.pendingRequests.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-proxy-bridge.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/rust-proxy-bridge.ts"],"names":[],"mappings":"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"}