feat(rust-proxy-engine): add a Rust SIP proxy engine with shared SIP and codec libraries

ts/proxybridge.ts

@@ -0,0 +1,196 @@
+/**
+ * Proxy engine bridge — manages the Rust proxy-engine subprocess.
+ *
+ * The proxy-engine handles ALL SIP protocol mechanics. TypeScript only:
+ * - Sends configuration
+ * - Receives high-level events (incoming_call, call_ended, etc.)
+ * - Sends high-level commands (hangup, make_call, play_audio)
+ *
+ * No raw SIP ever touches TypeScript.
+ */
+
+import path from 'node:path';
+import { RustBridge } from '@push.rocks/smartrust';
+
+// ---------------------------------------------------------------------------
+// Command type map for smartrust
+// ---------------------------------------------------------------------------
+
+type TProxyCommands = {
+  configure: {
+    params: Record<string, unknown>;
+    result: { bound: string };
+  };
+  hangup: {
+    params: { call_id: string };
+    result: Record<string, never>;
+  };
+  make_call: {
+    params: { number: string; device_id?: string; provider_id?: string };
+    result: { call_id: string };
+  };
+  play_audio: {
+    params: { call_id: string; leg_id?: string; file_path: string; codec?: number };
+    result: Record<string, never>;
+  };
+  start_recording: {
+    params: { call_id: string; file_path: string; max_duration_ms?: number };
+    result: Record<string, never>;
+  };
+  stop_recording: {
+    params: { call_id: string };
+    result: { file_path: string; duration_ms: number };
+  };
+};
+
+// ---------------------------------------------------------------------------
+// Event types from Rust
+// ---------------------------------------------------------------------------
+
+export interface IIncomingCallEvent {
+  call_id: string;
+  from_uri: string;
+  to_number: string;
+  provider_id: string;
+}
+
+export interface IOutboundCallEvent {
+  call_id: string;
+  from_device: string | null;
+  to_number: string;
+}
+
+export interface ICallEndedEvent {
+  call_id: string;
+  reason: string;
+  duration: number;
+  from_side?: string;
+}
+
+export interface IProviderRegisteredEvent {
+  provider_id: string;
+  registered: boolean;
+  public_ip: string | null;
+}
+
+export interface IDeviceRegisteredEvent {
+  device_id: string;
+  display_name: string;
+  address: string;
+  port: number;
+  aor: string;
+  expires: number;
+}
+
+// ---------------------------------------------------------------------------
+// Bridge singleton
+// ---------------------------------------------------------------------------
+
+let bridge: RustBridge<TProxyCommands> | null = null;
+let initialized = false;
+let logFn: ((msg: string) => void) | undefined;
+
+function buildLocalPaths(): string[] {
+  const root = process.cwd();
+  return [
+    path.join(root, 'dist_rust', 'proxy-engine'),
+    path.join(root, 'rust', 'target', 'release', 'proxy-engine'),
+    path.join(root, 'rust', 'target', 'debug', 'proxy-engine'),
+  ];
+}
+
+/**
+ * Initialize the proxy engine — spawn the Rust binary.
+ * Call configure() separately to push config and start SIP.
+ */
+export async function initProxyEngine(log?: (msg: string) => void): Promise<boolean> {
+  if (initialized && bridge) return true;
+  logFn = log;
+
+  try {
+    bridge = new RustBridge<TProxyCommands>({
+      binaryName: 'proxy-engine',
+      localPaths: buildLocalPaths(),
+    });
+
+    const spawned = await bridge.spawn();
+    if (!spawned) {
+      log?.('[proxy-engine] failed to spawn binary');
+      bridge = null;
+      return false;
+    }
+
+    bridge.on('exit', () => {
+      logFn?.('[proxy-engine] process exited — will need re-init');
+      bridge = null;
+      initialized = false;
+    });
+
+    // Forward stderr for debugging.
+    bridge.on('stderr', (line: string) => {
+      logFn?.(`[proxy-engine:stderr] ${line}`);
+    });
+
+    initialized = true;
+    log?.('[proxy-engine] spawned and ready');
+    return true;
+  } catch (e: any) {
+    log?.(`[proxy-engine] init error: ${e.message}`);
+    bridge = null;
+    return false;
+  }
+}
+
+/**
+ * Send the full app config to the proxy engine.
+ * This binds the SIP socket, starts provider registrations, etc.
+ */
+export async function configureProxyEngine(config: Record<string, unknown>): Promise<boolean> {
+  if (!bridge || !initialized) return false;
+  try {
+    const result = await bridge.sendCommand('configure', config as any);
+    logFn?.(`[proxy-engine] configured, SIP bound on ${(result as any)?.bound || '?'}`);
+    return true;
+  } catch (e: any) {
+    logFn?.(`[proxy-engine] configure error: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Send a hangup command.
+ */
+export async function hangupCall(callId: string): Promise<boolean> {
+  if (!bridge || !initialized) return false;
+  try {
+    await bridge.sendCommand('hangup', { call_id: callId } as any);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Subscribe to an event from the proxy engine.
+ * Event names: incoming_call, outbound_device_call, call_ringing,
+ * call_answered, call_ended, provider_registered, device_registered,
+ * dtmf_digit, recording_done, sip_unhandled
+ */
+export function onProxyEvent(event: string, handler: (data: any) => void): void {
+  if (!bridge) throw new Error('proxy engine not initialized');
+  bridge.on(`management:${event}`, handler);
+}
+
+/** Check if the proxy engine is ready. */
+export function isProxyReady(): boolean {
+  return initialized && bridge !== null;
+}
+
+/** Shut down the proxy engine. */
+export function shutdownProxyEngine(): void {
+  if (bridge) {
+    try { bridge.kill(); } catch { /* ignore */ }
+    bridge = null;
+    initialized = false;
+  }
+}