arnacon-webrtc-service 0.1.166 → 0.1.167

package/package.json

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

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

@@ -7,9 +7,22 @@
 
 const { reconcile } = require("./ReconcileRules");
 const { LEG_INTENTS } = require("./ports");
+const { LEG_STATES, isActiveCall } = require("./states");
 
 const MAX_RECONCILE_PASSES = 50;
 
+// Intents that drive a call toward the peer. If one of these throws (e.g. the SIP
+// INVITE is rejected during `ring`), the leg can no longer carry the call -> mark
+// it FAILED so reconcile ends the caller (end-call reneg). Teardown intents are
+// excluded: failing a teardown into more teardown would loop.
+const FAIL_ON_ERROR_INTENTS = new Set([
+    LEG_INTENTS.RING,
+    LEG_INTENTS.CONNECT,
+    LEG_INTENTS.ANSWER,
+    LEG_INTENTS.ACK_CONNECTED,
+    LEG_INTENTS.ACK_RING,
+]);
+
 class PolySession {
     constructor({ id, legA, legB, mediaController, rules = reconcile, teardownHooks = [], logger = console } = {}) {
         if (!legA || !legB) throw new Error("PolySession requires two legs");
@@ -95,6 +108,7 @@ class PolySession {
                 for (const action of actions) {
                     await this._execute(action);
                 }
+                this._recoverFailedLegs();
             }
         } finally {
             this._running = false;
@@ -129,10 +143,33 @@ class PolySession {
             }
         } catch (err) {
             this.logger.error(`[${this.id}] intent ${action.intent} on leg ${leg.id} failed: ${err.message}`);
+            // A reaching intent failed -> the leg cannot carry the call. Fail it so
+            // reconcile drives the peer into an end-call reneg (a FAILED leg is a
+            // teardown trigger). Idempotent: no-op if already FAILED/torn down.
+            if (FAIL_ON_ERROR_INTENTS.has(action.intent) && leg.state !== LEG_STATES.FAILED) {
+                leg.setState(LEG_STATES.FAILED, { reason: `intent-failed:${action.intent}`, from: "self" });
+            }
         }
         return undefined;
     }
 
+    // Once the call is over, a transportless leg left FAILED (e.g. a SIP INVITE that
+    // was rejected during ring) is stuck: FAILED is not rungable, so the next call
+    // would stall. Reset it to its idle (DISCONNECTED) so reconcile can re-drive it
+    // (the SIP leg rebuilds its INVITE per call). Scoped to SIP: a webrtc leg's
+    // FAILED means its actual PC died, so it must NOT be silently revived here.
+    // Only when the peer is no longer in an active call, so we never wipe a leg
+    // whose end-call reneg is still in flight.
+    _recoverFailedLegs() {
+        for (const ref of ["a", "b"]) {
+            const leg = this.legs[ref];
+            const peer = this.legs[ref === "a" ? "b" : "a"];
+            if (leg.kind === "sip" && leg.state === LEG_STATES.FAILED && !isActiveCall(peer.state)) {
+                leg.setState(LEG_STATES.DISCONNECTED, { reason: "failed-leg-recovery", from: "self" });
+            }
+        }
+    }
+
     async _executeMedia(action) {
         try {
             if (action.op === "connect") {

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

@@ -182,6 +182,40 @@ test("webrtc<->sip: remote BYE on sip leg ends the webrtc caller", async () => {
     assert.equal(a.leg.state, S.CONNECTED);
 });
 
+test("sip ring failure ends the webrtc caller, then the sip leg recovers for reuse", async () => {
+    const a = makeWebRtcLeg("alice");
+    const b = makeSipLeg("+15551234");
+    const { poly, media } = buildPoly(a, b);
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+
+    // The SIP INVITE is rejected before it establishes -> ring() rejects.
+    const realRing = b.negotiation.ring.bind(b.negotiation);
+    b.negotiation.ring = async () => { throw new Error("SIP call terminated before established"); };
+
+    // Caller offers -> P rings the sip leg, which fails -> sip FAILED -> P ends the
+    // caller via an end-call reneg (no media ever bridged).
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "o" }));
+    assert.equal(b.leg.state, S.FAILED, "sip leg failed its ring");
+    assert.equal(a.leg.state, S.ENDING, "caller is ended on the failed ring");
+    assert.equal(a.negotiation.named("endCall").length, 1);
+    assert.equal(media.connects.length, 0, "no media bridged for a failed ring");
+
+    // Caller's client answers the end-call offer -> caller back to connected, and
+    // the stuck FAILED sip leg recovers to its idle (DISCONNECTED) so it is reusable.
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.END_RENEGOTIATION, { type: "answer", sdp: "end-ans" }));
+    assert.equal(a.leg.state, S.CONNECTED);
+    assert.equal(b.leg.state, S.DISCONNECTED, "failed sip leg recovered to idle for reuse");
+
+    // Reuse: sip is reachable again -> a fresh offer connects + rings the sip leg
+    // (a blocking INVITE that answers -> both in-call, media bridged).
+    b.negotiation.ring = realRing;
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "o2" }));
+    assert.equal(a.leg.state, S.IN_CALL);
+    assert.equal(b.leg.state, S.IN_CALL, "sip leg rung again on reuse");
+    assert.equal(media.connects.length, 1, "media bridged on the reused call");
+});
+
 test("reject before answer: caller is ended, no media ever bridged", async () => {
     const a = makeWebRtcLeg("alice");
     const b = makeWebRtcLeg("bob");

package/webRTCservice/modules/calls/poly/__tests__/ReconcileRules.test.js

@@ -27,6 +27,12 @@ test("teardown beats progress: inCall vs failed (dropped) ends the inCall side,
     assert.deepEqual(ends[0], { kind: "intent", leg: "a", intent: I.END, from: "b" });
 });
 
+test("calling vs failed (e.g. sip ring rejected) ends the calling caller", () => {
+    const actions = reconcile(snap(S.CALLING, S.FAILED, false));
+    assert.deepEqual(mediaOps(actions), []);
+    assert.deepEqual(intents(actions), [{ kind: "intent", leg: "a", intent: I.END, from: "b" }]);
+});
+
 test("inCall vs disconnected (peer gone, e.g. sip BYE) ends the inCall side, stops media", () => {
     // You cannot be in a call by yourself: a disconnected peer ends the inCall leg.
     const actions = reconcile(snap(S.IN_CALL, S.DISCONNECTED, true));

package/webRTCservice/modules/media/werift/PeerConnectionFactory.js

@@ -39,14 +39,14 @@ function createPeerConnectionFactory({
             s.connectionState = state;
             session.connectionState = state;
             if (shouldRequestDestroy && (state === "failed" || state === "closed")) {
-                onSessionDestroyRequested(sessionId, { source: "webrtc", reason: `peer-connection-${state}`, notify: true });
+                onSessionDestroyRequested(sessionId, { source: "webrtc", reason: `peer-connection-${state}`, notify: true, pc });
             } else if (state === "disconnected") {
                 if (!s.disconnectTimer) {
                     s.disconnectTimer = setTimeout(() => {
                         s.disconnectTimer = null;
                         const current = sessions.get(sessionId);
                         if (shouldRequestDestroy && current && session.peerConnection === pc && session.connectionState === "disconnected") {
-                            onSessionDestroyRequested(sessionId, { source: "webrtc", reason: "peer-connection-disconnected", notify: true });
+                            onSessionDestroyRequested(sessionId, { source: "webrtc", reason: "peer-connection-disconnected", notify: true, pc });
                         }
                     }, 5000);
                 }

package/webRTCservice/webRTCmanager.js

@@ -1166,6 +1166,15 @@ function isSessionInCall(session) {
 // Terminal PC state -> tear the pair down and clean up.
 async function onTransportClosed(sessionId, event = {}) {
     const session = sessions.get(sessionId);
+    // A 2nd call reuses the same sessionId on a fresh transport. The old call's PC
+    // can fire `closed` after the new session is already bound under this id. If the
+    // closing transport is no longer the session's current caller/callee PC, it is
+    // superseded -> ignore it entirely so we don't tear down the fresh session.
+    if (session && event.pc &&
+        event.pc !== session.peerConnection &&
+        event.pc !== session.outboundWebrtc?.peerConnection) {
+        return;
+    }
     const poly = polyForSession(session);
     // Only tear the poly down if it actually owns this closing transport. A stale
     // PC closing after a new-ring rebuild resolves (by identity) to the freshly