@webex/plugin-meetings 3.12.0-next.7 → 3.12.0-next.70

package/src/webinar/index.ts

@@ -4,7 +4,6 @@
 import {WebexPlugin, config} from '@webex/webex-core';
 import uuid from 'uuid';
 import {get} from 'lodash';
-import {DataChannelTokenType} from '@webex/internal-plugin-llm';
 import {
   _ID_,
   HEADERS,
@@ -14,12 +13,27 @@ import {
   SHARE_STATUS,
   DEFAULT_LARGE_SCALE_WEBINAR_ATTENDEE_SEARCH_LIMIT,
   LLM_PRACTICE_SESSION,
+  LOCUS_LLM_EVENT,
 } from '../constants';
 
 import WebinarCollection from './collection';
 import LoggerProxy from '../common/logs/logger-proxy';
+import MeetingUtil from '../meeting/util';
 import {sanitizeParams} from './utils';
 
+const PS_LLM_EVENTS = [
+  {
+    event: `event:relay.event:${LLM_PRACTICE_SESSION}`,
+    listenerKey: 'relay',
+    handlerKey: 'processRelayEvent',
+  },
+  {
+    event: `${LOCUS_LLM_EVENT}:${LLM_PRACTICE_SESSION}`,
+    listenerKey: 'locusLLM',
+    handlerKey: 'processLocusLLMEvent',
+  },
+];
+
 /**
  * @class Webinar
  */
@@ -98,13 +112,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,34 +178,73 @@ 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() {
+    const {isOwner} = this.webex.internal.llm.resolveSessionOwnership(
+      this.meetingId,
+      LLM_PRACTICE_SESSION
+    );
+    this.llmListeners = this.llmListeners || {};
+
     if (this._pendingOnlineListener) {
       // @ts-ignore - Fix type
       this.webex.internal.llm.off('online', this._pendingOnlineListener);
       this._pendingOnlineListener = null;
     }
 
-    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+    try {
+      // @ts-ignore - Fix type
+      const disconnected = await this.webex.internal.llm.disconnectLLM(
+        {
+          code: 3050,
+          reason: 'done (permanent)',
+        },
+        LLM_PRACTICE_SESSION,
+        this.meetingId
+      );
 
-    // @ts-ignore - Fix type
-    await this.webex.internal.llm.disconnectLLM(
-      {
-        code: 3050,
-        reason: 'done (permanent)',
-      },
-      LLM_PRACTICE_SESSION
-    );
-    // @ts-ignore - Fix type
-    this.webex.internal.llm.off(
-      `event:relay.event:${LLM_PRACTICE_SESSION}`,
-      meeting?.processRelayEvent
-    );
+      if (!disconnected) {
+        LoggerProxy.logger.info(
+          `Webinar:index#cleanupPSDataChannel --> skipping disconnect; practice-session LLM is not owned by meeting ${this.meetingId}`
+        );
+      }
+    } catch (error) {
+      // disconnectLLM clears ownership only on success; release a stale owner
+      // tag here so other meeting instances can reclaim practice-session LLM.
+      if (isOwner) {
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.setOwnerMeetingId?.(undefined, LLM_PRACTICE_SESSION);
+      }
+
+      throw error;
+    } finally {
+      if (this._practiceSessionRelayListener) {
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.off(
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          this._practiceSessionRelayListener
+        );
+      }
+      this._practiceSessionRelayListener = null;
+
+      for (const {event, listenerKey} of PS_LLM_EVENTS) {
+        if (this.llmListeners[listenerKey]) {
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.off(event, this.llmListeners[listenerKey]);
+          this.llmListeners[listenerKey] = 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>}
    */
@@ -169,7 +258,8 @@ const Webinar = WebexPlugin.extend({
 
     // @ts-ignore
     const cachedToken = this.webex.internal.llm.getDatachannelToken(
-      DataChannelTokenType.PracticeSession
+      LLM_PRACTICE_SESSION,
+      this.meetingId
     );
 
     if (cachedToken) {
@@ -187,7 +277,8 @@ const Webinar = WebexPlugin.extend({
       // @ts-ignore
       this.webex.internal.llm.setDatachannelToken(
         datachannelToken,
-        dataChannelTokenType || DataChannelTokenType.PracticeSession
+        dataChannelTokenType || LLM_PRACTICE_SESSION,
+        this.meetingId
       );
 
       return datachannelToken;
@@ -208,11 +299,17 @@ const Webinar = WebexPlugin.extend({
    * @returns {Promise}
    */
   async updatePSDataChannel() {
+    this.llmListeners = this.llmListeners || {};
+
     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();
+    const {currentOwner, isOwner} = this.webex.internal.llm.resolveSessionOwnership(
+      this.meetingId,
+      LLM_PRACTICE_SESSION
+    );
 
     if (!isPracticeSession) {
       await this.cleanupPSDataChannel();
@@ -220,13 +317,22 @@ const Webinar = WebexPlugin.extend({
       return undefined;
     }
 
+    if (!isOwner) {
+      LoggerProxy.logger.info(
+        `Webinar:index#updatePSDataChannel --> skipping; practice-session LLM owned by meeting ${currentOwner}, not ${this.meetingId}`
+      );
+
+      return undefined;
+    }
+
     // @ts-ignore - Fix type
     const {url = undefined, info: {practiceSessionDatachannelUrl = undefined} = {}} =
       meeting?.locusInfo || {};
 
     // @ts-ignore
     let practiceSessionDatachannelToken = this.webex.internal.llm.getDatachannelToken(
-      DataChannelTokenType.PracticeSession
+      LLM_PRACTICE_SESSION,
+      this.meetingId
     );
 
     const isCaptionBoxOn = this.webex.internal.voicea.getIsCaptionBoxOn();
@@ -303,6 +409,30 @@ const Webinar = WebexPlugin.extend({
       practiceSessionDatachannelToken = refreshedPracticeSessionToken;
     }
 
+    const {currentOwner: currentOwnerBeforeConnect, isOwner: isOwnerBeforeConnect} =
+      this.webex.internal.llm.resolveSessionOwnership(this.meetingId, LLM_PRACTICE_SESSION);
+
+    if (!isOwnerBeforeConnect) {
+      LoggerProxy.logger.info(
+        `Webinar:index#updatePSDataChannel --> skipping pre-connect owner write; practice-session LLM owned by meeting ${currentOwnerBeforeConnect}, not ${this.meetingId}`
+      );
+
+      return undefined;
+    }
+
+    // Ensure refresh for practice datachannel requests is routed to this
+    // meeting only when we are actually about to connect the practice session.
+    // This avoids claiming ownership in flows that return early (e.g. missing
+    // practiceSessionDatachannelUrl or waiting for default session online).
+    // @ts-ignore - Fix type
+    this.webex.internal.llm.setRefreshHandler(
+      () => meeting.refreshDataChannelToken(),
+      LLM_PRACTICE_SESSION,
+      this.meetingId
+    );
+    // @ts-ignore - Fix type
+    this.webex.internal.llm.setOwnerMeetingId?.(this.meetingId, LLM_PRACTICE_SESSION);
+
     // @ts-ignore - Fix type
     return this.webex.internal.llm
       .registerAndConnect(
@@ -312,16 +442,30 @@ 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
-        );
-        // @ts-ignore - Fix type
-        this.webex.internal.llm.on(
-          `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting?.processRelayEvent
-        );
+        const {currentOwner: currentOwnerAfterConnect, isOwner: isOwnerAfterConnect} =
+          this.webex.internal.llm.resolveSessionOwnership(this.meetingId, LLM_PRACTICE_SESSION);
+
+        if (this.meetingId && isOwnerAfterConnect) {
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.setOwnerMeetingId?.(this.meetingId, LLM_PRACTICE_SESSION);
+        } else {
+          LoggerProxy.logger.info(
+            `Webinar:index#updatePSDataChannel --> skipping post-connect owner write; practice-session LLM owned by meeting ${currentOwnerAfterConnect}, not ${this.meetingId}`
+          );
+        }
+
+        // Track the exact listener references so cleanupPSDataChannel can
+        // unsubscribe deterministically, even if the meeting can no longer
+        // be resolved at cleanup time.
+        for (const {event, listenerKey, handlerKey} of PS_LLM_EVENTS) {
+          if (this.llmListeners[listenerKey]) {
+            // @ts-ignore - Fix type
+            this.webex.internal.llm.off(event, this.llmListeners[listenerKey]);
+          }
+          this.llmListeners[listenerKey] = meeting?.[handlerKey];
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.on(event, this.llmListeners[listenerKey]);
+        }
         // @ts-ignore - Fix type
         this.webex.internal.voicea?.announce?.();
         if (isCaptionBoxOn) {
@@ -332,6 +476,23 @@ const Webinar = WebexPlugin.extend({
         );
 
         return Promise.resolve(registerAndConnectResult);
+      })
+      .catch((error) => {
+        const {
+          currentOwner: currentOwnerAfterRegisterFailure,
+          isOwner: isOwnerAfterRegisterFailure,
+        } = this.webex.internal.llm.resolveSessionOwnership(this.meetingId, LLM_PRACTICE_SESSION);
+
+        if (isOwnerAfterRegisterFailure) {
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.setOwnerMeetingId?.(undefined, LLM_PRACTICE_SESSION);
+        } else {
+          LoggerProxy.logger.info(
+            `Webinar:index#updatePSDataChannel --> skipping failure owner release; practice-session LLM owned by meeting ${currentOwnerAfterRegisterFailure}, not ${this.meetingId}`
+          );
+        }
+
+        throw error;
       });
   },
 
@@ -341,6 +502,8 @@ const Webinar = WebexPlugin.extend({
    * @returns {Promise}
    */
   setPracticeSessionState(enabled) {
+    const meeting = this.getValidatedWebinarMeeting();
+
     return this.request({
       method: HTTP_VERBS.PATCH,
       uri: `${this.locusUrl}/controls`,
@@ -349,10 +512,16 @@ const Webinar = WebexPlugin.extend({
           enabled,
         },
       },
-    }).catch((error) => {
-      LoggerProxy.logger.error('Meeting:webinar#setPracticeSessionState failed', error);
-      throw error;
-    });
+    })
+      .then((response) => {
+        MeetingUtil.updateLocusFromApiResponse(meeting, response);
+
+        return response;
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:webinar#setPracticeSessionState failed', error);
+        throw error;
+      });
   },
 
   /**
@@ -532,7 +701,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 +716,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/aiEnableRequest/index.ts

@@ -55,6 +55,27 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#locusUrlUpdate', () => {
+      it('should update the locusUrl property', () => {
+        const testLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id';
+
+        aiEnableRequest.locusUrlUpdate(testLocusUrl);
+
+        assert.equal(aiEnableRequest.locusUrl, testLocusUrl);
+      });
+
+      it('should handle updating locusUrl multiple times', () => {
+        const firstUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id-1';
+        const secondUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id-2';
+
+        aiEnableRequest.locusUrlUpdate(firstUrl);
+        assert.equal(aiEnableRequest.locusUrl, firstUrl);
+
+        aiEnableRequest.locusUrlUpdate(secondUrl);
+        assert.equal(aiEnableRequest.locusUrl, secondUrl);
+      });
+    });
+
     describe('#selfParticipantIdUpdate', () => {
       it('should update the selfParticipantId property', () => {
         const testSelfParticipantId = 'participant-123';
@@ -254,6 +275,71 @@ describe('plugin-meetings', () => {
         sinon.assert.notCalled(triggerSpy);
       });
 
+      it('should not trigger event when locusUrl does not match', () => {
+        const testLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id';
+        const differentLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/different-id';
+
+        aiEnableRequest.locusUrl = testLocusUrl;
+
+        // Reset the spy after setting locusUrl to avoid counting property change events
+        triggerSpy.resetHistory();
+
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            locusUrl: differentLocusUrl,
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.notCalled(triggerSpy);
+      });
+
+      it('should trigger event when locusUrl matches', () => {
+        const testLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id';
+
+        aiEnableRequest.locusUrl = testLocusUrl;
+
+        // Reset the spy after setting locusUrl to avoid counting property change events
+        triggerSpy.resetHistory();
+
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            locusUrl: testLocusUrl,
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        sinon.assert.calledWith(triggerSpy, AI_ENABLE_REQUEST.EVENTS.APPROVAL_REQUEST_ARRIVED, {
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          isApprover: true,
+          isInitiator: false,
+          initiatorId: testInitiatorId,
+          approverId: testSelfParticipantId,
+          url: testUrl,
+        });
+      });
+
       it('should handle events with different action types', () => {
         aiEnableRequest.listenToApprovalRequests();
 

package/test/unit/spec/breakouts/breakout.ts

@@ -26,6 +26,7 @@ describe('plugin-meetings', () => {
       breakout.sessionId = 'sessionId';
       breakout.sessionType = 'BREAKOUT';
       breakout.url = 'url';
+      breakout.resourceLink = 'resource-link';
       breakout.collection = {
         parent: {
           meetingId: 'activeMeetingId',
@@ -45,6 +46,7 @@ describe('plugin-meetings', () => {
     describe('initialize', () => {
       it('creates the object correctly', () => {
         assert.instanceOf(breakout.breakoutRequest, BreakoutRequest);
+        assert.equal(breakout.resourceLink, 'resource-link');
       });
     });
 
@@ -217,10 +219,14 @@ describe('plugin-meetings', () => {
           locusParticipantsUpdate: sinon.stub(),
         };
 
-        const locusData = {some: 'data'};
+        const locusData = {participants: [{id: 'participant-1'}], sequence: {entries: [123]}};
         const result = breakout.parseRoster(locusData);
 
-        assert.calledOnceWithExactly(breakout.members.locusParticipantsUpdate, locusData);
+        assert.calledOnceWithExactly(breakout.members.locusParticipantsUpdate, {
+          participants: [{id: 'participant-1'}],
+          isReplace: true,
+        });
+        assert.equal(breakout.breakoutRosterLocus, locusData);
         assert.equal(result, undefined);
       });
       it('not call locusParticipantsUpdate if sequence is expired', () => {
@@ -228,7 +234,7 @@ describe('plugin-meetings', () => {
           locusParticipantsUpdate: sinon.stub(),
         };
         breakout.isNeedHandleRoster = sinon.stub().returns(false);
-        const locusData = {some: 'data'};
+        const locusData = {participants: [{id: 'participant-1'}], sequence: {entries: [123]}};
         breakout.parseRoster(locusData);
 
         assert.notCalled(breakout.members.locusParticipantsUpdate);

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

@@ -313,6 +313,7 @@ describe('plugin-meetings', () => {
           groupId: 'groupId',
           sessionType: 'sessionType',
           url: 'url',
+          resourceLink: 'resource-link',
           name: 'name',
           allowBackToMain: true,
           delayCloseTime: 10,
@@ -339,6 +340,7 @@ describe('plugin-meetings', () => {
         assert.equal(breakouts.currentBreakoutSession.current, true);
         assert.equal(breakouts.currentBreakoutSession.sessionType, 'sessionType');
         assert.equal(breakouts.currentBreakoutSession.url, 'url');
+        assert.equal(breakouts.currentBreakoutSession.resourceLink, 'resource-link');
         assert.equal(breakouts.currentBreakoutSession.active, false);
         assert.equal(breakouts.currentBreakoutSession.allowed, false);
         assert.equal(breakouts.currentBreakoutSession.assigned, false);
@@ -1847,6 +1849,53 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#removeFromBreakout', () => {
+      it('should make a POST request with correct body and return the result', async () => {
+        breakouts.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+        breakouts.set('url', 'url');
+        breakouts.set('mainGroupId', 'mainGroupId');
+        breakouts.set('mainSessionId', 'mainSessionId');
+
+        const participants = ['participant1', 'participant2'];
+        const result = await breakouts.removeFromBreakout(participants);
+
+        assert.calledOnceWithExactly(breakouts.request, {
+          method: 'POST',
+          uri: 'url/move',
+          body: {
+            groups: [
+              {
+                id: 'mainGroupId',
+                sessions: [
+                  {
+                    id: 'mainSessionId',
+                    participants,
+                  },
+                ],
+              },
+            ],
+          },
+        });
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+      });
+
+      it('should throw an error if mainGroupId is missing', () => {
+        breakouts.set('mainSessionId', 'mainSessionId');
+        assert.throws(
+          () => breakouts.removeFromBreakout(['participant1']),
+          'Main group ID and session ID must be available to remove participants from breakout'
+        );
+      });
+
+      it('should throw an error if mainSessionId is missing', () => {
+        breakouts.set('mainGroupId', 'mainGroupId');
+        assert.throws(
+          () => breakouts.removeFromBreakout(['participant1']),
+          'Main group ID and session ID must be available to remove participants from breakout'
+        );
+      });
+    });
+
     describe('#triggerReturnToMainEvent', () => {
       const checkTrigger = ({breakout, shouldTrigger}) => {
         breakouts.trigger = sinon.stub();