livekit-client 1.12.1 → 1.12.2

package/src/api/SignalClient.ts

@@ -1,3 +1,4 @@
+import { protoInt64 } from '@bufbuild/protobuf';
 import log from '../logger';
 import {
   ClientInfo,
@@ -7,12 +8,14 @@ import {
   Room,
   SpeakerInfo,
   VideoLayer,
-} from '../proto/livekit_models';
+} from '../proto/livekit_models_pb';
 import {
   AddTrackRequest,
   ConnectionQualityUpdate,
   JoinResponse,
   LeaveRequest,
+  MuteTrackRequest,
+  Ping,
   ReconnectResponse,
   SessionDescription,
   SignalRequest,
@@ -21,18 +24,22 @@ import {
   SimulateScenario,
   StreamStateUpdate,
   SubscribedQualityUpdate,
+  SubscriptionPermission,
   SubscriptionPermissionUpdate,
   SubscriptionResponse,
   SyncState,
   TrackPermission,
   TrackPublishedResponse,
   TrackUnpublishedResponse,
+  TrickleRequest,
+  UpdateParticipantMetadata,
   UpdateSubscription,
   UpdateTrackSettings,
-} from '../proto/livekit_rtc';
+  UpdateVideoLayers,
+} from '../proto/livekit_rtc_pb';
 import { ConnectionError, ConnectionErrorReason } from '../room/errors';
 import CriticalTimers from '../room/timers';
-import { Mutex, getClientInfo, isReactNative, sleep } from '../room/utils';
+import { Mutex, getClientInfo, isReactNative, sleep, toWebsocketUrl } from '../room/utils';
 import { AsyncQueue } from '../utils/AsyncQueue';
 
 // internal options
@@ -65,7 +72,7 @@ export interface SignalOptions {
 
 type SignalMessage = SignalRequest['message'];
 
-type SignalKind = NonNullable<SignalMessage>['$case'];
+type SignalKind = NonNullable<SignalMessage>['case'];
 
 const passThroughQueueSignals: Array<SignalKind> = [
   'syncState',
@@ -77,7 +84,7 @@ const passThroughQueueSignals: Array<SignalKind> = [
 ];
 
 function canPassThroughQueue(req: SignalMessage): boolean {
-  const canPass = passThroughQueueSignals.indexOf(req!.$case) >= 0;
+  const canPass = passThroughQueueSignals.indexOf(req!.case) >= 0;
   log.trace('request allowed to bypass queue:', { canPass, req });
   return canPass;
 }
@@ -206,9 +213,7 @@ export class SignalClient {
     abortSignal?: AbortSignal,
   ): Promise<JoinResponse | ReconnectResponse | void> {
     this.connectOptions = opts;
-    if (url.startsWith('http')) {
-      url = url.replace('http', 'ws');
-    }
+    url = toWebsocketUrl(url);
     // strip trailing slash
     url = url.replace(/\/$/, '');
     url += '/rtc';
@@ -268,9 +273,9 @@ export class SignalClient {
         let resp: SignalResponse;
         if (typeof ev.data === 'string') {
           const json = JSON.parse(ev.data);
-          resp = SignalResponse.fromJSON(json);
+          resp = SignalResponse.fromJson(json);
         } else if (ev.data instanceof ArrayBuffer) {
-          resp = SignalResponse.decode(new Uint8Array(ev.data));
+          resp = SignalResponse.fromBinary(new Uint8Array(ev.data));
         } else {
           log.error(`could not decode websocket message: ${typeof ev.data}`);
           return;
@@ -279,11 +284,11 @@ export class SignalClient {
         if (!this.isConnected) {
           let shouldProcessMessage = false;
           // handle join message only
-          if (resp.message?.$case === 'join') {
+          if (resp.message?.case === 'join') {
             this.isConnected = true;
             abortSignal?.removeEventListener('abort', abortHandler);
-            this.pingTimeoutDuration = resp.message.join.pingTimeout;
-            this.pingIntervalDuration = resp.message.join.pingInterval;
+            this.pingTimeoutDuration = resp.message.value.pingTimeout;
+            this.pingIntervalDuration = resp.message.value.pingInterval;
 
             if (this.pingTimeoutDuration && this.pingTimeoutDuration > 0) {
               log.debug('ping config', {
@@ -292,14 +297,14 @@ export class SignalClient {
               });
               this.startPingInterval();
             }
-            resolve(resp.message.join);
+            resolve(resp.message.value);
           } else if (opts.reconnect) {
             // in reconnecting, any message received means signal reconnected
             this.isConnected = true;
             abortSignal?.removeEventListener('abort', abortHandler);
             this.startPingInterval();
-            if (resp.message?.$case === 'reconnect') {
-              resolve(resp.message?.reconnect);
+            if (resp.message?.case === 'reconnect') {
+              resolve(resp.message?.value);
             } else {
               resolve();
               shouldProcessMessage = true;
@@ -308,7 +313,7 @@ export class SignalClient {
             // non-reconnect case, should receive join response first
             reject(
               new ConnectionError(
-                `did not receive join response, got ${resp.message?.$case} instead`,
+                `did not receive join response, got ${resp.message?.case} instead`,
               ),
             );
           }
@@ -382,8 +387,8 @@ export class SignalClient {
   sendOffer(offer: RTCSessionDescriptionInit) {
     log.debug('sending offer', offer);
     this.sendRequest({
-      $case: 'offer',
-      offer: toProtoSessionDescription(offer),
+      case: 'offer',
+      value: toProtoSessionDescription(offer),
     });
   }
 
@@ -391,94 +396,94 @@ export class SignalClient {
   sendAnswer(answer: RTCSessionDescriptionInit) {
     log.debug('sending answer');
     return this.sendRequest({
-      $case: 'answer',
-      answer: toProtoSessionDescription(answer),
+      case: 'answer',
+      value: toProtoSessionDescription(answer),
     });
   }
 
   sendIceCandidate(candidate: RTCIceCandidateInit, target: SignalTarget) {
     log.trace('sending ice candidate', candidate);
     return this.sendRequest({
-      $case: 'trickle',
-      trickle: {
+      case: 'trickle',
+      value: new TrickleRequest({
         candidateInit: JSON.stringify(candidate),
         target,
-      },
+      }),
     });
   }
 
   sendMuteTrack(trackSid: string, muted: boolean) {
     return this.sendRequest({
-      $case: 'mute',
-      mute: {
+      case: 'mute',
+      value: new MuteTrackRequest({
         sid: trackSid,
         muted,
-      },
+      }),
     });
   }
 
   sendAddTrack(req: AddTrackRequest) {
     return this.sendRequest({
-      $case: 'addTrack',
-      addTrack: req,
+      case: 'addTrack',
+      value: req,
     });
   }
 
   sendUpdateLocalMetadata(metadata: string, name: string) {
     return this.sendRequest({
-      $case: 'updateMetadata',
-      updateMetadata: {
+      case: 'updateMetadata',
+      value: new UpdateParticipantMetadata({
         metadata,
         name,
-      },
+      }),
     });
   }
 
   sendUpdateTrackSettings(settings: UpdateTrackSettings) {
     this.sendRequest({
-      $case: 'trackSetting',
-      trackSetting: settings,
+      case: 'trackSetting',
+      value: settings,
     });
   }
 
   sendUpdateSubscription(sub: UpdateSubscription) {
     return this.sendRequest({
-      $case: 'subscription',
-      subscription: sub,
+      case: 'subscription',
+      value: sub,
     });
   }
 
   sendSyncState(sync: SyncState) {
     return this.sendRequest({
-      $case: 'syncState',
-      syncState: sync,
+      case: 'syncState',
+      value: sync,
     });
   }
 
   sendUpdateVideoLayers(trackSid: string, layers: VideoLayer[]) {
     return this.sendRequest({
-      $case: 'updateLayers',
-      updateLayers: {
+      case: 'updateLayers',
+      value: new UpdateVideoLayers({
         trackSid,
         layers,
-      },
+      }),
     });
   }
 
   sendUpdateSubscriptionPermissions(allParticipants: boolean, trackPermissions: TrackPermission[]) {
     return this.sendRequest({
-      $case: 'subscriptionPermission',
-      subscriptionPermission: {
+      case: 'subscriptionPermission',
+      value: new SubscriptionPermission({
         allParticipants,
         trackPermissions,
-      },
+      }),
     });
   }
 
   sendSimulateScenario(scenario: SimulateScenario) {
     return this.sendRequest({
-      $case: 'simulate',
-      simulate: scenario,
+      case: 'simulate',
+      value: scenario,
     });
   }
 
@@ -486,26 +491,26 @@ export class SignalClient {
     /** send both of ping and pingReq for compatibility to old and new server */
     return Promise.all([
       this.sendRequest({
-        $case: 'ping',
-        ping: Date.now(),
+        case: 'ping',
+        value: protoInt64.parse(Date.now()),
       }),
       this.sendRequest({
-        $case: 'pingReq',
-        pingReq: {
-          timestamp: Date.now(),
-          rtt: this.rtt,
-        },
+        case: 'pingReq',
+        value: new Ping({
+          timestamp: protoInt64.parse(Date.now()),
+          rtt: protoInt64.parse(this.rtt),
+        }),
       }),
     ]);
   }
 
   sendLeave() {
     return this.sendRequest({
-      $case: 'leave',
-      leave: {
+      case: 'leave',
+      value: new LeaveRequest({
         canReconnect: false,
         reason: DisconnectReason.CLIENT_INITIATED,
-      },
+      }),
     });
   }
 
@@ -527,18 +532,16 @@ export class SignalClient {
       await sleep(this.signalLatency);
     }
     if (!this.ws || this.ws.readyState !== this.ws.OPEN) {
-      log.error(`cannot send signal request before connected, type: ${message?.$case}`);
+      log.error(`cannot send signal request before connected, type: ${message?.case}`);
       return;
     }
+    const req = new SignalRequest({ message });
 
-    const req = {
-      message,
-    };
     try {
       if (this.useJSON) {
-        this.ws.send(JSON.stringify(SignalRequest.toJSON(req)));
+        this.ws.send(req.toJsonString());
       } else {
-        this.ws.send(SignalRequest.encode(req).finish());
+        this.ws.send(req.toBinary());
       }
     } catch (e) {
       log.error('error sending signal message', { error: e });
@@ -551,77 +554,77 @@ export class SignalClient {
       log.debug('received unsupported message');
       return;
     }
-    if (msg.$case === 'answer') {
-      const sd = fromProtoSessionDescription(msg.answer);
+    if (msg.case === 'answer') {
+      const sd = fromProtoSessionDescription(msg.value);
       if (this.onAnswer) {
         this.onAnswer(sd);
       }
-    } else if (msg.$case === 'offer') {
-      const sd = fromProtoSessionDescription(msg.offer);
+    } else if (msg.case === 'offer') {
+      const sd = fromProtoSessionDescription(msg.value);
       if (this.onOffer) {
         this.onOffer(sd);
       }
-    } else if (msg.$case === 'trickle') {
-      const candidate: RTCIceCandidateInit = JSON.parse(msg.trickle.candidateInit!);
+    } else if (msg.case === 'trickle') {
+      const candidate: RTCIceCandidateInit = JSON.parse(msg.value.candidateInit!);
       if (this.onTrickle) {
-        this.onTrickle(candidate, msg.trickle.target);
+        this.onTrickle(candidate, msg.value.target);
       }
-    } else if (msg.$case === 'update') {
+    } else if (msg.case === 'update') {
       if (this.onParticipantUpdate) {
-        this.onParticipantUpdate(msg.update.participants ?? []);
+        this.onParticipantUpdate(msg.value.participants ?? []);
       }
-    } else if (msg.$case === 'trackPublished') {
+    } else if (msg.case === 'trackPublished') {
       if (this.onLocalTrackPublished) {
-        this.onLocalTrackPublished(msg.trackPublished);
+        this.onLocalTrackPublished(msg.value);
       }
-    } else if (msg.$case === 'speakersChanged') {
+    } else if (msg.case === 'speakersChanged') {
       if (this.onSpeakersChanged) {
-        this.onSpeakersChanged(msg.speakersChanged.speakers ?? []);
+        this.onSpeakersChanged(msg.value.speakers ?? []);
       }
-    } else if (msg.$case === 'leave') {
+    } else if (msg.case === 'leave') {
       if (this.onLeave) {
-        this.onLeave(msg.leave);
+        this.onLeave(msg.value);
       }
-    } else if (msg.$case === 'mute') {
+    } else if (msg.case === 'mute') {
       if (this.onRemoteMuteChanged) {
-        this.onRemoteMuteChanged(msg.mute.sid, msg.mute.muted);
+        this.onRemoteMuteChanged(msg.value.sid, msg.value.muted);
       }
-    } else if (msg.$case === 'roomUpdate') {
-      if (this.onRoomUpdate && msg.roomUpdate.room) {
-        this.onRoomUpdate(msg.roomUpdate.room);
+    } else if (msg.case === 'roomUpdate') {
+      if (this.onRoomUpdate && msg.value.room) {
+        this.onRoomUpdate(msg.value.room);
       }
-    } else if (msg.$case === 'connectionQuality') {
+    } else if (msg.case === 'connectionQuality') {
       if (this.onConnectionQuality) {
-        this.onConnectionQuality(msg.connectionQuality);
+        this.onConnectionQuality(msg.value);
       }
-    } else if (msg.$case === 'streamStateUpdate') {
+    } else if (msg.case === 'streamStateUpdate') {
       if (this.onStreamStateUpdate) {
-        this.onStreamStateUpdate(msg.streamStateUpdate);
+        this.onStreamStateUpdate(msg.value);
       }
-    } else if (msg.$case === 'subscribedQualityUpdate') {
+    } else if (msg.case === 'subscribedQualityUpdate') {
       if (this.onSubscribedQualityUpdate) {
-        this.onSubscribedQualityUpdate(msg.subscribedQualityUpdate);
+        this.onSubscribedQualityUpdate(msg.value);
       }
-    } else if (msg.$case === 'subscriptionPermissionUpdate') {
+    } else if (msg.case === 'subscriptionPermissionUpdate') {
       if (this.onSubscriptionPermissionUpdate) {
-        this.onSubscriptionPermissionUpdate(msg.subscriptionPermissionUpdate);
+        this.onSubscriptionPermissionUpdate(msg.value);
       }
-    } else if (msg.$case === 'refreshToken') {
+    } else if (msg.case === 'refreshToken') {
       if (this.onTokenRefresh) {
-        this.onTokenRefresh(msg.refreshToken);
+        this.onTokenRefresh(msg.value);
       }
-    } else if (msg.$case === 'trackUnpublished') {
+    } else if (msg.case === 'trackUnpublished') {
       if (this.onLocalTrackUnpublished) {
-        this.onLocalTrackUnpublished(msg.trackUnpublished);
+        this.onLocalTrackUnpublished(msg.value);
       }
-    } else if (msg.$case === 'subscriptionResponse') {
+    } else if (msg.case === 'subscriptionResponse') {
       if (this.onSubscriptionError) {
-        this.onSubscriptionError(msg.subscriptionResponse);
+        this.onSubscriptionError(msg.value);
       }
-    } else if (msg.$case === 'pong') {
+    } else if (msg.case === 'pong') {
       this.resetPingTimeout();
-    } else if (msg.$case === 'pongResp') {
-      this.rtt = Date.now() - msg.pongResp.lastPingTimestamp;
+    } else if (msg.case === 'pongResp') {
+      this.rtt = Date.now() - Number.parseInt(msg.value.lastPingTimestamp.toString());
       this.resetPingTimeout();
     } else {
       log.debug('unsupported message', msg);
@@ -724,10 +727,10 @@ function fromProtoSessionDescription(sd: SessionDescription): RTCSessionDescript
 export function toProtoSessionDescription(
   rsd: RTCSessionDescription | RTCSessionDescriptionInit,
 ): SessionDescription {
-  const sd: SessionDescription = {
+  const sd = new SessionDescription({
     sdp: rsd.sdp!,
     type: rsd.type!,
-  };
+  });
   return sd;
 }
 

package/src/connectionHelper/ConnectionCheck.ts

@@ -1,4 +1,5 @@
-import EventEmitter from 'eventemitter3';
+import { EventEmitter } from 'events';
+import type TypedEmitter from 'typed-emitter';
 import { CheckStatus, Checker } from './checks/Checker';
 import type { CheckInfo, InstantiableCheck } from './checks/Checker';
 import { PublishAudioCheck } from './checks/publishAudio';
@@ -10,7 +11,7 @@ import { WebSocketCheck } from './checks/websocket';
 
 export type { CheckInfo, CheckStatus };
 
-export class ConnectionCheck extends EventEmitter<ConnectionCheckCallbacks> {
+export class ConnectionCheck extends (EventEmitter as new () => TypedEmitter<ConnectionCheckCallbacks>) {
   token: string;
 
   url: string;

package/src/connectionHelper/checks/Checker.ts

@@ -1,4 +1,5 @@
-import EventEmitter from 'eventemitter3';
+import { EventEmitter } from 'events';
+import type TypedEmitter from 'typed-emitter';
 import type { RoomConnectOptions, RoomOptions } from '../../options';
 import type RTCEngine from '../../room/RTCEngine';
 import Room, { ConnectionState } from '../../room/Room';
@@ -29,7 +30,7 @@ export interface CheckerOptions {
   connectOptions?: RoomConnectOptions;
 }
 
-export abstract class Checker extends EventEmitter<CheckerCallbacks> {
+export abstract class Checker extends (EventEmitter as new () => TypedEmitter<CheckerCallbacks>) {
   protected url: string;
 
   protected token: string;
@@ -67,7 +68,6 @@ export abstract class Checker extends EventEmitter<CheckerCallbacks> {
       throw Error('check is running already');
     }
     this.setStatus(CheckStatus.RUNNING);
-    this.appendMessage(`${this.name} started.`);
 
     try {
       await this.perform();

package/src/connectionHelper/checks/webrtc.ts

@@ -1,3 +1,4 @@
+import { RoomEvent } from '../../room/events';
 import { Checker } from './Checker';
 
 export class WebRTCCheck extends Checker {
@@ -6,13 +7,76 @@ export class WebRTCCheck extends Checker {
   }
 
   protected async perform(): Promise<void> {
+    let hasTcp = false;
+    let hasIpv4Udp = false;
+    this.room.on(RoomEvent.SignalConnected, () => {
+      const prevTrickle = this.room.engine.client.onTrickle;
+
+      const candidates: RTCIceCandidate[] = [];
+      this.room.engine.client.onTrickle = (sd, target) => {
+        console.log('got candidate', sd);
+        if (sd.candidate) {
+          const candidate = new RTCIceCandidate(sd);
+          candidates.push(candidate);
+          let str = `${candidate.protocol} ${candidate.address}:${candidate.port} ${candidate.type}`;
+          if (candidate.protocol === 'tcp' && candidate.tcpType === 'passive') {
+            hasTcp = true;
+            str += ' (active)';
+          } else if (candidate.protocol === 'udp' && candidate.address) {
+            if (isIPPrivate(candidate.address)) {
+              str += ' (private)';
+            } else {
+              hasIpv4Udp = true;
+            }
+          }
+          this.appendMessage(str);
+        }
+        if (prevTrickle) {
+          prevTrickle(sd, target);
+        }
+      };
+
+      if (this.room.engine.subscriber) {
+        this.room.engine.subscriber.pc.onicecandidateerror = (ev) => {
+          if (ev instanceof RTCPeerConnectionIceErrorEvent) {
+            this.appendWarning(
+              `error with ICE candidate: ${ev.errorCode} ${ev.errorText} ${ev.url}`,
+            );
+          }
+        };
+      }
+    });
     try {
-      console.log('initiating room connection');
-      this.room = await this.connect();
+      await this.connect();
       console.log('now the room is connected');
     } catch (err) {
       this.appendWarning('ports need to be open on firewall in order to connect.');
       throw err;
     }
+    if (!hasTcp) {
+      this.appendWarning('Server is not configured for ICE/TCP');
+    }
+    if (!hasIpv4Udp) {
+      this.appendWarning(
+        'No public IPv4 UDP candidates were found. Your server is likely not configured correctly',
+      );
+    }
+  }
+}
+
+function isIPPrivate(address: string): boolean {
+  const parts = address.split('.');
+  if (parts.length === 4) {
+    if (parts[0] === '10') {
+      return true;
+    } else if (parts[0] === '192' && parts[1] === '168') {
+      return true;
+    } else if (parts[0] === '172') {
+      const second = parseInt(parts[1], 10);
+      if (second >= 16 && second <= 31) {
+        return true;
+      }
+    }
   }
+  return false;
 }

package/src/connectionHelper/checks/websocket.ts

@@ -1,4 +1,5 @@
 import { SignalClient } from '../../api/SignalClient';
+import { ServerInfo_Edition } from '../../proto/livekit_models_pb';
 import { Checker } from './Checker';
 
 export class WebSocketCheck extends Checker {
@@ -18,6 +19,9 @@ export class WebSocketCheck extends Checker {
       e2eeEnabled: false,
     });
     this.appendMessage(`Connected to server, version ${joinRes.serverVersion}.`);
+    if (joinRes.serverInfo?.edition === ServerInfo_Edition.Cloud && joinRes.serverInfo?.region) {
+      this.appendMessage(`LiveKit Cloud: ${joinRes.serverInfo?.region}`);
+    }
     await signalClient.close();
   }
 }

package/src/e2ee/E2eeManager.ts

@@ -1,6 +1,7 @@
-import EventEmitter from 'eventemitter3';
+import { EventEmitter } from 'events';
+import type TypedEventEmitter from 'typed-emitter';
 import log from '../logger';
-import { Encryption_Type, TrackInfo } from '../proto/livekit_models';
+import { Encryption_Type, TrackInfo } from '../proto/livekit_models_pb';
 import type RTCEngine from '../room/RTCEngine';
 import type Room from '../room/Room';
 import { ConnectionState } from '../room/Room';
@@ -32,7 +33,7 @@ import { isE2EESupported, isScriptTransformSupported, mimeTypeToVideoCodecString
 /**
  * @experimental
  */
-export class E2EEManager extends EventEmitter<E2EEManagerCallbacks> {
+export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2EEManagerCallbacks>) {
   protected worker: Worker;
 
   protected room?: Room;

package/src/e2ee/KeyProvider.ts

@@ -1,4 +1,5 @@
-import EventEmitter from 'eventemitter3';
+import { EventEmitter } from 'events';
+import type TypedEventEmitter from 'typed-emitter';
 import { KEY_PROVIDER_DEFAULTS } from './constants';
 import type { KeyInfo, KeyProviderCallbacks, KeyProviderOptions } from './types';
 import { createKeyMaterialFromString } from './utils';
@@ -6,7 +7,7 @@ import { createKeyMaterialFromString } from './utils';
 /**
  * @experimental
  */
-export class BaseKeyProvider extends EventEmitter<KeyProviderCallbacks> {
+export class BaseKeyProvider extends (EventEmitter as new () => TypedEventEmitter<KeyProviderCallbacks>) {
   private keyInfoMap: Map<string, KeyInfo>;
 
   private options: KeyProviderOptions;

package/src/e2ee/constants.ts

@@ -7,6 +7,9 @@ export const ENCRYPTION_ALGORITHM = 'AES-GCM';
 // in the frame trailer.
 export const KEYRING_SIZE = 16;
 
+// How many consecutive frames can fail decrypting before a particular key gets marked as invalid
+export const DECRYPTION_FAILURE_TOLERANCE = 10;
+
 // We copy the first bytes of the VP8 payload unencrypted.
 // For keyframes this is 10 bytes, for non-keyframes (delta) 3. See
 //   https://tools.ietf.org/html/rfc6386#section-9.1
@@ -37,4 +40,5 @@ export const KEY_PROVIDER_DEFAULTS: KeyProviderOptions = {
   sharedKey: false,
   ratchetSalt: SALT,
   ratchetWindowSize: 8,
+  failureTolerance: DECRYPTION_FAILURE_TOLERANCE,
 } as const;

package/src/e2ee/types.ts

@@ -110,6 +110,7 @@ export type KeyProviderOptions = {
   sharedKey: boolean;
   ratchetSalt: string;
   ratchetWindowSize: number;
+  failureTolerance: number;
 };
 
 export type KeyProviderCallbacks = {

package/src/e2ee/worker/FrameCryptor.test.ts

@@ -1,6 +1,4 @@
-/**
- * @jest-environment node
- */
+import { describe, expect, it } from 'vitest';
 import { isFrameServerInjected } from './FrameCryptor';
 
 describe('FrameCryptor', () => {