initial

ts/smartvpn.classes.vpnbridge.ts

@@ -0,0 +1,152 @@
+import * as plugins from './smartvpn.plugins.js';
+import * as paths from './smartvpn.paths.js';
+import type {
+  TVpnTransportOptions,
+  IVpnTransportSocket,
+} from './smartvpn.interfaces.js';
+import type { TCommandMap } from '@push.rocks/smartrust';
+
+/**
+ * Get the package root directory.
+ */
+function getPackageRoot(): string {
+  const thisDir = plugins.path.dirname(plugins.url.fileURLToPath(import.meta.url));
+  return plugins.path.resolve(thisDir, '..');
+}
+
+/**
+ * Map Node.js platform/arch to tsrust's platform suffix.
+ */
+function getTsrustPlatformSuffix(): string | null {
+  const archMap: Record<string, string> = { x64: 'amd64', arm64: 'arm64' };
+  const osMap: Record<string, string> = { linux: 'linux', darwin: 'macos' };
+  const os = osMap[process.platform];
+  const arch = archMap[process.arch];
+  if (os && arch) {
+    return `${os}_${arch}`;
+  }
+  return null;
+}
+
+/**
+ * Build local search paths for the smartvpn daemon binary.
+ */
+function buildLocalPaths(binaryName: string): string[] {
+  const packageRoot = getPackageRoot();
+  const suffix = getTsrustPlatformSuffix();
+  const paths: string[] = [];
+
+  // dist_rust/ (tsrust cross-compiled output)
+  if (suffix) {
+    paths.push(plugins.path.join(packageRoot, 'dist_rust', `${binaryName}_${suffix}`));
+  }
+  paths.push(plugins.path.join(packageRoot, 'dist_rust', binaryName));
+
+  // Local dev build paths
+  paths.push(plugins.path.resolve(process.cwd(), 'rust', 'target', 'release', binaryName));
+  paths.push(plugins.path.resolve(process.cwd(), 'rust', 'target', 'debug', binaryName));
+
+  return paths;
+}
+
+/**
+ * Shared bridge wrapper around smartrust RustBridge.
+ * Supports stdio mode (dev: spawn child process) and socket mode (production: connect to running daemon).
+ */
+export class VpnBridge<TCommands extends TCommandMap> extends plugins.events.EventEmitter {
+  private bridge: plugins.smartrust.RustBridge<TCommands>;
+  private transportOptions: TVpnTransportOptions;
+  private mode: 'client' | 'server';
+
+  constructor(options: {
+    transport: TVpnTransportOptions;
+    mode: 'client' | 'server';
+    binaryName?: string;
+  }) {
+    super();
+
+    const binaryName = options.binaryName || 'smartvpn_daemon';
+    this.transportOptions = options.transport;
+    this.mode = options.mode;
+
+    this.bridge = new plugins.smartrust.RustBridge<TCommands>({
+      binaryName,
+      envVarName: 'SMARTVPN_RUST_BINARY',
+      platformPackagePrefix: '@push.rocks/smartvpn',
+      localPaths: buildLocalPaths(binaryName),
+      cliArgs: ['--management', '--mode', this.mode],
+      maxPayloadSize: 10 * 1024 * 1024, // 10 MB
+    });
+
+    // Forward events from inner bridge
+    this.bridge.on('exit', (code: number | null, signal: string | null) => {
+      this.emit('exit', code, signal);
+    });
+    this.bridge.on('reconnected', () => {
+      this.emit('reconnected');
+    });
+
+    // Forward management events from the daemon
+    // smartrust emits 'management:<eventName>' for unsolicited events
+    this.bridge.on('management:status', (data: any) => {
+      this.emit('status', data);
+    });
+    this.bridge.on('management:error', (data: any) => {
+      this.emit('error', data);
+    });
+    this.bridge.on('management:client-connected', (data: any) => {
+      this.emit('client-connected', data);
+    });
+    this.bridge.on('management:client-disconnected', (data: any) => {
+      this.emit('client-disconnected', data);
+    });
+    this.bridge.on('management:started', (data: any) => {
+      this.emit('started', data);
+    });
+    this.bridge.on('management:stopped', (data: any) => {
+      this.emit('stopped', data);
+    });
+  }
+
+  /**
+   * Start the bridge: spawn in stdio mode or connect in socket mode.
+   */
+  public async start(): Promise<boolean> {
+    if (this.transportOptions.transport === 'socket') {
+      const socketOpts = this.transportOptions as IVpnTransportSocket;
+      return this.bridge.connect(socketOpts.socketPath, {
+        autoReconnect: socketOpts.autoReconnect,
+        reconnectBaseDelayMs: socketOpts.reconnectBaseDelayMs,
+        reconnectMaxDelayMs: socketOpts.reconnectMaxDelayMs,
+        maxReconnectAttempts: socketOpts.maxReconnectAttempts,
+      });
+    } else {
+      return this.bridge.spawn();
+    }
+  }
+
+  /**
+   * Stop the bridge. In socket mode, closes the socket (daemon stays alive).
+   * In stdio mode, kills the child process.
+   */
+  public stop(): void {
+    this.bridge.kill();
+  }
+
+  /**
+   * Send a typed command to the daemon.
+   */
+  public async sendCommand<K extends string & keyof TCommands>(
+    method: K,
+    params: TCommands[K]['params'],
+  ): Promise<TCommands[K]['result']> {
+    return this.bridge.sendCommand(method, params);
+  }
+
+  /**
+   * Whether the bridge is currently running/connected.
+   */
+  public get running(): boolean {
+    return this.bridge.running;
+  }
+}