arnacon-webrtc-service 0.1.71 → 0.1.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnacon-webrtc-service",
-  "version": "0.1.71",
+  "version": "0.1.73",
   "description": "Arnacon WebRTC core runtime and service modules",
   "main": "./webRTCservice/core.js",
   "type": "commonjs",

package/webRTCservice/modules/bridge.js

@@ -98,14 +98,16 @@ function createBridgeApi({
         return trimmed;
     }
 
-    function narrowAudioOfferToG711(sdp) {
+    function narrowAudioOfferToPayloads(sdp, allowedPayloads) {
         if (!sdp || !sdp.includes("m=audio")) return sdp;
+        const allowedPayloadSet = new Set((allowedPayloads || []).map(String));
+        if (allowedPayloadSet.size === 0) return sdp;
         const sections = sdp.split(/\r\n(?=m=)/);
         return sections.map((section) => {
             if (!section.startsWith("m=audio")) return section;
             const lines = section.split(/\r\n/);
             const mLine = lines[0].split(" ");
-            const payloads = mLine.slice(3).filter((pt) => pt === "0" || pt === "8");
+            const payloads = mLine.slice(3).filter((pt) => allowedPayloadSet.has(pt));
             if (!payloads.length) return section;
 
             const allowed = new Set(payloads);
@@ -119,6 +121,13 @@ function createBridgeApi({
         }).join("\r\n");
     }
 
+    function narrowAudioOfferForCodecPolicy(sdp, codecPolicy) {
+        if (codecPolicy === "pcmu") return narrowAudioOfferToPayloads(sdp, ["0"]);
+        if (codecPolicy === "pcma") return narrowAudioOfferToPayloads(sdp, ["8"]);
+        if (codecPolicy === "g711") return narrowAudioOfferToPayloads(sdp, ["0", "8"]);
+        return sdp;
+    }
+
     function attachOutboundDataChannel(legSessionId, legSession) {
         const pc = createPeerConnection(legSessionId);
         if (typeof pc.createDataChannel !== "function") return pc;
@@ -186,11 +195,11 @@ function createBridgeApi({
         const candidatesToEmbed = srflxAndRelay.length > 0 ? srflxAndRelay : gatheredCandidates;
         const relayCandidates = getRelayCandidates(gatheredCandidates);
         let baseOfferSdp = offer.sdp;
-        if (callerSession.mediaCodecPolicy === "g711") {
-            const g711OfferSdp = narrowAudioOfferToG711(baseOfferSdp);
-            if (g711OfferSdp !== baseOfferSdp) {
-                logger.log(`[${legSessionId}] WebRTC leg inherited G.711 bridge codec policy`);
-                baseOfferSdp = g711OfferSdp;
+        if (callerSession.mediaCodecPolicy) {
+            const narrowedOfferSdp = narrowAudioOfferForCodecPolicy(baseOfferSdp, callerSession.mediaCodecPolicy);
+            if (narrowedOfferSdp !== baseOfferSdp) {
+                logger.log(`[${legSessionId}] WebRTC leg inherited bridge codec policy=${callerSession.mediaCodecPolicy}`);
+                baseOfferSdp = narrowedOfferSdp;
             }
         }
         const offerSdp = embedCandidatesInSdp(baseOfferSdp, candidatesToEmbed);

package/webRTCservice/modules/callFlow.js

@@ -100,11 +100,11 @@ function createCallFlowApi({
         const candidatesToEmbed = srflxAndRelay.length > 0 ? srflxAndRelay : gatheredCandidates;
         const relayCandidates = getRelayCandidates(gatheredCandidates);
         let baseOfferSdp = offer.sdp;
-        if (session.mediaCodecPolicy === "g711") {
-            const g711OfferSdp = narrowAudioOfferToG711(baseOfferSdp);
-            if (g711OfferSdp !== baseOfferSdp) {
-                logger.log(`[${sessionId}] outbound WebRTC leg: narrowed RING offer to PCMU/PCMA`);
-                baseOfferSdp = g711OfferSdp;
+        if (session.mediaCodecPolicy) {
+            const narrowedOfferSdp = narrowAudioOfferForCodecPolicy(baseOfferSdp, session.mediaCodecPolicy);
+            if (narrowedOfferSdp !== baseOfferSdp) {
+                logger.log(`[${sessionId}] outbound WebRTC leg: narrowed RING offer codecPolicy=${session.mediaCodecPolicy}`);
+                baseOfferSdp = narrowedOfferSdp;
             }
         }
         const offerSdp = embedCandidatesInSdp(baseOfferSdp, candidatesToEmbed);
@@ -198,6 +198,30 @@ function createCallFlowApi({
         return narrowAudioOfferToPayloads(sdp, ["8"]);
     }
 
+    function narrowAudioOfferToPcmu(sdp) {
+        return narrowAudioOfferToPayloads(sdp, ["0"]);
+    }
+
+    function narrowAudioOfferForCodecPolicy(sdp, codecPolicy) {
+        if (codecPolicy === "pcma") return narrowAudioOfferToPcma(sdp);
+        if (codecPolicy === "pcmu") return narrowAudioOfferToPcmu(sdp);
+        if (codecPolicy === "g711") return narrowAudioOfferToG711(sdp);
+        return sdp;
+    }
+
+    function getPrimaryAudioPayload(sdp) {
+        const audioSection = String(sdp || "").match(/m=audio[^\r\n]*[\s\S]*?(?=\r?\nm=|$)/m)?.[0] || "";
+        const mLine = audioSection.match(/^m=audio[^\r\n]*/m)?.[0] || "";
+        return mLine.split(/\s+/).slice(3)[0] || null;
+    }
+
+    function exactG711PolicyFromAnswer(answerSdp) {
+        const primaryPt = getPrimaryAudioPayload(answerSdp);
+        if (primaryPt === "0") return "pcmu";
+        if (primaryPt === "8") return "pcma";
+        return null;
+    }
+
     function routeCodecPolicy(destination, isInbound) {
         if (isInbound) return false;
         if (destination?.route === "sbc") return "pcma";
@@ -294,7 +318,14 @@ function createCallFlowApi({
         ensureLocalAudioTrack(session, pc, sessionId);
         const answerLabel = isInactive ? "PHASE 1 ANSWER SDP" : "ANSWER SDP";
         const answerSdp = await createAnswerSdp(pc, sessionId, answerLabel);
-        if (!isInbound && destination?.route === "ivr") storeIvrNegotiatedAudio(session, sessionId, answerSdp);
+        if (!isInbound && destination?.route === "ivr") {
+            const exactPolicy = exactG711PolicyFromAnswer(answerSdp);
+            if (exactPolicy) {
+                session.mediaCodecPolicy = exactPolicy;
+                logger.log(`[${sessionId}] IVR bridge codec policy resolved to ${exactPolicy}`);
+            }
+            storeIvrNegotiatedAudio(session, sessionId, answerSdp);
+        }
 
         if (!isInbound) sendAck(sessionId);
         let routeResult = null;

package/webRTCservice/services/secnum.js

@@ -2,14 +2,8 @@
 
 const DOMAINS = ["secnumtest.global", "secnum.global", "cellactm.global", "cellactl.global"];
 const IVR_WAITING_AUDIO_FILE = "waiting.mp3";
-const HARD_CODED_MULTI_RING = {
-    callerEns: "972557012401.secnumtest.global",
-    callerSbcNumber: "972557258108",
-    ringTargets: [
-        "972557012402.secnumtest.global",
-        "972557012403.secnumtest.global",
-    ],
-};
+const MULTIRING_CONFIG_BASE_URL = "https://lightpbx-save-config-343948402138.europe-west1.run.app";
+const MULTIRING_CONFIG_TIMEOUT_MS = 2500;
 
 function getDomains(helpers) {
     const configured = helpers.getServiceConstants()?.domains;
@@ -45,17 +39,94 @@ async function resolveEnsWallet(helpers, ensName) {
     return null;
 }
 
-async function buildHardcodedMultiRing(parsedFrom, helpers) {
-    const fromEns = String(parsedFrom?.full || "").toLowerCase();
-    const fromNumber = helpers.normalizePhone(parsedFrom?.value || parsedFrom?.full || "");
-    const matchedEns = fromEns === HARD_CODED_MULTI_RING.callerEns;
-    const matchedSbcNumber = fromNumber === HARD_CODED_MULTI_RING.callerSbcNumber;
-    if (!matchedEns && !matchedSbcNumber) {
+function normalizeMultiringEndpoint(value, helpers) {
+    const firstLabel = String(value || "").trim().split(".")[0] || "";
+    return helpers.normalizePhone(firstLabel).replace(/\D/g, "");
+}
+
+async function fetchMultiringConfig(endpoint, helpers) {
+    if (!endpoint || typeof fetch !== "function") return null;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), MULTIRING_CONFIG_TIMEOUT_MS);
+    try {
+        const url = `${MULTIRING_CONFIG_BASE_URL}/get_mutiring/${encodeURIComponent(endpoint)}`;
+        const resp = await fetch(url, { method: "GET", signal: controller.signal });
+        if (!resp.ok) {
+            helpers.logRouteDecision?.({
+                serviceId: "secnum",
+                route: "multiring-config",
+                endpoint,
+                status: resp.status,
+            });
+            return null;
+        }
+        return await resp.json();
+    } catch (err) {
+        helpers.logRouteDecision?.({
+            serviceId: "secnum",
+            route: "multiring-config",
+            endpoint,
+            error: err.message,
+        });
         return null;
+    } finally {
+        clearTimeout(timeout);
+    }
+}
+
+function extractMultiringEmails(config) {
+    if (!config || config.ok === false || config.found === false) return [];
+    if (config?.route?.type !== "multi_ring") return [];
+
+    const directEmails = config?.route?.multiRing?.group?.selectedEmails;
+    if (Array.isArray(directEmails)) return directEmails;
+
+    const groupId = config?.route?.multiRing?.groupId;
+    if (!groupId || !Array.isArray(config?.groups)) return [];
+    const group = config.groups.find((item) => item?.id === groupId);
+    return Array.isArray(group?.selectedEmails) ? group.selectedEmails : [];
+}
+
+function multiringTargetToEnsName(target, helpers, targetDomain) {
+    const value = String(target || "").trim().toLowerCase();
+    if (!value) return null;
+
+    if (value.includes("@") && !value.endsWith(".global")) {
+        return helpers.emailToEnsName(helpers.normalizeEmail(value), targetDomain);
+    }
+
+    if (value.endsWith(".global")) {
+        return value;
+    }
+
+    const normalizedPhone = helpers.normalizePhone(value).replace(/\D/g, "");
+    if (normalizedPhone) {
+        return `${normalizedPhone}.${targetDomain}`;
     }
 
+    return null;
+}
+
+async function buildConfiguredMultiRing(parsedTo, helpers) {
+    const rawTarget = helpers.normalizePhone(parsedTo?.value || parsedTo?.full || "");
+    if (!/^\d+$/.test(rawTarget)) return null;
+
+    const endpoint = normalizeMultiringEndpoint(rawTarget, helpers);
+    if (!endpoint) return null;
+
+    const config = await fetchMultiringConfig(endpoint, helpers);
+    const ringTargets = extractMultiringEmails(config)
+        .map((target) => String(target || "").trim())
+        .filter(Boolean);
+    if (ringTargets.length === 0) return null;
+
+    const targetDomain = getDomains(helpers)[0];
     const targets = [];
-    for (const ensName of HARD_CODED_MULTI_RING.ringTargets) {
+    const seenEnsNames = new Set();
+    for (const ringTarget of ringTargets) {
+        const ensName = multiringTargetToEnsName(ringTarget, helpers, targetDomain);
+        if (!ensName || seenEnsNames.has(ensName)) continue;
+        seenEnsNames.add(ensName);
         const wallet = await resolveEnsWallet(helpers, ensName);
         if (!wallet) continue;
         targets.push({ wallet, ensName });
@@ -69,7 +140,7 @@ async function buildHardcodedMultiRing(parsedFrom, helpers) {
         route: "webrtc-multiring",
         mode: "first-verified-answer-wins",
         targets,
-        ruleId: "hardcoded-secnumtest-multiring",
+        ruleId: `gcp-secnum-multiring:${endpoint}`,
     };
 }
 
@@ -99,9 +170,6 @@ async function resolveDestination(ctx) {
     const { parsedTo, parsedFrom, helpers } = ctx;
     if (!parsedTo) return { route: "reject", reason: "Missing destination" };
 
-    const multiRing = await buildHardcodedMultiRing(parsedFrom, helpers);
-    if (multiRing) return multiRing;
-
     const normalizedTarget = helpers.normalizePhone(parsedTo.value || parsedTo.full || "");
     if (normalizedTarget === "2006") {
         return {
@@ -112,6 +180,9 @@ async function resolveDestination(ctx) {
         };
     }
 
+    const multiRing = await buildConfiguredMultiRing(parsedTo, helpers);
+    if (multiRing) return multiRing;
+
     if (parsedTo.type === "raw" || parsedTo.type === "unknown") {
         return { route: "sbc", number: helpers.normalizePhone(parsedTo.value) };
     }