@webex/plugin-meetings 3.12.0-next.41 → 3.12.0-next.43

package/dist/types/constants.d.ts

@@ -293,6 +293,7 @@ export declare const EVENT_TRIGGERS: {
     MEETING_CAPTION_RECEIVED: string;
     MEETING_PARTICIPANT_REASON_CHANGED: string;
     MEETING_AI_ENABLE_REQUEST: string;
+    MEETING_SRTP_CIPHER_UPDATED: string;
 };
 export declare const EVENT_TYPES: {
     SELF: string;

package/dist/types/media/properties.d.ts

@@ -26,6 +26,7 @@ export default class MediaProperties {
     shareAudioStream?: LocalSystemAudioStream;
     videoDeviceId: any;
     videoStream?: LocalCameraStream;
+    srtpCipher: string | undefined;
     namespace: string;
     mediaIssueCounters: {
         [key: string]: number;

package/dist/webinar/index.js

@@ -723,7 +723,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee1);
     }))();
   },
-  version: "3.12.0-next.41"
+  version: "3.12.0-next.43"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -62,7 +62,7 @@
   },
   "dependencies": {
     "@webex/common": "3.12.0-next.1",
-    "@webex/internal-media-core": "2.23.3",
+    "@webex/internal-media-core": "2.24.1",
     "@webex/internal-plugin-conversation": "3.12.0-next.16",
     "@webex/internal-plugin-device": "3.12.0-next.14",
     "@webex/internal-plugin-llm": "3.12.0-next.16",
@@ -71,7 +71,7 @@
     "@webex/internal-plugin-support": "3.12.0-next.16",
     "@webex/internal-plugin-user": "3.12.0-next.15",
     "@webex/internal-plugin-voicea": "3.12.0-next.16",
-    "@webex/media-helpers": "3.12.0-next.2",
+    "@webex/media-helpers": "3.12.0-next.3",
     "@webex/plugin-people": "3.12.0-next.15",
     "@webex/plugin-rooms": "3.12.0-next.16",
     "@webex/ts-sdp": "^1.8.1",
@@ -94,5 +94,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.12.0-next.41"
+  "version": "3.12.0-next.43"
 }

package/src/constants.ts

@@ -391,6 +391,7 @@ export const EVENT_TRIGGERS = {
   MEETING_CAPTION_RECEIVED: 'meeting:caption-received',
   MEETING_PARTICIPANT_REASON_CHANGED: 'meeting:participant-reason-changed',
   MEETING_AI_ENABLE_REQUEST: 'meeting:aiEnableRequest',
+  MEETING_SRTP_CIPHER_UPDATED: 'meeting:srtpCipher:updated',
 };
 
 export const EVENT_TYPES = {

package/src/media/properties.ts

@@ -43,6 +43,7 @@ export default class MediaProperties {
   shareAudioStream?: LocalSystemAudioStream;
   videoDeviceId: any;
   videoStream?: LocalCameraStream;
+  srtpCipher: string | undefined;
   namespace = MEETINGS;
   mediaIssueCounters: {[key: string]: number} = {};
   throttledSendMediaIssueMetric: ReturnType<typeof throttle>;

package/src/meeting/index.ts

@@ -7603,6 +7603,33 @@ export default class Meeting extends StatelessWebexPlugin {
         }
       }
     });
+    this.statsAnalyzer.on(StatsAnalyzerEventNames.STATS_UPDATE, (data) => {
+      // Extract srtpCipher from transport stats
+      let srtpCipher: string | undefined;
+      for (const stats of data.stats.values()) {
+        if (stats.type === 'transport' && stats.srtpCipher) {
+          srtpCipher = stats.srtpCipher as string;
+          break;
+        }
+      }
+
+      // Only emit event if srtpCipher has changed
+      if (srtpCipher && srtpCipher !== this.mediaProperties.srtpCipher) {
+        LoggerProxy.logger.info(
+          `Meeting:index#setupStatsAnalyzerEventHandlers --> SRTP cipher changed from ${this.mediaProperties.srtpCipher} to ${srtpCipher}`
+        );
+        this.mediaProperties.srtpCipher = srtpCipher;
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'setupStatsAnalyzerEventHandlers',
+          },
+          EVENT_TRIGGERS.MEETING_SRTP_CIPHER_UPDATED,
+          {srtpCipher}
+        );
+      }
+    });
   };
 
   getMediaConnectionDebugId() {

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

@@ -4535,6 +4535,297 @@ describe('plugin-meetings', () => {
               },
             });
           });
+
+          describe('handles STATS_UPDATE event for SRTP cipher detection', () => {
+            it('emits MEETING_SRTP_CIPHER_UPDATED event when srtpCipher is found in transport stats', async () => {
+              const fakeStats = new Map([
+                [
+                  'transport-1',
+                  {
+                    type: 'transport',
+                    srtpCipher: 'AES_CM_128_HMAC_SHA1_80',
+                    dtlsCipher: 'TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256',
+                  },
+                ],
+                [
+                  'outbound-rtp-1',
+                  {
+                    type: 'outbound-rtp',
+                    ssrc: 12345,
+                  },
+                ],
+              ]);
+
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: fakeStats}
+              );
+
+              assert.calledWith(
+                TriggerProxy.trigger,
+                sinon.match.instanceOf(Meeting),
+                {
+                  file: 'meeting/index',
+                  function: 'setupStatsAnalyzerEventHandlers',
+                },
+                EVENT_TRIGGERS.MEETING_SRTP_CIPHER_UPDATED,
+                {srtpCipher: 'AES_CM_128_HMAC_SHA1_80'}
+              );
+
+              assert.equal(meeting.mediaProperties.srtpCipher, 'AES_CM_128_HMAC_SHA1_80');
+            });
+
+            it('updates meeting.mediaProperties.srtpCipher when cipher changes', async () => {
+              const firstStats = new Map([
+                [
+                  'transport-1',
+                  {
+                    type: 'transport',
+                    srtpCipher: 'AES_CM_128_HMAC_SHA1_80',
+                  },
+                ],
+              ]);
+
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: firstStats}
+              );
+
+              assert.equal(meeting.mediaProperties.srtpCipher, 'AES_CM_128_HMAC_SHA1_80');
+
+              const secondStats = new Map([
+                [
+                  'transport-1',
+                  {
+                    type: 'transport',
+                    srtpCipher: 'AEAD_AES_256_GCM',
+                  },
+                ],
+              ]);
+
+              TriggerProxy.trigger.resetHistory();
+
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: secondStats}
+              );
+
+              assert.calledWith(
+                TriggerProxy.trigger,
+                sinon.match.instanceOf(Meeting),
+                {
+                  file: 'meeting/index',
+                  function: 'setupStatsAnalyzerEventHandlers',
+                },
+                EVENT_TRIGGERS.MEETING_SRTP_CIPHER_UPDATED,
+                {srtpCipher: 'AEAD_AES_256_GCM'}
+              );
+
+              assert.equal(meeting.mediaProperties.srtpCipher, 'AEAD_AES_256_GCM');
+            });
+
+            it('does not emit event when srtpCipher has not changed', async () => {
+              const firstStats = new Map([
+                [
+                  'transport-1',
+                  {
+                    type: 'transport',
+                    srtpCipher: 'AES_CM_128_HMAC_SHA1_80',
+                  },
+                ],
+              ]);
+
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: firstStats}
+              );
+
+              assert.equal(meeting.mediaProperties.srtpCipher, 'AES_CM_128_HMAC_SHA1_80');
+
+              TriggerProxy.trigger.resetHistory();
+
+              // Emit same cipher again
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: firstStats}
+              );
+
+              // Should not trigger event again
+              assert.neverCalledWith(
+                TriggerProxy.trigger,
+                sinon.match.instanceOf(Meeting),
+                sinon.match.any,
+                EVENT_TRIGGERS.MEETING_SRTP_CIPHER_UPDATED,
+                sinon.match.any
+              );
+
+              // Cipher should remain the same
+              assert.equal(meeting.mediaProperties.srtpCipher, 'AES_CM_128_HMAC_SHA1_80');
+            });
+
+            it('does not emit event when stats contain no transport with srtpCipher', async () => {
+              const fakeStats = new Map([
+                [
+                  'outbound-rtp-1',
+                  {
+                    type: 'outbound-rtp',
+                    ssrc: 12345,
+                  },
+                ],
+                [
+                  'inbound-rtp-1',
+                  {
+                    type: 'inbound-rtp',
+                    ssrc: 67890,
+                  },
+                ],
+              ]);
+
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: fakeStats}
+              );
+
+              assert.neverCalledWith(
+                TriggerProxy.trigger,
+                sinon.match.instanceOf(Meeting),
+                sinon.match.any,
+                EVENT_TRIGGERS.MEETING_SRTP_CIPHER_UPDATED,
+                sinon.match.any
+              );
+
+              assert.isUndefined(meeting.mediaProperties.srtpCipher);
+            });
+
+            it('does not emit event when transport stat has no srtpCipher property', async () => {
+              const fakeStats = new Map([
+                [
+                  'transport-1',
+                  {
+                    type: 'transport',
+                    dtlsCipher: 'TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256',
+                    // no srtpCipher property
+                  },
+                ],
+              ]);
+
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: fakeStats}
+              );
+
+              assert.neverCalledWith(
+                TriggerProxy.trigger,
+                sinon.match.instanceOf(Meeting),
+                sinon.match.any,
+                EVENT_TRIGGERS.MEETING_SRTP_CIPHER_UPDATED,
+                sinon.match.any
+              );
+
+              assert.isUndefined(meeting.mediaProperties.srtpCipher);
+            });
+
+            it('uses first transport with srtpCipher when multiple transports exist', async () => {
+              const fakeStats = new Map([
+                [
+                  'transport-1',
+                  {
+                    type: 'transport',
+                    srtpCipher: 'AES_CM_128_HMAC_SHA1_80',
+                  },
+                ],
+                [
+                  'transport-2',
+                  {
+                    type: 'transport',
+                    srtpCipher: 'AEAD_AES_256_GCM',
+                  },
+                ],
+                [
+                  'outbound-rtp-1',
+                  {
+                    type: 'outbound-rtp',
+                    ssrc: 12345,
+                  },
+                ],
+              ]);
+
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: fakeStats}
+              );
+
+              assert.calledWith(
+                TriggerProxy.trigger,
+                sinon.match.instanceOf(Meeting),
+                {
+                  file: 'meeting/index',
+                  function: 'setupStatsAnalyzerEventHandlers',
+                },
+                EVENT_TRIGGERS.MEETING_SRTP_CIPHER_UPDATED,
+                {srtpCipher: 'AES_CM_128_HMAC_SHA1_80'}
+              );
+
+              assert.equal(meeting.mediaProperties.srtpCipher, 'AES_CM_128_HMAC_SHA1_80');
+            });
+
+            it('handles empty stats map without errors', async () => {
+              const emptyStats = new Map();
+
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: emptyStats}
+              );
+
+              assert.neverCalledWith(
+                TriggerProxy.trigger,
+                sinon.match.instanceOf(Meeting),
+                sinon.match.any,
+                EVENT_TRIGGERS.MEETING_SRTP_CIPHER_UPDATED,
+                sinon.match.any
+              );
+
+              assert.isUndefined(meeting.mediaProperties.srtpCipher);
+            });
+
+            it('logs cipher change when cipher is updated', async () => {
+              const loggerSpy = sinon.spy(LoggerProxy.logger, 'info');
+
+              meeting.mediaProperties.srtpCipher = 'AES_CM_128_HMAC_SHA1_80';
+
+              const newStats = new Map([
+                [
+                  'transport-1',
+                  {
+                    type: 'transport',
+                    srtpCipher: 'AEAD_AES_256_GCM',
+                  },
+                ],
+              ]);
+
+              statsAnalyzerStub.emit(
+                {file: 'test', function: 'test'},
+                StatsAnalyzerEventNames.STATS_UPDATE,
+                {stats: newStats}
+              );
+
+              assert.calledWithMatch(
+                loggerSpy,
+                sinon.match(/SRTP cipher changed from AES_CM_128_HMAC_SHA1_80 to AEAD_AES_256_GCM/)
+              );
+
+              loggerSpy.restore();
+            });
+          });
         });
 
         describe('handles StatsMonitor events', () => {