@webex/plugin-meetings 3.12.0-next.44 → 3.12.0-next.45

package/src/webinar/index.ts

@@ -98,13 +98,49 @@ const Webinar = WebexPlugin.extend({
     return {isPromoted, isDemoted};
   },
 
+  /**
+   * Resolves the meeting associated with this webinar instance, guarded against the
+   * meetingId pointer drifting onto an unrelated transient meeting (e.g. an inbound
+   * 1:1 call) that may exist in the meeting collection. Returns the meeting only when
+   * its locusUrl matches this webinar's tracked locusUrl. Returns undefined (with a
+   * warning) when the meeting cannot be resolved or when the webinar's locusUrl has
+   * not been initialized yet — callers must treat this as "no owned meeting" rather
+   * than fall through to an unvalidated lookup.
+   * @returns {object|undefined}
+   */
+  getValidatedWebinarMeeting() {
+    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+
+    if (!meeting) {
+      return undefined;
+    }
+
+    if (!this.locusUrl) {
+      LoggerProxy.logger.warn(
+        `Webinar:index#getValidatedWebinarMeeting --> skipping; webinar locusUrl is not yet initialized for meetingId ${this.meetingId}`
+      );
+
+      return undefined;
+    }
+
+    if (meeting.locusUrl !== this.locusUrl) {
+      LoggerProxy.logger.warn(
+        `Webinar:index#getValidatedWebinarMeeting --> skipping; meeting ${this.meetingId} locusUrl ${meeting.locusUrl} does not match webinar locusUrl ${this.locusUrl}`
+      );
+
+      return undefined;
+    }
+
+    return meeting;
+  },
+
   /**
    * should join practice session data channel or not
    * @param {Object} {isPromoted: boolean, isDemoted: boolean}} Role transition states
    * @returns {void}
    */
   updateStatusByRole({isPromoted, isDemoted}) {
-    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+    const meeting = this.getValidatedWebinarMeeting();
 
     if (
       (isDemoted && meeting?.shareStatus === SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE) ||
@@ -128,6 +164,9 @@ const Webinar = WebexPlugin.extend({
 
   /**
    * Disconnects the practice session data channel and removes its relay listener.
+   * The listener reference removed here is the exact callback captured at subscribe
+   * time (see updatePSDataChannel) so that cleanup is correct even if the underlying
+   * meeting can no longer be resolved (e.g. locusUrl mismatch).
    * @returns {Promise<void>}
    */
   async cleanupPSDataChannel() {
@@ -137,8 +176,6 @@ const Webinar = WebexPlugin.extend({
       this._pendingOnlineListener = null;
     }
 
-    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
-
     // @ts-ignore - Fix type
     await this.webex.internal.llm.disconnectLLM(
       {
@@ -147,15 +184,21 @@ const Webinar = WebexPlugin.extend({
       },
       LLM_PRACTICE_SESSION
     );
-    // @ts-ignore - Fix type
-    this.webex.internal.llm.off(
-      `event:relay.event:${LLM_PRACTICE_SESSION}`,
-      meeting?.processRelayEvent
-    );
+
+    if (this._practiceSessionRelayListener) {
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.off(
+        `event:relay.event:${LLM_PRACTICE_SESSION}`,
+        this._practiceSessionRelayListener
+      );
+      this._practiceSessionRelayListener = null;
+    }
   },
 
   /**
    * Ensures practice-session token exists before registering the practice LLM channel.
+   * Caller is responsible for passing a meeting that has already been resolved via
+   * getValidatedWebinarMeeting() — this method does not re-validate ownership.
    * @param {object} meeting
    * @returns {Promise<string|undefined>}
    */
@@ -211,7 +254,7 @@ const Webinar = WebexPlugin.extend({
     this._updatePSDataChannelSequence = (this._updatePSDataChannelSequence || 0) + 1;
     const invocationSequence = this._updatePSDataChannelSequence;
 
-    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+    const meeting = this.getValidatedWebinarMeeting();
     const isPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
 
     if (!isPracticeSession) {
@@ -312,15 +355,21 @@ const Webinar = WebexPlugin.extend({
         LLM_PRACTICE_SESSION
       )
       .then((registerAndConnectResult) => {
-        // @ts-ignore - Fix type
-        this.webex.internal.llm.off(
-          `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting?.processRelayEvent
-        );
+        // Track the exact listener reference so cleanupPSDataChannel can
+        // unsubscribe deterministically, even if the meeting can no longer
+        // be resolved at cleanup time.
+        if (this._practiceSessionRelayListener) {
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.off(
+            `event:relay.event:${LLM_PRACTICE_SESSION}`,
+            this._practiceSessionRelayListener
+          );
+        }
+        this._practiceSessionRelayListener = meeting?.processRelayEvent;
         // @ts-ignore - Fix type
         this.webex.internal.llm.on(
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting?.processRelayEvent
+          this._practiceSessionRelayListener
         );
         // @ts-ignore - Fix type
         this.webex.internal.voicea?.announce?.();
@@ -532,7 +581,14 @@ const Webinar = WebexPlugin.extend({
    * @returns {Promise}
    */
   async searchLargeScaleWebinarAttendees(payload) {
-    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+    const meeting = this.getValidatedWebinarMeeting();
+    if (!meeting) {
+      LoggerProxy.logger.error(
+        'Meeting:webinar5k#searchLargeScaleWebinarAttendees failed --> webinar meeting could not be validated'
+      );
+      throw new Error('Meeting:webinar5k#Webinar meeting is not resolvable for the current locus');
+    }
+
     const rawParams = {
       search_text: payload?.queryString,
       limit: payload?.limit ?? DEFAULT_LARGE_SCALE_WEBINAR_ATTENDEE_SEARCH_LIMIT,
@@ -540,7 +596,9 @@ const Webinar = WebexPlugin.extend({
     };
     const attendeeSearchUrl = meeting?.locusInfo?.links?.resources?.attendeeSearch?.url;
     if (!attendeeSearchUrl) {
-      LoggerProxy.logger.error(`Meeting:webinar5k#searchLargeScaleWebinarAttendees failed`);
+      LoggerProxy.logger.error(
+        'Meeting:webinar5k#searchLargeScaleWebinarAttendees failed --> attendee search url unavailable'
+      );
       throw new Error('Meeting:webinar5k#Attendee search url is not available');
     }
 

package/test/unit/spec/meeting/index.js

@@ -13703,6 +13703,131 @@ describe('plugin-meetings', () => {
           assert.notCalled(webex.internal.llm.setDatachannelToken);
         });
 
+        describe('ownership tag', () => {
+          beforeEach(() => {
+            // Make the owner stub dynamic so setOwnerMeetingId() writes
+            // propagate back to getOwnerMeetingId() reads. This mirrors the
+            // real LLM singleton behavior so the finally-block release in
+            // cleanupLLMConneciton is reflected in subsequent reads.
+            webex.internal.llm.getOwnerMeetingId = sinon.stub().returns(undefined);
+            webex.internal.llm.setOwnerMeetingId = sinon.stub().callsFake((id) => {
+              webex.internal.llm.getOwnerMeetingId.returns(id);
+            });
+          });
+
+          it('skips disconnect and reconnect when LLM is connected and owned by another meeting (regardless of URL)', async () => {
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(true);
+            webex.internal.llm.getOwnerMeetingId.returns('some-other-meeting-id');
+            // Locus/datachannel URL mismatch is the *normal* case when
+            // another meeting owns the live socket -- each meeting has its
+            // own locus URL. URL mismatch must NOT trigger a reclaim,
+            // because doing so would tear down the owning meeting's healthy
+            // LLM socket and break its data channel.
+            webex.internal.llm.getLocusUrl.returns('owner-locus-url');
+            webex.internal.llm.getDatachannelUrl.returns('owner-dc-url');
+            meeting.locusInfo = {
+              url: 'a different url',
+              info: {datachannelUrl: 'a different datachannel url'},
+              self: {},
+            };
+
+            const result = await meeting.updateLLMConnection();
+
+            assert.equal(result, undefined);
+            assert.notCalled(webex.internal.llm.disconnectLLM);
+            assert.notCalled(webex.internal.llm.registerAndConnect);
+            assert.notCalled(webex.internal.llm.setOwnerMeetingId);
+            assert.notCalled(meeting.startLLMHealthCheckTimer);
+          });
+
+
+          it('clears stale owner tag in cleanup finally block even when disconnectLLM rejects', async () => {
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(true);
+            webex.internal.llm.getOwnerMeetingId.returns(meeting.id);
+            webex.internal.llm.getLocusUrl.returns('a url');
+            webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
+            webex.internal.llm.disconnectLLM.rejects(new Error('disconnect failed'));
+            meeting.locusInfo = {
+              url: 'a different url',
+              info: {datachannelUrl: 'a datachannel url'},
+              self: {},
+            };
+
+            try {
+              await meeting.updateLLMConnection();
+            } catch (e) {
+              /* updateLLMConnection may reject when cleanup throws */
+            }
+
+            // The owner-eligible finally branch must release the tag so a
+            // subsequent reconnect attempt from any meeting is not blocked.
+            assert.calledWith(webex.internal.llm.setOwnerMeetingId, undefined);
+          });
+
+          it('proceeds normally when LLM is connected and owned by this meeting with URL change', async () => {
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(true);
+            webex.internal.llm.getOwnerMeetingId.returns(meeting.id);
+            webex.internal.llm.getLocusUrl.returns('a url');
+            webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
+            meeting.locusInfo = {
+              url: 'a different url',
+              info: {datachannelUrl: 'a datachannel url'},
+              self: {},
+            };
+
+            await meeting.updateLLMConnection();
+
+            assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
+              code: 3050,
+              reason: 'done (permanent)',
+            });
+            assert.calledWithExactly(
+              webex.internal.llm.registerAndConnect,
+              'a different url',
+              'a datachannel url',
+              undefined
+            );
+            // setOwnerMeetingId is called twice: first with undefined in
+            // cleanupLLMConneciton's finally block (so a failed disconnect
+            // cannot leave a stale owner), then with this meeting's id
+            // after registerAndConnect resolves.
+            assert.calledTwice(webex.internal.llm.setOwnerMeetingId);
+            assert.calledWith(webex.internal.llm.setOwnerMeetingId.firstCall, undefined);
+            assert.calledWith(webex.internal.llm.setOwnerMeetingId.lastCall, meeting.id);
+          });
+
+          it('claims ownership after successful registerAndConnect on initial connect', async () => {
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(false);
+            webex.internal.llm.getOwnerMeetingId.returns(undefined);
+            meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
+
+            await meeting.updateLLMConnection();
+
+            assert.calledOnce(webex.internal.llm.registerAndConnect);
+            assert.calledOnceWithExactly(webex.internal.llm.setOwnerMeetingId, meeting.id);
+          });
+
+          it('proceeds to connect when LLM is not connected even if another ownerId lingers', async () => {
+            // Defensive path: if the LLM reports not-connected but an old
+            // ownerId is still present (e.g. race before a successful
+            // connections.delete), this meeting can still claim a fresh
+            // connection.
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(false);
+            webex.internal.llm.getOwnerMeetingId.returns('stale-owner-id');
+            meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
+
+            await meeting.updateLLMConnection();
+
+            assert.calledOnce(webex.internal.llm.registerAndConnect);
+            assert.calledOnceWithExactly(webex.internal.llm.setOwnerMeetingId, meeting.id);
+          });
+        });
+
         describe('#clearMeetingData', () => {
           beforeEach(() => {
             webex.internal.llm.isConnected = sinon.stub().returns(true);
@@ -13763,6 +13888,64 @@ describe('plugin-meetings', () => {
             assert.notCalled(meeting.stopTranscription);
             assert.notCalled(meeting.annotation.deregisterEvents);
           });
+
+          describe('ownership tag', () => {
+            beforeEach(() => {
+              webex.internal.llm.getOwnerMeetingId = sinon.stub();
+            });
+
+            it('skips disconnectLLM but still removes this meeting listeners when another meeting owns the LLM', async () => {
+              webex.internal.llm.getOwnerMeetingId.returns('some-other-meeting-id');
+
+              await meeting.clearMeetingData();
+
+              assert.notCalled(webex.internal.llm.disconnectLLM);
+              // Shared data-channel auth tokens belong to the owner meeting's
+              // live LLM session and must not be wiped by a non-owner
+              // teardown, otherwise the owner's next reconnect would lose
+              // its Data-Channel-Auth-Token.
+              assert.notCalled(meeting.clearDataChannelToken);
+              // Listeners owned by *this* Meeting instance must still be
+              // removed so a leaving subordinate meeting stops receiving
+              // relay/locus events from the shared singleton.
+              assert.calledWithExactly(webex.internal.llm.off, 'online', meeting.handleLLMOnline);
+              assert.calledWithExactly(
+                webex.internal.llm.off,
+                'event:relay.event',
+                meeting.processRelayEvent
+              );
+              assert.calledWithExactly(
+                webex.internal.llm.off,
+                'event:locus.state_message',
+                meeting.processLocusLLMEvent
+              );
+              assert.calledOnce(meeting.clearLLMHealthCheckTimer);
+            });
+
+            it('calls disconnectLLM and clears data channel token when this meeting is the owner', async () => {
+              webex.internal.llm.getOwnerMeetingId.returns(meeting.id);
+
+              await meeting.clearMeetingData();
+
+              assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
+                code: 3050,
+                reason: 'done (permanent)',
+              });
+              assert.calledOnce(meeting.clearDataChannelToken);
+            });
+
+            it('calls disconnectLLM and clears data channel token when no owner is recorded (first-claim / legacy)', async () => {
+              webex.internal.llm.getOwnerMeetingId.returns(undefined);
+
+              await meeting.clearMeetingData();
+
+              assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
+                code: 3050,
+                reason: 'done (permanent)',
+              });
+              assert.calledOnce(meeting.clearDataChannelToken);
+            });
+          });
         });
       });
 

package/test/unit/spec/webinar/index.ts

@@ -176,6 +176,42 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#getValidatedWebinarMeeting', () => {
+      it('returns the meeting when its locusUrl matches the webinar locusUrl', () => {
+        const meeting = {locusUrl: 'locusUrl'};
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        webinar.locusUrl = 'locusUrl';
+
+        assert.equal(webinar.getValidatedWebinarMeeting(), meeting);
+      });
+
+      it('returns undefined and warns when the resolved meeting locusUrl does not match', () => {
+        const warnStub = sinon.stub(LoggerProxy.logger, 'warn');
+        const meeting = {locusUrl: 'other-locus-url'};
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        webinar.locusUrl = 'locusUrl';
+
+        assert.isUndefined(webinar.getValidatedWebinarMeeting());
+        assert.calledOnce(warnStub);
+      });
+
+      it('returns undefined when no meeting is resolved', () => {
+        webex.meetings.getMeetingByType = sinon.stub().returns(undefined);
+
+        assert.isUndefined(webinar.getValidatedWebinarMeeting());
+      });
+
+      it('returns undefined and warns when webinar locusUrl is not yet initialized', () => {
+        const warnStub = sinon.stub(LoggerProxy.logger, 'warn');
+        const meeting = {locusUrl: 'some-url'};
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        webinar.locusUrl = undefined;
+
+        assert.isUndefined(webinar.getValidatedWebinarMeeting());
+        assert.calledOnce(warnStub);
+      });
+    });
+
     describe('#cleanUp', () => {
       it('delegates to cleanupPSDataChannel', () => {
         const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
@@ -187,17 +223,14 @@ describe('plugin-meetings', () => {
     });
 
     describe('#cleanupPSDataChannel', () => {
-      let meeting;
+      let relayListener;
 
       beforeEach(() => {
-        meeting = {
-          processRelayEvent: sinon.stub(),
-        };
-
-        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        relayListener = sinon.stub();
+        webinar._practiceSessionRelayListener = relayListener;
       });
 
-      it('disconnects the practice session channel and removes the relay listener', async () => {
+      it('disconnects the practice session channel and removes the tracked relay listener', async () => {
         await webinar.cleanupPSDataChannel();
 
         assert.calledOnceWithExactly(
@@ -208,8 +241,28 @@ describe('plugin-meetings', () => {
         assert.calledOnceWithExactly(
           webex.internal.llm.off,
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting.processRelayEvent
+          relayListener
         );
+        assert.isNull(webinar._practiceSessionRelayListener);
+      });
+
+      it('skips relay listener removal when no listener has been tracked', async () => {
+        webinar._practiceSessionRelayListener = null;
+
+        await webinar.cleanupPSDataChannel();
+
+        const relayOffCalls = webex.internal.llm.off.args.filter(
+          ([event]) => event === `event:relay.event:${LLM_PRACTICE_SESSION}`
+        );
+        assert.equal(relayOffCalls.length, 0);
+      });
+
+      it('does not consult the meeting collection during cleanup', async () => {
+        webex.meetings.getMeetingByType = sinon.stub();
+
+        await webinar.cleanupPSDataChannel();
+
+        assert.notCalled(webex.meetings.getMeetingByType);
       });
 
       it('removes a pending online listener if one exists', async () => {
@@ -240,6 +293,7 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         processRelayEvent = sinon.stub();
         meeting = {
+          locusUrl: 'locusUrl',
           isJoined: sinon.stub().returns(true),
           processRelayEvent,
           locusInfo: {
@@ -418,19 +472,30 @@ describe('plugin-meetings', () => {
         assert.calledOnce(webex.internal.llm.registerAndConnect);
       });
 
-      it('rebinds relay listener after successful connect', async () => {
+      it('tracks and binds the relay listener after successful connect', async () => {
         await webinar.updatePSDataChannel();
 
+        // Stores the exact listener reference for deterministic cleanup
+        assert.equal(webinar._practiceSessionRelayListener, processRelayEvent);
         assert.calledWith(
-          webex.internal.llm.off,
+          webex.internal.llm.on,
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
           processRelayEvent
         );
+      });
+
+      it('removes a previously tracked relay listener before re-binding on reconnect', async () => {
+        const previousListener = sinon.stub();
+        webinar._practiceSessionRelayListener = previousListener;
+
+        await webinar.updatePSDataChannel();
+
         assert.calledWith(
-          webex.internal.llm.on,
+          webex.internal.llm.off,
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          processRelayEvent
+          previousListener
         );
+        assert.equal(webinar._practiceSessionRelayListener, processRelayEvent);
       });
 
       it('subscribes to transcription when caption intent is enabled', async () => {
@@ -551,7 +616,7 @@ describe('plugin-meetings', () => {
           updateMediaShares = sinon.stub()
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               isJoined: sinon.stub().returns(false),
               updateLLMConnection: sinon.stub(),
               shareStatus: SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE,
@@ -606,7 +671,7 @@ describe('plugin-meetings', () => {
 
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               isJoined: sinon.stub().returns(false),
               updateLLMConnection: sinon.stub(),
               shareStatus: SHARE_STATUS.REMOTE_SHARE_ACTIVE,
@@ -1034,7 +1099,7 @@ describe('plugin-meetings', () => {
           // @ts-ignore
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               locusInfo: {
                 links:{
                   resources: {
@@ -1051,7 +1116,7 @@ describe('plugin-meetings', () => {
         it('throws an error if attendeeSearchUrl is not available', async () => {
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               locusInfo: {
                 links:{
                   resources: {