feat(proxy-engine,webrtc): add B2BUA SIP leg handling and WebRTC call bridging for outbound calls

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: 'siprouter',
-  version: '1.12.0',
+  version: '1.13.0',
   description: 'undefined'
 }

ts/frontend.ts

@@ -339,11 +339,13 @@ export function initWebUi(
   onHangupCall: (callId: string) => boolean,
   onConfigSaved?: () => void,
   callManager?: CallManager,
+  voiceboxManager?: VoiceboxManager,
   /** WebRTC signaling handlers — forwarded to Rust proxy-engine. */
   onWebRtcOffer?: (sessionId: string, sdp: string, ws: WebSocket) => Promise<void>,
   onWebRtcIce?: (sessionId: string, candidate: any) => Promise<void>,
   onWebRtcClose?: (sessionId: string) => Promise<void>,
-  voiceboxManager?: VoiceboxManager,
+  /** Called when browser sends webrtc-accept (callId + sessionId linking). */
+  onWebRtcAccept?: (callId: string, sessionId: string) => void,
 ): void {
   const WEB_PORT = 3060;
 
@@ -382,6 +384,7 @@ export function initWebUi(
         if (msg.type === 'webrtc-offer' && msg.sessionId) {
           // Forward to Rust proxy-engine for WebRTC handling.
           if (onWebRtcOffer) {
+            log(`[webrtc-ws] offer msg keys: ${Object.keys(msg).join(',')}, sdp type: ${typeof msg.sdp}, sdp len: ${msg.sdp?.length || 0}`);
             onWebRtcOffer(msg.sessionId, msg.sdp, socket as any).catch((e: any) =>
               log(`[webrtc] offer error: ${e.message}`));
           }
@@ -394,8 +397,10 @@ export function initWebUi(
             onWebRtcClose(msg.sessionId).catch(() => {});
           }
         } else if (msg.type === 'webrtc-accept' && msg.callId) {
-          // TODO: Wire to Rust call linking.
           log(`[webrtc] accept: call=${msg.callId} session=${msg.sessionId || 'none'}`);
+          if (onWebRtcAccept && msg.sessionId) {
+            onWebRtcAccept(msg.callId, msg.sessionId);
+          }
         } else if (msg.type?.startsWith('webrtc-')) {
           msg._remoteIp = remoteIp;
           handleWebRtcSignaling(socket as any, msg);

ts/sipproxy.ts

@@ -37,6 +37,7 @@ import {
   shutdownProxyEngine,
   webrtcOffer,
   webrtcIce,
+  webrtcLink,
   webrtcClose,
 } from './proxybridge.ts';
 import type {
@@ -118,6 +119,12 @@ const activeCalls = new Map<string, IActiveCall>();
 const callHistory: ICallHistoryEntry[] = [];
 const MAX_HISTORY = 100;
 
+// WebRTC session ↔ call linking state.
+// Both pieces (session accept + call media info) can arrive in any order.
+const webrtcSessionToCall = new Map<string, string>(); // sessionId → callId
+const webrtcCallToSession = new Map<string, string>(); // callId → sessionId
+const pendingCallMedia = new Map<string, { addr: string; port: number; sipPt: number }>(); // callId → provider media info
+
 // Initialize provider statuses from config (all start as unregistered).
 for (const p of appConfig.providers) {
   providerStatuses.set(p.id, {
@@ -271,6 +278,17 @@ async function startProxyEngine(): Promise<void> {
       state: 'setting-up',
       startedAt: Date.now(),
     });
+
+    // Notify all browser devices — they can connect via WebRTC to listen/talk.
+    const browserIds = getAllBrowserDeviceIds();
+    for (const bid of browserIds) {
+      sendToBrowserDevice(bid, {
+        type: 'webrtc-incoming',
+        callId: data.call_id,
+        from: data.number,
+        deviceId: bid,
+      });
+    }
   });
 
   onProxyEvent('call_ringing', (data: { call_id: string }) => {
@@ -278,12 +296,33 @@ async function startProxyEngine(): Promise<void> {
     if (call) call.state = 'ringing';
   });
 
-  onProxyEvent('call_answered', (data: { call_id: string }) => {
+  onProxyEvent('call_answered', (data: { call_id: string; provider_media_addr?: string; provider_media_port?: number; sip_pt?: number }) => {
     const call = activeCalls.get(data.call_id);
     if (call) {
       call.state = 'connected';
       log(`[call] ${data.call_id} connected`);
     }
+
+    // Try to link WebRTC session to this call for audio bridging.
+    if (data.provider_media_addr && data.provider_media_port) {
+      const sessionId = webrtcCallToSession.get(data.call_id);
+      if (sessionId) {
+        // Both session and media info available — link now.
+        const sipPt = data.sip_pt ?? 9;
+        log(`[webrtc] linking session=${sessionId.slice(0, 8)} to call=${data.call_id} media=${data.provider_media_addr}:${data.provider_media_port} pt=${sipPt}`);
+        webrtcLink(sessionId, data.call_id, data.provider_media_addr, data.provider_media_port, sipPt).then((ok) => {
+          log(`[webrtc] link result: ${ok}`);
+        });
+      } else {
+        // Session not yet accepted — store media info for when it arrives.
+        pendingCallMedia.set(data.call_id, {
+          addr: data.provider_media_addr,
+          port: data.provider_media_port,
+          sipPt: data.sip_pt ?? 9,
+        });
+        log(`[webrtc] media info cached for call=${data.call_id}, waiting for session accept`);
+      }
+    }
   });
 
   onProxyEvent('call_ended', (data: ICallEndedEvent) => {
@@ -301,6 +340,18 @@ async function startProxyEngine(): Promise<void> {
       });
       if (callHistory.length > MAX_HISTORY) callHistory.pop();
       activeCalls.delete(data.call_id);
+
+      // Notify browser(s) that the call ended.
+      broadcastWs('webrtc-call-ended', { callId: data.call_id });
+
+      // Clean up WebRTC session mappings.
+      const sessionId = webrtcCallToSession.get(data.call_id);
+      if (sessionId) {
+        webrtcCallToSession.delete(data.call_id);
+        webrtcSessionToCall.delete(sessionId);
+        webrtcClose(sessionId).catch(() => {});
+      }
+      pendingCallMedia.delete(data.call_id);
     }
   });
 
@@ -467,14 +518,22 @@ initWebUi(
     }
   },
   undefined, // callManager — legacy, replaced by Rust proxy-engine
-  voiceboxManager,
+  voiceboxManager, // voiceboxManager
   // WebRTC signaling → forwarded to Rust proxy-engine.
   async (sessionId, sdp, ws) => {
-    log(`[webrtc] offer from browser session=${sessionId.slice(0, 8)}`);
+    log(`[webrtc] offer from browser session=${sessionId.slice(0, 8)} sdp_type=${typeof sdp} sdp_len=${sdp?.length || 0}`);
+    if (!sdp || typeof sdp !== 'string' || sdp.length < 10) {
+      log(`[webrtc] WARNING: invalid SDP (type=${typeof sdp}), skipping offer`);
+      return;
+    }
+    log(`[webrtc] sending offer to Rust (${sdp.length}b)...`);
     const result = await webrtcOffer(sessionId, sdp);
+    log(`[webrtc] Rust result: ${JSON.stringify(result)?.slice(0, 200)}`);
     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)}`);
+    } else {
+      log(`[webrtc] ERROR: no answer SDP from Rust`);
     }
   },
   async (sessionId, candidate) => {
@@ -483,6 +542,26 @@ initWebUi(
   async (sessionId) => {
     await webrtcClose(sessionId);
   },
+  // onWebRtcAccept — browser has accepted a call, linking session to call.
+  (callId: string, sessionId: string) => {
+    log(`[webrtc] accept: callId=${callId} sessionId=${sessionId.slice(0, 8)}`);
+
+    // Store bidirectional mapping.
+    webrtcSessionToCall.set(sessionId, callId);
+    webrtcCallToSession.set(callId, sessionId);
+
+    // Check if we already have media info for this call (provider answered first).
+    const media = pendingCallMedia.get(callId);
+    if (media) {
+      pendingCallMedia.delete(callId);
+      log(`[webrtc] linking session=${sessionId.slice(0, 8)} to call=${callId} media=${media.addr}:${media.port} pt=${media.sipPt}`);
+      webrtcLink(sessionId, callId, media.addr, media.port, media.sipPt).then((ok) => {
+        log(`[webrtc] link result: ${ok}`);
+      });
+    } else {
+      log(`[webrtc] session ${sessionId.slice(0, 8)} accepted, waiting for call_answered media info`);
+    }
+  },
 );
 
 // ---------------------------------------------------------------------------