@push.rocks/smartproxy 21.1.7 → 22.6.0

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

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

@@ -0,0 +1,310 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../core/utils/logger.js';
+import { RustBinaryLocator } from './rust-binary-locator.js';
+import type { IRouteConfig } from './models/route-types.js';
+import { ChildProcess, spawn } from 'child_process';
+import { createInterface, Interface as ReadlineInterface } from 'readline';
+
+/**
+ * Management request sent to the Rust binary via stdin.
+ */
+interface IManagementRequest {
+  id: string;
+  method: string;
+  params: Record<string, any>;
+}
+
+/**
+ * Management response received from the Rust binary via stdout.
+ */
+interface IManagementResponse {
+  id: string;
+  success: boolean;
+  result?: any;
+  error?: string;
+}
+
+/**
+ * Management event received from the Rust binary (unsolicited).
+ */
+interface IManagementEvent {
+  event: string;
+  data: any;
+}
+
+/**
+ * Bridge between TypeScript SmartProxy and the Rust binary.
+ * Communicates via JSON-over-stdin/stdout IPC protocol.
+ */
+export class RustProxyBridge extends plugins.EventEmitter {
+  private locator = new RustBinaryLocator();
+  private process: ChildProcess | null = null;
+  private readline: ReadlineInterface | null = null;
+  private pendingRequests = new Map<string, {
+    resolve: (value: any) => void;
+    reject: (error: Error) => void;
+    timer: NodeJS.Timeout;
+  }>();
+  private requestCounter = 0;
+  private isRunning = false;
+  private binaryPath: string | null = null;
+  private readonly requestTimeoutMs = 30000;
+
+  /**
+   * Spawn the Rust binary in management mode.
+   * Returns true if the binary was found and spawned successfully.
+   */
+  public async spawn(): Promise<boolean> {
+    this.binaryPath = await this.locator.findBinary();
+    if (!this.binaryPath) {
+      return false;
+    }
+
+    return new Promise<boolean>((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: Buffer) => {
+          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: string) => {
+          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: any) {
+        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.
+   */
+  public async sendCommand(method: string, params: Record<string, any> = {}): Promise<any> {
+    if (!this.process || !this.isRunning) {
+      throw new Error('RustProxy bridge is not running');
+    }
+
+    const id = `req_${++this.requestCounter}`;
+    const request: IManagementRequest = { id, method, params };
+
+    return new Promise<any>((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
+
+  public async startProxy(config: any): Promise<void> {
+    await this.sendCommand('start', { config });
+  }
+
+  public async stopProxy(): Promise<void> {
+    await this.sendCommand('stop');
+  }
+
+  public async updateRoutes(routes: IRouteConfig[]): Promise<void> {
+    await this.sendCommand('updateRoutes', { routes });
+  }
+
+  public async getMetrics(): Promise<any> {
+    return this.sendCommand('getMetrics');
+  }
+
+  public async getStatistics(): Promise<any> {
+    return this.sendCommand('getStatistics');
+  }
+
+  public async provisionCertificate(routeName: string): Promise<void> {
+    await this.sendCommand('provisionCertificate', { routeName });
+  }
+
+  public async renewCertificate(routeName: string): Promise<void> {
+    await this.sendCommand('renewCertificate', { routeName });
+  }
+
+  public async getCertificateStatus(routeName: string): Promise<any> {
+    return this.sendCommand('getCertificateStatus', { routeName });
+  }
+
+  public async getListeningPorts(): Promise<number[]> {
+    const result = await this.sendCommand('getListeningPorts');
+    return result?.ports ?? [];
+  }
+
+  public async getNftablesStatus(): Promise<any> {
+    return this.sendCommand('getNftablesStatus');
+  }
+
+  public async setSocketHandlerRelay(socketPath: string): Promise<void> {
+    await this.sendCommand('setSocketHandlerRelay', { socketPath });
+  }
+
+  public async addListeningPort(port: number): Promise<void> {
+    await this.sendCommand('addListeningPort', { port });
+  }
+
+  public async removeListeningPort(port: number): Promise<void> {
+    await this.sendCommand('removeListeningPort', { port });
+  }
+
+  public async loadCertificate(domain: string, cert: string, key: string, ca?: string): Promise<void> {
+    await this.sendCommand('loadCertificate', { domain, cert, key, ca });
+  }
+
+  /**
+   * Kill the Rust process and clean up all stdio streams.
+   */
+  public kill(): void {
+    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.
+   */
+  public get running(): boolean {
+    return this.isRunning;
+  }
+
+  private handleLine(line: string): void {
+    if (!line) return;
+
+    let parsed: any;
+    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 as IManagementEvent;
+      this.emit(`management:${event.event}`, event.data);
+      return;
+    }
+
+    // Otherwise it's a response (has 'id' field)
+    if ('id' in parsed) {
+      const response = parsed as IManagementResponse;
+      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'));
+        }
+      }
+    }
+  }
+
+  private cleanup(): void {
+    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();
+  }
+}