@webex/plugin-meetings 3.11.0-next.4 → 3.11.0-next.6

package/dist/types/meeting/util.d.ts

@@ -2,6 +2,31 @@ import { LocalCameraStream, LocalMicrophoneStream } from '@webex/media-helpers';
 import { SELF_POLICY, IP_VERSION } from '../constants';
 declare const MeetingUtil: {
     parseLocusJoin: (response: any) => any;
+    /**
+     * Sanitizes a WebSocket URL by extracting only protocol, host, and pathname
+     * Returns concatenated protocol + host + pathname for safe logging
+     * @param {string} urlString - The URL to sanitize
+     * @returns {string} Sanitized URL or empty string if parsing fails
+     */
+    sanitizeWebSocketUrl: (urlString: string) => string;
+    /**
+     * Compares two URLs by protocol, host, and pathname (ignoring query params and hash)
+     * Uses sanitizeWebSocketUrl to ensure comparison matches what gets reported
+     * @param {string} url1 - First URL to compare
+     * @param {string} url2 - Second URL to compare
+     * @returns {boolean} True if URLs match, false otherwise
+     */
+    _urlsMatch: (url1: string, url2: string) => boolean;
+    /**
+     * Gets socket URL information for metrics, including whether the socket URLs match
+     * @param {Object} webex - The webex instance
+     * @returns {Object} Object with hasMismatchedSocket, mercurySocketUrl, and deviceSocketUrl properties
+     */
+    getSocketUrlInfo: (webex: any) => {
+        hasMismatchedSocket: boolean;
+        mercurySocketUrl: string;
+        deviceSocketUrl: string;
+    };
     remoteUpdateAudioVideo: (meeting: any, audioMuted?: boolean, videoMuted?: boolean) => any;
     hasOwner: (info: any) => any;
     isOwnerSelf: (owner: any, selfId: any) => boolean;

package/dist/webinar/index.js

@@ -506,7 +506,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee8);
     }))();
   },
-  version: "3.11.0-next.4"
+  version: "3.11.0-next.6"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -93,5 +93,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.11.0-next.4"
+  "version": "3.11.0-next.6"
 }

package/src/meeting/util.ts

@@ -1,4 +1,5 @@
 import {LocalCameraStream, LocalMicrophoneStream} from '@webex/media-helpers';
+import url from 'url';
 
 import {cloneDeep} from 'lodash';
 import {MeetingNotActiveError, UserNotJoinedError} from '../common/errors/webex-errors';
@@ -47,6 +48,111 @@ const MeetingUtil = {
     return parsed;
   },
 
+  /**
+   * Sanitizes a WebSocket URL by extracting only protocol, host, and pathname
+   * Returns concatenated protocol + host + pathname for safe logging
+   * @param {string} urlString - The URL to sanitize
+   * @returns {string} Sanitized URL or empty string if parsing fails
+   */
+  sanitizeWebSocketUrl: (urlString: string): string => {
+    if (!urlString || typeof urlString !== 'string') {
+      return '';
+    }
+
+    try {
+      const parsedUrl = url.parse(urlString);
+      const protocol = parsedUrl.protocol || '';
+      const host = parsedUrl.host || '';
+
+      // If we don't have at least protocol and host, it's not a valid URL
+      if (!protocol || !host) {
+        return '';
+      }
+
+      const pathname = parsedUrl.pathname || '';
+
+      // Strip trailing slash if pathname is just '/'
+      const normalizedPathname = pathname === '/' ? '' : pathname;
+
+      return `${protocol}//${host}${normalizedPathname}`;
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Meeting:util#sanitizeWebSocketUrl --> unable to parse URL: ${error}`
+      );
+
+      return '';
+    }
+  },
+
+  /**
+   * Compares two URLs by protocol, host, and pathname (ignoring query params and hash)
+   * Uses sanitizeWebSocketUrl to ensure comparison matches what gets reported
+   * @param {string} url1 - First URL to compare
+   * @param {string} url2 - Second URL to compare
+   * @returns {boolean} True if URLs match, false otherwise
+   */
+  _urlsMatch: (url1: string, url2: string): boolean => {
+    if (!url1 || !url2) {
+      return false;
+    }
+
+    try {
+      const sanitized1 = MeetingUtil.sanitizeWebSocketUrl(url1);
+      const sanitized2 = MeetingUtil.sanitizeWebSocketUrl(url2);
+
+      // If either failed to parse (empty string), they don't match
+      if (!sanitized1 || !sanitized2) {
+        return false;
+      }
+
+      return sanitized1 === sanitized2;
+    } catch (e) {
+      LoggerProxy.logger.warn('Meeting:util#_urlsMatch --> error comparing URLs', e);
+
+      return false;
+    }
+  },
+
+  /**
+   * Gets socket URL information for metrics, including whether the socket URLs match
+   * @param {Object} webex - The webex instance
+   * @returns {Object} Object with hasMismatchedSocket, mercurySocketUrl, and deviceSocketUrl properties
+   */
+  getSocketUrlInfo: (
+    webex: any
+  ): {hasMismatchedSocket: boolean; mercurySocketUrl: string; deviceSocketUrl: string} => {
+    try {
+      const mercuryUrl = webex?.internal?.mercury?.socket?.url;
+      const deviceUrl = webex?.internal?.device?.webSocketUrl;
+
+      const sanitizedMercuryUrl = MeetingUtil.sanitizeWebSocketUrl(mercuryUrl);
+      const sanitizedDeviceUrl = MeetingUtil.sanitizeWebSocketUrl(deviceUrl);
+
+      // Only report a mismatch if both URLs are present and they don't match
+      // If either URL is missing, we can't determine if there's a mismatch, so return false
+      let hasMismatchedSocket = false;
+      if (sanitizedMercuryUrl && sanitizedDeviceUrl) {
+        hasMismatchedSocket = !MeetingUtil._urlsMatch(mercuryUrl, deviceUrl);
+      }
+
+      return {
+        hasMismatchedSocket,
+        mercurySocketUrl: sanitizedMercuryUrl,
+        deviceSocketUrl: sanitizedDeviceUrl,
+      };
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Meeting:util#getSocketUrlInfo --> error getting socket URL info: ${error}`
+      );
+
+      return {
+        hasMismatchedSocket: false,
+        mercurySocketUrl: '',
+        deviceSocketUrl: '',
+      };
+    }
+  },
+
   remoteUpdateAudioVideo: (meeting, audioMuted?: boolean, videoMuted?: boolean) => {
     if (!meeting) {
       return Promise.reject(new ParameterError('You need a meeting object.'));
@@ -203,6 +309,7 @@ const MeetingUtil = {
         const parsed = MeetingUtil.parseLocusJoin(res);
         meeting.setLocus(parsed);
         meeting.isoLocalClientMeetingJoinTime = res?.headers?.date; // read from header if exist, else fall back to system clock : https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-555657
+        const socketUrlInfo = MeetingUtil.getSocketUrlInfo(webex);
         webex.internal.newMetrics.submitClientEvent({
           name: 'client.locus.join.response',
           payload: {
@@ -210,6 +317,9 @@ const MeetingUtil = {
             identifiers: {
               trackingId: res.headers.trackingid,
             },
+            eventData: {
+              ...socketUrlInfo,
+            },
           },
           options: {
             meetingId: meeting.id,
@@ -220,12 +330,19 @@ const MeetingUtil = {
         return parsed;
       })
       .catch((err) => {
+        const socketUrlInfo = MeetingUtil.getSocketUrlInfo(webex);
         webex.internal.newMetrics.submitClientEvent({
           name: 'client.locus.join.response',
           payload: {
             identifiers: {meetingLookupUrl: meeting.meetingInfo?.meetingLookupUrl},
+            eventData: {
+              ...socketUrlInfo,
+            },
+          },
+          options: {
+            meetingId: meeting.id,
+            rawError: err,
           },
-          options: {meetingId: meeting.id, rawError: err},
         });
 
         throw err;

package/src/meetings/index.ts

@@ -1047,11 +1047,7 @@ export default class Meetings extends WebexPlugin {
     return (
       // @ts-ignore
       this.webex.internal.mercury
-        // Use code 3050 with a non-reconnecting reason to prevent Mercury auto-reconnect
-        // during unregister. Without this, disconnect() defaults to code 1000/"Done" which
-        // force-closes as "Done (forced)" - a normalReconnectReason that triggers auto-reconnect,
-        // causing a race condition with device.unregister().
-        .disconnect({code: 3050, reason: 'meetings unregister'})
+        .disconnect()
         // @ts-ignore
         .then(() => this.webex.internal.device.unregister())
         .catch((error) => {

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

@@ -61,8 +61,9 @@ describe('plugin-meetings', () => {
       meeting.trigger = sinon.stub();
       meeting.webex = webex;
       meeting.webex.internal.newMetrics.callDiagnosticMetrics =
-      meeting.webex.internal.newMetrics.callDiagnosticMetrics || {};
-      meeting.webex.internal.newMetrics.callDiagnosticMetrics.clearEventLimitsForCorrelationId = sinon.stub();
+        meeting.webex.internal.newMetrics.callDiagnosticMetrics || {};
+      meeting.webex.internal.newMetrics.callDiagnosticMetrics.clearEventLimitsForCorrelationId =
+        sinon.stub();
     });
 
     afterEach(() => {
@@ -245,7 +246,11 @@ describe('plugin-meetings', () => {
         const response = MeetingUtil.updateLocusFromApiResponse(meeting, originalResponse);
 
         assert.deepEqual(response, originalResponse);
-        assert.calledOnceWithExactly(meeting.locusInfo.handleLocusAPIResponse, meeting, originalResponse.body);
+        assert.calledOnceWithExactly(
+          meeting.locusInfo.handleLocusAPIResponse,
+          meeting,
+          originalResponse.body
+        );
       });
 
       it('should handle locus being missing from the response', () => {
@@ -361,8 +366,8 @@ describe('plugin-meetings', () => {
     describe('remoteUpdateAudioVideo', () => {
       it('#Should call meetingRequest.locusMediaRequest with correct parameters and return the full response', async () => {
         const fakeResponse = {
-          body: { locus: { url: 'locusUrl'}},
-          headers: { },
+          body: {locus: {url: 'locusUrl'}},
+          headers: {},
         };
         const meeting = {
           id: 'meeting-id',
@@ -480,6 +485,11 @@ describe('plugin-meetings', () => {
             identifiers: {
               trackingId: 'trackingId',
             },
+            eventData: {
+              hasMismatchedSocket: false,
+              mercurySocketUrl: '',
+              deviceSocketUrl: 'ws://example.com',
+            },
           },
           options: {
             meetingId: meeting.id,
@@ -649,21 +659,26 @@ describe('plugin-meetings', () => {
       it('should post client event with error when join fails', async () => {
         const joinError = new Error('Join failed');
         meeting.meetingRequest.joinMeeting.rejects(joinError);
-        meeting.meetingInfo = { meetingLookupUrl: 'test-lookup-url' };
+        meeting.meetingInfo = {meetingLookupUrl: 'test-lookup-url'};
 
         try {
           await MeetingUtil.joinMeeting(meeting, {});
           assert.fail('Expected joinMeeting to throw an error');
         } catch (error) {
           assert.equal(error, joinError);
-          
+
           // Verify error client event was submitted
           assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
             name: 'client.locus.join.response',
             payload: {
-              identifiers: { meetingLookupUrl: 'test-lookup-url' },
+              identifiers: {meetingLookupUrl: 'test-lookup-url'},
+              eventData: {
+                hasMismatchedSocket: false,
+                mercurySocketUrl: '',
+                deviceSocketUrl: 'ws://example.com',
+              },
             },
-            options: { meetingId: meeting.id, rawError: joinError },
+            options: {meetingId: meeting.id, rawError: joinError},
           });
         }
       });
@@ -721,7 +736,7 @@ describe('plugin-meetings', () => {
           assert.fail('Expected joinMeetingOptions to throw PasswordError');
         } catch (error) {
           assert.instanceOf(error, PasswordError);
-          
+
           // Verify client event was submitted with error details
           assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
             name: 'client.meetinginfo.response',
@@ -759,7 +774,7 @@ describe('plugin-meetings', () => {
           assert.fail('Expected joinMeetingOptions to throw CaptchaError');
         } catch (error) {
           assert.instanceOf(error, CaptchaError);
-          
+
           // Verify client event was submitted with error details
           assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
             name: 'client.meetinginfo.response',
@@ -972,15 +987,18 @@ describe('plugin-meetings', () => {
       {functionName: 'canStartManualCaption', displayHint: 'MANUAL_CAPTION_START'},
       {functionName: 'canStopManualCaption', displayHint: 'MANUAL_CAPTION_STOP'},
 
-      {functionName: 'isLocalRecordingStarted',displayHint:'LOCAL_RECORDING_STATUS_STARTED'},
+      {functionName: 'isLocalRecordingStarted', displayHint: 'LOCAL_RECORDING_STATUS_STARTED'},
       {functionName: 'isLocalRecordingStopped', displayHint: 'LOCAL_RECORDING_STATUS_STOPPED'},
       {functionName: 'isLocalRecordingPaused', displayHint: 'LOCAL_RECORDING_STATUS_PAUSED'},
-      {functionName: 'isLocalStreamingStarted',displayHint:'STREAMING_STATUS_STARTED'},
+      {functionName: 'isLocalStreamingStarted', displayHint: 'STREAMING_STATUS_STARTED'},
       {functionName: 'isLocalStreamingStopped', displayHint: 'STREAMING_STATUS_STOPPED'},
 
       {functionName: 'isManualCaptionActive', displayHint: 'MANUAL_CAPTION_STATUS_ACTIVE'},
 
-      {functionName: 'isSpokenLanguageAutoDetectionEnabled', displayHint: 'SPOKEN_LANGUAGE_AUTO_DETECTION_ENABLED'},
+      {
+        functionName: 'isSpokenLanguageAutoDetectionEnabled',
+        displayHint: 'SPOKEN_LANGUAGE_AUTO_DETECTION_ENABLED',
+      },
 
       {functionName: 'isWebexAssistantActive', displayHint: 'WEBEX_ASSISTANT_STATUS_ACTIVE'},
       {functionName: 'canViewCaptionPanel', displayHint: 'ENABLE_CAPTION_PANEL'},
@@ -1447,10 +1465,7 @@ describe('plugin-meetings', () => {
               },
             },
             dataSets: [{name: 'dataset1', url: 'http://dataset.com'}],
-            mediaConnections: [
-              {mediaId: 'mediaId456'},
-              {someOtherField: 'value'},
-            ],
+            mediaConnections: [{mediaId: 'mediaId456'}, {someOtherField: 'value'}],
           },
         };
       });
@@ -1500,15 +1515,249 @@ describe('plugin-meetings', () => {
       });
 
       it('handles mediaConnections without mediaId', () => {
-        response.body.mediaConnections = [
-          {someField: 'value1'},
-          {anotherField: 'value2'},
-        ];
+        response.body.mediaConnections = [{someField: 'value1'}, {anotherField: 'value2'}];
 
         const result = MeetingUtil.parseLocusJoin(response);
 
         assert.isUndefined(result.mediaId);
       });
     });
+
+    describe('#sanitizeWebSocketUrl', () => {
+      it('extracts protocol, host, and pathname from URL', () => {
+        const url = 'wss://example.com:443/mercury/path?token=secret&key=value#fragment';
+        const result = MeetingUtil.sanitizeWebSocketUrl(url);
+
+        assert.equal(result, 'wss://example.com:443/mercury/path');
+      });
+
+      it('handles URL without query string or hash', () => {
+        const url = 'wss://example.com/path';
+        const result = MeetingUtil.sanitizeWebSocketUrl(url);
+
+        assert.equal(result, 'wss://example.com/path');
+      });
+
+      it('removes authentication from URL', () => {
+        const url = 'wss://user:password@example.com/path?token=secret';
+        const result = MeetingUtil.sanitizeWebSocketUrl(url);
+
+        assert.equal(result, 'wss://example.com/path');
+      });
+
+      it('returns empty string for null or undefined', () => {
+        assert.equal(MeetingUtil.sanitizeWebSocketUrl(null), '');
+        assert.equal(MeetingUtil.sanitizeWebSocketUrl(undefined), '');
+      });
+
+      it('returns empty string for non-string input', () => {
+        assert.equal(MeetingUtil.sanitizeWebSocketUrl(123), '');
+        assert.equal(MeetingUtil.sanitizeWebSocketUrl({}), '');
+      });
+
+      it('returns empty string for invalid URL', () => {
+        const result = MeetingUtil.sanitizeWebSocketUrl('not a valid url');
+
+        assert.equal(result, '');
+      });
+
+      it('handles URL without pathname', () => {
+        const url = 'wss://example.com?query=value';
+        const result = MeetingUtil.sanitizeWebSocketUrl(url);
+
+        assert.equal(result, 'wss://example.com');
+      });
+    });
+
+    describe('#_urlsMatch', () => {
+      it('returns true when URLs match (ignoring query and hash)', () => {
+        const url1 = 'wss://example.com:443/path?token=abc#fragment1';
+        const url2 = 'wss://example.com:443/path?token=xyz#fragment2';
+
+        assert.isTrue(MeetingUtil._urlsMatch(url1, url2));
+      });
+
+      it('returns false when protocols differ', () => {
+        const url1 = 'wss://example.com/path';
+        const url2 = 'ws://example.com/path';
+
+        assert.isFalse(MeetingUtil._urlsMatch(url1, url2));
+      });
+
+      it('returns false when hosts differ', () => {
+        const url1 = 'wss://example1.com/path';
+        const url2 = 'wss://example2.com/path';
+
+        assert.isFalse(MeetingUtil._urlsMatch(url1, url2));
+      });
+
+      it('returns false when ports differ', () => {
+        const url1 = 'wss://example.com:443/path';
+        const url2 = 'wss://example.com:8443/path';
+
+        assert.isFalse(MeetingUtil._urlsMatch(url1, url2));
+      });
+
+      it('returns false when pathnames differ', () => {
+        const url1 = 'wss://example.com/path1';
+        const url2 = 'wss://example.com/path2';
+
+        assert.isFalse(MeetingUtil._urlsMatch(url1, url2));
+      });
+
+      it('returns false when either URL is null or undefined', () => {
+        const url = 'wss://example.com/path';
+
+        assert.isFalse(MeetingUtil._urlsMatch(null, url));
+        assert.isFalse(MeetingUtil._urlsMatch(url, null));
+        assert.isFalse(MeetingUtil._urlsMatch(undefined, url));
+        assert.isFalse(MeetingUtil._urlsMatch(url, undefined));
+      });
+
+      it('returns false when both URLs are null', () => {
+        assert.isFalse(MeetingUtil._urlsMatch(null, null));
+      });
+
+      it('returns false when URL parsing fails', () => {
+        const url1 = 'invalid url';
+        const url2 = 'wss://example.com/path';
+
+        assert.isFalse(MeetingUtil._urlsMatch(url1, url2));
+      });
+
+      it('compares URLs case-sensitively', () => {
+        const url1 = 'wss://Example.com/path';
+        const url2 = 'wss://example.com/path';
+
+        // URL parsing should handle host case-sensitivity
+        assert.isTrue(MeetingUtil._urlsMatch(url1, url2));
+      });
+    });
+
+    describe('#getSocketUrlInfo', () => {
+      it('returns socket URL info when URLs differ', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {
+                url: 'wss://mercury.example.com:443/path?token=abc',
+              },
+            },
+            device: {
+              webSocketUrl: 'wss://device.example.com:443/path?token=xyz',
+            },
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isTrue(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, 'wss://mercury.example.com:443/path');
+        assert.equal(result.deviceSocketUrl, 'wss://device.example.com:443/path');
+      });
+
+      it('returns socket URL info when URLs match', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {
+                url: 'wss://example.com:443/path?token=abc',
+              },
+            },
+            device: {
+              webSocketUrl: 'wss://example.com:443/path?token=xyz',
+            },
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, 'wss://example.com:443/path');
+        assert.equal(result.deviceSocketUrl, 'wss://example.com:443/path');
+      });
+
+      it('returns false for hasMismatchedSocket when mercury socket URL is missing', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {},
+            },
+            device: {
+              webSocketUrl: 'wss://device.example.com:443/path',
+            },
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, '');
+        assert.equal(result.deviceSocketUrl, 'wss://device.example.com:443/path');
+      });
+
+      it('returns false for hasMismatchedSocket when device socket URL is missing', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {
+                url: 'wss://mercury.example.com:443/path',
+              },
+            },
+            device: {},
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, 'wss://mercury.example.com:443/path');
+        assert.equal(result.deviceSocketUrl, '');
+      });
+
+      it('returns default values when webex object is missing properties', () => {
+        const testWebex = {
+          internal: {},
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, '');
+        assert.equal(result.deviceSocketUrl, '');
+      });
+
+      it('handles error gracefully and returns default values', () => {
+        const testWebex = null;
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.isFalse(result.hasMismatchedSocket);
+        assert.equal(result.mercurySocketUrl, '');
+        assert.equal(result.deviceSocketUrl, '');
+      });
+
+      it('sanitizes URLs by removing query parameters', () => {
+        const testWebex = {
+          internal: {
+            mercury: {
+              socket: {
+                url: 'wss://mercury.example.com/path?secret=token123&key=value',
+              },
+            },
+            device: {
+              webSocketUrl: 'wss://device.example.com/path?secret=differenttoken&key=value',
+            },
+          },
+        };
+
+        const result = MeetingUtil.getSocketUrlInfo(testWebex);
+
+        assert.notInclude(result.mercurySocketUrl, 'secret');
+        assert.notInclude(result.mercurySocketUrl, 'token123');
+        assert.notInclude(result.deviceSocketUrl, 'secret');
+        assert.notInclude(result.deviceSocketUrl, 'differenttoken');
+      });
+    });
   });
 });