arnacon-webrtc-service 0.1.183 → 0.1.185

package/package.json

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

package/webRTCservice/modules/calls/poly/PolySession.js

@@ -35,6 +35,16 @@ class PolySession {
         // billing). Kept as a list so callers compose without subclassing.
         this._teardownHooks = teardownHooks.filter((h) => typeof h === "function");
         this._teardownRan = false;
+        // Call-lifecycle hooks, fired on the active<->inactive edge derived from leg
+        // states (a call is "active" while either leg isActiveCall). This is the
+        // single robust seam for per-call side-effects that must bracket the call
+        // itself -- NOT the poly's disposal -- so they fire once per call on EVERY
+        // end path (hangup either side, mid-call failure, transport drop, reject)
+        // and again on a reused poly's next call. Used for minute-counter
+        // start/finish so billing always stops regardless of how the call ends.
+        this._onCallStart = null;
+        this._onCallEnd = null;
+        this._callActive = false;
         this.logger = logger;
 
         this.mediaHandle = null;
@@ -110,11 +120,38 @@ class PolySession {
                 }
                 this._recoverFailedLegs();
             }
+            await this._settleCallActivity();
         } finally {
             this._running = false;
         }
     }
 
+    // Detect the in-call edge from the quiesced leg states and fire the lifecycle
+    // hooks once per transition. "In call" = BOTH legs are IN_CALL, i.e. the actual
+    // answered conversation (the media-bridged window) -- ring/setup/teardown are
+    // deliberately excluded. The falling edge is the reliable "conversation is over"
+    // signal that fires on every end path (hangup either side, mid-call failure,
+    // transport drop) while the poly itself survives for reuse.
+    async _settleCallActivity() {
+        const active = this.legs.a.state === LEG_STATES.IN_CALL && this.legs.b.state === LEG_STATES.IN_CALL;
+        if (active === this._callActive) return;
+        this._callActive = active;
+        const hook = active ? this._onCallStart : this._onCallEnd;
+        if (typeof hook !== "function") return;
+        try {
+            await hook(this);
+        } catch (err) {
+            this.logger.error(`[${this.id}] call-${active ? "start" : "end"} hook failed: ${err.message}`);
+        }
+    }
+
+    // Inject per-call lifecycle side-effects (e.g. minuteCounter start/finish).
+    // Idempotent to set; safe to (re)assign on a reused poly before its next call.
+    setCallActivityHooks({ onCallStart = null, onCallEnd = null } = {}) {
+        if (onCallStart !== undefined) this._onCallStart = typeof onCallStart === "function" ? onCallStart : null;
+        if (onCallEnd !== undefined) this._onCallEnd = typeof onCallEnd === "function" ? onCallEnd : null;
+    }
+
     async _execute(action) {
         if (action.kind === "media") {
             return this._executeMedia(action);

package/webRTCservice/webRTCmanager.js

@@ -139,7 +139,7 @@ const { ParticipantFactory } = require("./modules/participants/ParticipantFactor
 const { createPolyCore } = require("./modules/calls/poly/createPolyCore");
 const { WebRtcOutboundLegFactory } = require("./modules/calls/webrtc/WebRtcOutboundLegFactory");
 const { LEG_EVENTS, makeLegEvent } = require("./modules/calls/poly/ports");
-const { LEG_STATES } = require("./modules/calls/poly/states");
+const { LEG_STATES, canBeRung, isActiveCall } = require("./modules/calls/poly/states");
 const { isInactiveOffer } = require("./modules/calls/poly/negotiation/sdp");
 const { routeToCodecPolicy } = require("./modules/media/negotiation/CodecPolicy");
 const { narrowAudioOfferForCodecPolicy } = require("./modules/media/negotiation/SdpCodecNegotiator");
@@ -730,9 +730,67 @@ console.log("[poly] PolySession core is the live coordinator");
 // HTTP SERVER — ENTRY POINT
 // ═════════════════════════════════════════════════════════════
 
+// Inbound reuse: if the PSTN callee already has a live, connected webrtc leg that
+// is paired with THIS PSTN caller (idle from a prior call between the two), there
+// is nothing to FCM-wake. Seed the PSTN INVITE as the SIP caller's OFFER into the
+// EXISTING poly and let reconcile ring the connected callee over its open data
+// channel -- byte-for-byte the webrtc<->webrtc redial path. Same S, same P; no
+// fresh session, no notification. Returns the reuse result, or null to fall back
+// to the cold (FCM-wake) flow when the callee isn't reachably connected.
+async function tryInboundReuse(payload) {
+    const calleeLabel = pLabel(String(payload.to || "").toLowerCase());
+    const callerLabel = pLabel(String(payload.from || "").replace(/^\+/, "").toLowerCase());
+    if (!calleeLabel || !callerLabel) return null;
+
+    const poly = polyRegistry.getByEndpoint(payload.to);
+    if (!poly) return null;
+
+    const sipRef = polySipRef(poly);
+    const webRef = poly.legs.a.kind === "webrtc" ? "a" : (poly.legs.b.kind === "webrtc" ? "b" : null);
+    if (!sipRef || !webRef) return null; // not a webrtc<->sip poly
+
+    const webLeg = poly.legs[webRef];
+    const sipLeg = poly.legs[sipRef];
+
+    // The webrtc leg must be the callee (this `to`) and the sip leg this `from`,
+    // else the existing poly belongs to a different conversation.
+    if (pLabel(String(webLeg.endpoint || "").toLowerCase()) !== calleeLabel) return null;
+    if (pLabel(String(sipLeg.endpoint || "").toLowerCase()) !== callerLabel) return null;
+
+    // Only reuse a callee whose transport is actually rungable, and only if the
+    // sip leg is idle (no call already in flight on this poly).
+    if (!canBeRung(webLeg.state)) return null;
+    if (isActiveCall(sipLeg.state)) return null;
+
+    const hostSession = webLeg.negotiation?.session;
+    if (!hostSession || !hostSession.peerConnection) return null;
+
+    // Inject the per-call SIP context onto the reused session: the callee's own
+    // number to REGISTER as (openInbound pulls the suspended SBC INVITE) and the
+    // inbound metadata. Direction is decided by P firing answer() on the sip leg,
+    // never stored on the leg.
+    hostSession.inboundCall = { fromNumber: payload.from, toNumber: payload.to, callId: payload.callId };
+    if (sipLeg.negotiation) sipLeg.negotiation.phoneNumber = payload.to;
+
+    console.log(`[${hostSession.sessionId}] inbound reuse: ringing connected callee ${calleeLabel} over existing DC (caller ${callerLabel})`);
+    try {
+        // Seed the PSTN INVITE as the sip caller's OFFER -> CALLING. Reconcile then
+        // sees sip CALLING + webrtc CONNECTED -> ring(webrtc) over its DC; on pickup
+        // -> answer(sip) (openInbound) + media bridge.
+        await poly.onIngress(sipRef, makeLegEvent(LEG_EVENTS.OFFER));
+    } catch (err) {
+        console.error(`[${hostSession.sessionId}] inbound reuse seed failed: ${err.message}`);
+        return null;
+    }
+    return { ok: true, sessionId: hostSession.sessionId, reused: true };
+}
+
 async function handleInboundCallRequest(data, serviceContext = null) {
     const payload = serviceContext?.serviceId ? { ...data, serviceId: serviceContext.serviceId } : data;
-    // The inbound flow creates the session + PC1 and FCM-invites the secnum callee.
+    // Fast path: reuse a connected callee's existing transport (P rings over DC).
+    const reused = await tryInboundReuse(payload);
+    if (reused) return reused;
+    // Cold path: the inbound flow creates the session + PC1 and FCM-invites the secnum callee.
     const result = await inboundCallFlowApi.handleInboundCallRequest(payload);
     if (result?.ok && result.sessionId) {
         const session = sessions.get(result.sessionId);
@@ -758,6 +816,14 @@ async function handleInboundCallRequest(data, serviceContext = null) {
             const phoneNumber = session.inboundCall?.toNumber || payload.to;
             const callerNumber = session.inboundCall?.fromNumber || session.callerEns;
             try {
+                // The registry keys polys by an order-independent pair key, so a
+                // stale poly from a prior call between these two parties (e.g. an
+                // earlier W->SIP attempt) resolves to the SAME key. Reusing it is
+                // wrong here: its leg layout (a/b) and bound session belong to that
+                // old call, so the hardcoded onIngress("a") would hit the wrong leg.
+                // An inbound call always brings a fresh session + FCM wake, so it
+                // must own a fresh poly -> tear any stale one down first.
+                await polyRegistry.destroy(polyRegistry.keyForPair(callerNumber, calleeEns), "inbound-fresh-call");
                 const { poly } = polyRegistry.resolve({
                     a: { endpoint: callerNumber, kind: "sip", phoneNumber, session },
                     b: {
@@ -983,6 +1049,9 @@ async function onDcRing(callerSessionId, payload) {
 
     const a = { endpoint: session.callerEns, kind: "webrtc", session };
     let b;
+    // Minute metering is SBC/PSTN-outbound only; resolved in the sip branch below.
+    let minuteCounterSettings = null;
+    let minuteCounterIdentity = null;
     if (destination.route === "webrtc") {
         b = {
             endpoint: destination.ensName || destination.wallet,
@@ -1020,9 +1089,63 @@ async function onDcRing(callerSessionId, payload) {
             kind: "sip",
             session,
         };
+
+        // Minute metering for SBC/PSTN outbound. The poly cutover orphaned the
+        // legacy SbcRouteStrategy where start()/assertCanStart() lived, so wire it
+        // here at SIP-leg origination: gate on the per-service monthly cap, then (on
+        // resolve) stamp session.minuteCounter so the registry teardown hook's
+        // finish() records the elapsed seconds. Pure caller-side billing.
+        minuteCounterSettings = minuteCounterPolicy.getSettings(serviceId);
+        minuteCounterIdentity = minuteCounterPolicy.getIdentity(parsedFrom, session);
+        if (minuteCounterApi && minuteCounterSettings?.limitSeconds) {
+            try {
+                minuteCounterApi.assertCanStart({
+                    serviceId: minuteCounterSettings.serviceId,
+                    identity: minuteCounterIdentity,
+                    limitSeconds: minuteCounterSettings.limitSeconds,
+                });
+            } catch (err) {
+                console.log(`[${callerSessionId}] minute limit reached for ${minuteCounterIdentity}: ${err.message}`);
+                sendDataChannelMessage(callerSessionId, { msgType: "call", action: "end", reason: "minute-limit" });
+                return;
+            }
+            // Prepaid cutoff: when the caller is low on monthly balance (< 5 min
+            // left) tell Kamailio how many seconds THIS call is allowed via a "Limit"
+            // header. Kamailio arms a dialog timer, BYEs both legs at expiry, and
+            // strips the header before the SBC. The service decides the budget;
+            // Kamailio enforces it. (remaining > 0 here -- assertCanStart already
+            // rejected an exhausted balance.)
+            const usedSeconds = minuteCounterApi.getUsedSeconds({
+                serviceId: minuteCounterSettings.serviceId,
+                identity: minuteCounterIdentity,
+            });
+            const remainingSeconds = minuteCounterSettings.limitSeconds - usedSeconds;
+            if (remainingSeconds > 0 && remainingSeconds < 300) {
+                session.sipDirective.headers = {
+                    ...(session.sipDirective.headers || {}),
+                    Limit: String(remainingSeconds),
+                };
+                console.log(`[${callerSessionId}] low balance: capping call at ${remainingSeconds}s for ${minuteCounterIdentity}`);
+            }
+        }
     }
 
     const { poly } = polyRegistry.resolve({ a, b, target: "a" });
+    if (b.kind === "sip" && minuteCounterApi && minuteCounterSettings?.limitSeconds) {
+        // Bill only the answered conversation: PolySession fires onCallStart when
+        // both legs reach IN_CALL and onCallEnd when they leave it -- so the counter
+        // starts at answer and stops on ANY end (hangup either side, failure,
+        // transport drop), independent of poly disposal/reuse. finish() is
+        // idempotent (the dispose teardown hook remains a backstop).
+        poly.setCallActivityHooks({
+            onCallStart: () => minuteCounterApi.start(session, {
+                serviceId: minuteCounterSettings.serviceId,
+                identity: minuteCounterIdentity,
+                limitSeconds: minuteCounterSettings.limitSeconds,
+            }),
+            onCallEnd: () => minuteCounterApi.finish(session),
+        });
+    }
     // Caller transport is already up (HTTP handshake). The SIP leg has no transport
     // to negotiate (openOutbound happens on ring), so mark it usable too. A webrtc
     // callee, by contrast, starts disconnected: reconcile will connect() it (FCM