feat(proxy-engine): add Rust-based outbound calling, WebRTC bridging, and voicemail handling

ts/sipproxy.ts

@@ -33,7 +33,11 @@ import {
   configureProxyEngine,
   onProxyEvent,
   hangupCall,
+  makeCall,
   shutdownProxyEngine,
+  webrtcOffer,
+  webrtcIce,
+  webrtcClose,
 } from './proxybridge.ts';
 import type {
   IIncomingCallEvent,
@@ -152,12 +156,25 @@ initWebRtcSignaling({ log });
 // ---------------------------------------------------------------------------
 
 function getStatus() {
+  // Merge SIP devices (from Rust) + browser devices (from TS WebSocket).
+  const devices = [...deviceStatuses.values()];
+  for (const bid of getAllBrowserDeviceIds()) {
+    devices.push({
+      id: bid,
+      displayName: 'Browser',
+      address: null,
+      port: 0,
+      connected: true,
+      isBrowser: true,
+    });
+  }
+
   return {
     instanceId,
     uptime: Math.floor((Date.now() - startTime) / 1000),
     lanIp: appConfig.proxy.lanIp,
     providers: [...providerStatuses.values()],
-    devices: [...deviceStatuses.values()],
+    devices,
     calls: [...activeCalls.values()].map((c) => ({
       ...c,
       duration: Math.floor((Date.now() - c.startedAt) / 1000),
@@ -243,6 +260,19 @@ async function startProxyEngine(): Promise<void> {
     });
   });
 
+  onProxyEvent('outbound_call_started', (data: any) => {
+    log(`[call] outbound started: ${data.call_id} → ${data.number} via ${data.provider_id}`);
+    activeCalls.set(data.call_id, {
+      id: data.call_id,
+      direction: 'outbound',
+      callerNumber: null,
+      calleeNumber: data.number,
+      providerUsed: data.provider_id,
+      state: 'setting-up',
+      startedAt: Date.now(),
+    });
+  });
+
   onProxyEvent('call_ringing', (data: { call_id: string }) => {
     const call = activeCalls.get(data.call_id);
     if (call) call.state = 'ringing';
@@ -278,6 +308,49 @@ async function startProxyEngine(): Promise<void> {
     log(`[sip] unhandled ${data.method_or_status} Call-ID=${data.call_id?.slice(0, 20)} from=${data.from_addr}:${data.from_port}`);
   });
 
+  // WebRTC events from Rust — forward ICE candidates to browser via WebSocket.
+  onProxyEvent('webrtc_ice_candidate', (data: any) => {
+    // Find the browser's WebSocket by session ID and send the ICE candidate.
+    broadcastWs('webrtc-ice', {
+      sessionId: data.session_id,
+      candidate: { candidate: data.candidate, sdpMid: data.sdp_mid, sdpMLineIndex: data.sdp_mline_index },
+    });
+  });
+
+  onProxyEvent('webrtc_state', (data: any) => {
+    log(`[webrtc] session=${data.session_id?.slice(0, 8)} state=${data.state}`);
+  });
+
+  onProxyEvent('webrtc_track', (data: any) => {
+    log(`[webrtc] session=${data.session_id?.slice(0, 8)} track=${data.kind} codec=${data.codec}`);
+  });
+
+  onProxyEvent('webrtc_audio_rx', (data: any) => {
+    if (data.packet_count === 1 || data.packet_count === 50) {
+      log(`[webrtc] session=${data.session_id?.slice(0, 8)} browser audio rx #${data.packet_count}`);
+    }
+  });
+
+  // Voicemail events.
+  onProxyEvent('voicemail_started', (data: any) => {
+    log(`[voicemail] started for call ${data.call_id} caller=${data.caller_number}`);
+  });
+
+  onProxyEvent('recording_done', (data: any) => {
+    log(`[voicemail] recording done: ${data.file_path} (${data.duration_ms}ms) caller=${data.caller_number}`);
+    // Save voicemail metadata via VoiceboxManager.
+    voiceboxManager.addMessage?.('default', {
+      callerNumber: data.caller_number || 'Unknown',
+      callerName: null,
+      fileName: data.file_path,
+      durationMs: data.duration_ms,
+    });
+  });
+
+  onProxyEvent('voicemail_error', (data: any) => {
+    log(`[voicemail] error: ${data.error} call=${data.call_id}`);
+  });
+
   // Send full config to Rust — this binds the SIP socket and starts registrations.
   const configured = await configureProxyEngine({
     proxy: appConfig.proxy,
@@ -330,12 +403,28 @@ async function startProxyEngine(): Promise<void> {
 initWebUi(
   getStatus,
   log,
-  (number, _deviceId, _providerId) => {
+  (number, deviceId, providerId) => {
     // Outbound calls from dashboard — send make_call command to Rust.
-    // For now, log only. Full implementation needs make_call in Rust.
-    log(`[dashboard] start call requested: ${number}`);
-    // TODO: send make_call command when implemented in Rust
-    return null;
+    log(`[dashboard] start call: ${number} device=${deviceId || 'any'} provider=${providerId || 'auto'}`);
+    // Fire-and-forget — the async result comes via events.
+    makeCall(number, deviceId, providerId).then((callId) => {
+      if (callId) {
+        log(`[dashboard] call started: ${callId}`);
+        activeCalls.set(callId, {
+          id: callId,
+          direction: 'outbound',
+          callerNumber: null,
+          calleeNumber: number,
+          providerUsed: providerId || null,
+          state: 'setting-up',
+          startedAt: Date.now(),
+        });
+      } else {
+        log(`[dashboard] call failed for ${number}`);
+      }
+    });
+    // Return a temporary ID so the frontend doesn't show "failed" immediately.
+    return { id: `pending-${Date.now()}` };
   },
   (callId) => {
     hangupCall(callId);
@@ -377,8 +466,23 @@ initWebUi(
       log(`[config] reload failed: ${e.message}`);
     }
   },
-  undefined, // callManager — WebRTC calls handled separately in Phase 2
+  undefined, // callManager — legacy, replaced by Rust proxy-engine
   voiceboxManager,
+  // WebRTC signaling → forwarded to Rust proxy-engine.
+  async (sessionId, sdp, ws) => {
+    log(`[webrtc] offer from browser session=${sessionId.slice(0, 8)}`);
+    const result = await webrtcOffer(sessionId, sdp);
+    if (result?.sdp) {
+      ws.send(JSON.stringify({ type: 'webrtc-answer', sessionId, sdp: result.sdp }));
+      log(`[webrtc] answer sent to browser session=${sessionId.slice(0, 8)}`);
+    }
+  },
+  async (sessionId, candidate) => {
+    await webrtcIce(sessionId, candidate);
+  },
+  async (sessionId) => {
+    await webrtcClose(sessionId);
+  },
 );
 
 // ---------------------------------------------------------------------------