djs-selfbot-v13 3.7.32 → 3.7.33

package/src/client/voice/networking/DAVESession.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const EventEmitter = require('events');
+const Davey = require('@snazzah/davey');
+
+const TRANSITION_EXPIRY = 10;
+const TRANSITION_EXPIRY_PENDING_DOWNGRADE = 24;
+const DEFAULT_DECRYPTION_FAILURE_TOLERANCE = 36;
+
+const SILENCE_FRAME = Buffer.from([0xf8, 0xff, 0xfe]);
+
+function getMaxProtocolVersion() {
+  return Davey.DAVE_PROTOCOL_VERSION ?? 0;
+}
+
+class DAVESession extends EventEmitter {
+  constructor(protocolVersion, userId, channelId, options = {}) {
+    super();
+    this.protocolVersion = protocolVersion;
+    this.userId = userId;
+    this.channelId = channelId;
+    this.failureTolerance = options.decryptionFailureTolerance ?? DEFAULT_DECRYPTION_FAILURE_TOLERANCE;
+    this.pendingTransitions = new Map();
+    this.downgraded = false;
+    this.consecutiveFailures = 0;
+    this.reinitializing = false;
+    this.lastTransitionId = undefined;
+    this.session = undefined;
+  }
+
+  get voicePrivacyCode() {
+    if (this.protocolVersion === 0 || !this.session?.voicePrivacyCode) return null;
+    return this.session.voicePrivacyCode;
+  }
+
+  async getVerificationCode(userId) {
+    if (!this.session) throw new Error('Session not available');
+    return this.session.getVerificationCode(userId);
+  }
+
+  reinit() {
+    if (this.protocolVersion > 0) {
+      if (this.session) {
+        this.session.reinit(this.protocolVersion, this.userId, this.channelId);
+        this.emit('debug', `Session reinitialized for protocol version ${this.protocolVersion}`);
+      } else {
+        this.session = new Davey.DAVESession(this.protocolVersion, this.userId, this.channelId);
+        this.emit('debug', `Session initialized for protocol version ${this.protocolVersion}`);
+      }
+      this.emit('keyPackage', this.session.getSerializedKeyPackage());
+    } else if (this.session) {
+      this.session.reset();
+      this.session.setPassthroughMode(true, TRANSITION_EXPIRY);
+      this.emit('debug', 'Session reset');
+    }
+  }
+
+  setExternalSender(externalSender) {
+    if (!this.session) throw new Error('No session available');
+    try {
+      this.session.setExternalSender(externalSender);
+      this.emit('debug', 'Set MLS external sender');
+    } catch (error) {
+      if (String(error).includes('AlreadyInGroup')) {
+        this.emit('debug', 'MLS external sender already set, skipping');
+        return;
+      }
+      throw error;
+    }
+  }
+
+  prepareTransition(data) {
+    this.emit('debug', `Preparing for transition (${data.transition_id}, v${data.protocol_version})`);
+    this.pendingTransitions.set(data.transition_id, data.protocol_version);
+
+    if (data.transition_id === 0) {
+      this.executeTransition(data.transition_id);
+    } else {
+      if (data.protocol_version === 0) this.session?.setPassthroughMode(true, TRANSITION_EXPIRY_PENDING_DOWNGRADE);
+      return true;
+    }
+
+    return false;
+  }
+
+  executeTransition(transitionId) {
+    this.emit('debug', `Executing transition (${transitionId})`);
+    if (!this.pendingTransitions.has(transitionId)) {
+      this.emit('debug', `Received execute transition, but we don't have a pending transition for ${transitionId}`);
+      return false;
+    }
+
+    const oldVersion = this.protocolVersion;
+    this.protocolVersion = this.pendingTransitions.get(transitionId);
+
+    if (oldVersion !== this.protocolVersion && this.protocolVersion === 0) {
+      this.downgraded = true;
+      this.emit('debug', 'Session downgraded');
+    } else if (transitionId > 0 && this.downgraded) {
+      this.downgraded = false;
+      this.session?.setPassthroughMode(true, TRANSITION_EXPIRY);
+      this.emit('debug', 'Session upgraded');
+    }
+
+    this.reinitializing = false;
+    this.lastTransitionId = transitionId;
+    this.emit('debug', `Transition executed (v${oldVersion} -> v${this.protocolVersion}, id: ${transitionId})`);
+    this.pendingTransitions.delete(transitionId);
+    return true;
+  }
+
+  prepareEpoch(data) {
+    this.emit('debug', `Preparing for epoch (${data.epoch})`);
+    if (data.epoch === 1) {
+      this.protocolVersion = data.protocol_version;
+      this.reinit();
+    }
+  }
+
+  recoverFromInvalidTransition(transitionId) {
+    if (this.reinitializing) return;
+    this.emit('debug', `Invalidating transition ${transitionId}`);
+    this.reinitializing = true;
+    this.consecutiveFailures = 0;
+    this.emit('invalidateTransition', transitionId);
+    this.reinit();
+  }
+
+  processProposals(payload, connectedClients) {
+    if (!this.session) throw new Error('No session available');
+    try {
+      const optype = payload.readUInt8(0);
+      const { commit, welcome } = this.session.processProposals(
+        optype,
+        payload.subarray(1),
+        Array.from(connectedClients),
+      );
+      this.emit('debug', 'MLS proposals processed');
+      if (!commit) return;
+      return welcome ? Buffer.concat([commit, welcome]) : commit;
+    } catch (error) {
+      this.emit('debug', `MLS proposals errored: ${error}`);
+      return null;
+    }
+  }
+
+  processCommit(payload) {
+    if (!this.session) throw new Error('No session available');
+    const transitionId = payload.readUInt16BE(0);
+    try {
+      this.session.processCommit(payload.subarray(2));
+      if (transitionId === 0) {
+        this.reinitializing = false;
+        this.lastTransitionId = transitionId;
+      } else {
+        this.pendingTransitions.set(transitionId, this.protocolVersion);
+      }
+      this.emit('debug', `MLS commit processed (transition id: ${transitionId})`);
+      return { transitionId, success: true };
+    } catch (error) {
+      this.emit('debug', `MLS commit errored from transition ${transitionId}: ${error}`);
+      this.recoverFromInvalidTransition(transitionId);
+      return { transitionId, success: false };
+    }
+  }
+
+  processWelcome(payload) {
+    if (!this.session) throw new Error('No session available');
+    const transitionId = payload.readUInt16BE(0);
+    try {
+      this.session.processWelcome(payload.subarray(2));
+      if (transitionId === 0) {
+        this.reinitializing = false;
+        this.lastTransitionId = transitionId;
+      } else {
+        this.pendingTransitions.set(transitionId, this.protocolVersion);
+      }
+      this.emit('debug', `MLS welcome processed (transition id: ${transitionId})`);
+      return { transitionId, success: true };
+    } catch (error) {
+      this.emit('debug', `MLS welcome errored from transition ${transitionId}: ${error}`);
+      this.recoverFromInvalidTransition(transitionId);
+      return { transitionId, success: false };
+    }
+  }
+
+  encrypt(packet) {
+    if (this.protocolVersion === 0 || !this.session?.ready || packet.equals(SILENCE_FRAME)) return packet;
+    return this.session.encryptOpus(packet);
+  }
+
+  encryptVideo(packet, codec = 'H264') {
+    if (this.protocolVersion === 0 || !this.session?.ready) return packet;
+    const codecMap = {
+      H264: Davey.Codec.H264,
+      VP8: Davey.Codec.VP8,
+      H265: Davey.Codec.H265,
+      AV1: Davey.Codec.AV1,
+    };
+    return this.session.encrypt(Davey.MediaType.VIDEO, codecMap[codec] ?? Davey.Codec.UNKNOWN, packet);
+  }
+
+  decrypt(packet, userId) {
+    const canDecrypt = this.session?.ready && (this.protocolVersion !== 0 || this.session?.canPassthrough(userId));
+    if (packet.equals(SILENCE_FRAME) || !canDecrypt || !this.session) return packet;
+    try {
+      const buffer = this.session.decrypt(userId, Davey.MediaType.AUDIO, packet);
+      this.consecutiveFailures = 0;
+      return buffer;
+    } catch (error) {
+      if (!this.reinitializing && this.pendingTransitions.size === 0) {
+        this.consecutiveFailures++;
+        this.emit('debug', `Failed to decrypt a packet (${this.consecutiveFailures} consecutive fails)`);
+        if (this.consecutiveFailures > this.failureTolerance) {
+          if (this.lastTransitionId) this.recoverFromInvalidTransition(this.lastTransitionId);
+          else throw error;
+        }
+      } else if (this.reinitializing) {
+        this.emit('debug', 'Failed to decrypt a packet (reinitializing session)');
+      } else if (this.pendingTransitions.size > 0) {
+        this.emit('debug', `Failed to decrypt a packet (${this.pendingTransitions.size} pending transition[s])`);
+      }
+    }
+    return null;
+  }
+
+  destroy() {
+    try {
+      this.session?.reset();
+    } catch {}
+  }
+}
+
+module.exports = { DAVESession, getMaxProtocolVersion };

package/src/client/voice/networking/VoiceWebSocket.js

@@ -4,7 +4,8 @@ const EventEmitter = require('events');
 const { setTimeout, setInterval } = require('node:timers');
 const WebSocket = require('../../../WebSocket');
 const { Error } = require('../../../errors');
-const { Opcodes, VoiceOpcodes } = require('../../../util/Constants');
+const { Opcodes, VoiceOpcodes, VoiceStatus } = require('../../../util/Constants');
+const { DAVESession, getMaxProtocolVersion } = require('./DAVESession');
 
 /**
  * Represents a Voice Connection's WebSocket.
@@ -29,6 +30,7 @@ class VoiceWebSocket extends EventEmitter {
     this._sequenceNumber = -1;
 
     this.dead = false;
+    this._identified = false;
     this.connection.on('closing', this.shutdown.bind(this));
   }
 
@@ -57,6 +59,7 @@ class VoiceWebSocket extends EventEmitter {
       this.ws = null;
     }
     this.clearHeartbeat();
+    this._identified = false;
   }
 
   /**
@@ -67,7 +70,7 @@ class VoiceWebSocket extends EventEmitter {
     if (this.dead) return;
     if (this.ws) this.reset();
     if (this.attempts >= 5) {
-      this.emit('debug', new Error('VOICE_CONNECTION_ATTEMPTS_EXCEEDED', this.attempts));
+      this.emit('error', new Error('VOICE_CONNECTION_ATTEMPTS_EXCEEDED', this.attempts));
       return;
     }
 
@@ -87,13 +90,14 @@ class VoiceWebSocket extends EventEmitter {
 
   /**
    * Sends data to the WebSocket if it is open.
-   * @param {string} data The data to send to the WebSocket
-   * @returns {Promise<string>}
+   * @param {string|Buffer} data The data to send to the WebSocket
+   * @returns {Promise<string|Buffer>}
    */
   send(data) {
-    this.emit('debug', `[WS] >> ${data}`);
+    const preview = typeof data === 'string' ? data : `[bin] ${data.byteLength} bytes`;
+    this.emit('debug', `[WS] >> ${preview}`);
     return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error('WS_NOT_OPEN', data);
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error('WS_NOT_OPEN', preview);
       this.ws.send(data, null, error => {
         if (error) reject(error);
         else resolve(data);
@@ -111,23 +115,46 @@ class VoiceWebSocket extends EventEmitter {
     return this.send(packet);
   }
 
+  /**
+   * Sends a binary message over the WebSocket.
+   * @param {number} opcode The opcode to use
+   * @param {Buffer} payload The payload to send
+   * @returns {Promise<Buffer>}
+   */
+  sendBinaryMessage(opcode, payload) {
+    const message = Buffer.concat([Buffer.from([opcode]), payload]);
+    return this.send(message);
+  }
+
   /**
    * Called whenever the WebSocket opens.
    */
   onOpen() {
     this.emit('debug', `[WS] opened at gateway ${this.connection.authentication.endpoint}`);
-    this.sendPacket({
-      op: Opcodes.DISPATCH,
-      d: {
-        server_id: this.connection.serverId || this.connection.channel.guild?.id || this.connection.channel.id,
-        user_id: this.client.user.id,
-        token: this.connection.authentication.token,
-        session_id: this.connection.authentication.sessionId,
-        streams: [{ type: 'screen', rid: '100', quality: 100 }],
-        video: true,
-      },
-    }).catch(() => {
-      this.emit('error', new Error('VOICE_JOIN_SOCKET_CLOSED'));
+  }
+
+  sendIdentify() {
+    if (this._identified) return Promise.resolve();
+    this._identified = true;
+
+    const isStream = this.connection.constructor.name === 'StreamConnection';
+    const data = {
+      server_id: this.connection.serverId || this.connection.channel.guild?.id || this.connection.channel.id,
+      user_id: this.client.user.id,
+      token: this.connection.authentication.token,
+      session_id: this.connection.authentication.sessionId,
+      max_dave_protocol_version: getMaxProtocolVersion(),
+    };
+
+    if (isStream) {
+      data.channel_id = this.connection.channel.id;
+      data.streams = [{ type: 'screen', rid: '100', quality: 100 }];
+      data.video = true;
+    }
+
+    return this.sendPacket({
+      op: VoiceOpcodes.IDENTIFY,
+      d: data,
     });
   }
 
@@ -138,18 +165,151 @@ class VoiceWebSocket extends EventEmitter {
    */
   onMessage(event) {
     try {
-      return this.onPacket(WebSocket.unpack(event.data, 'json'));
+      const { data } = event;
+      if (data instanceof ArrayBuffer || Buffer.isBuffer(data)) {
+        const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        const seq = buffer.readUInt16BE(0);
+        const op = buffer.readUInt8(2);
+        const payload = buffer.subarray(3);
+        this._sequenceNumber = seq;
+        this.emit('debug', `[WS] << [bin] opcode ${op}, seq ${seq}, ${payload.byteLength} bytes`);
+        return this.onBinaryMessage({ op, seq, payload });
+      }
+      return this.onPacket(WebSocket.unpack(data, 'json'));
     } catch (error) {
       return this.onError(error);
     }
   }
 
+  usesSharedDaveSession() {
+    return (
+      this.connection.constructor.name === 'StreamConnection' &&
+      this.connection.voiceConnection?.dave === this.connection.dave
+    );
+  }
+
+  onBinaryMessage(message) {
+    const { dave } = this.connection;
+    if (!dave) return;
+    if (this.usesSharedDaveSession()) {
+      this.emit('debug', `[WS] << [bin] opcode ${message.op} ignored (shared MLS session)`);
+      return;
+    }
+
+    switch (message.op) {
+      case VoiceOpcodes.DAVE_MLS_EXTERNAL_SENDER:
+        dave.setExternalSender(message.payload);
+        break;
+      case VoiceOpcodes.DAVE_MLS_PROPOSALS: {
+        const payload = dave.processProposals(message.payload, this.connection.connectedClients);
+        if (payload) this.sendBinaryMessage(VoiceOpcodes.DAVE_MLS_COMMIT_WELCOME, payload);
+        break;
+      }
+      case VoiceOpcodes.DAVE_MLS_ANNOUNCE_COMMIT_TRANSITION: {
+        const { transitionId, success } = dave.processCommit(message.payload);
+        if (success) {
+          if (transitionId === 0) {
+            this.emit('transitioned', transitionId);
+          } else {
+            this.sendPacket({
+              op: VoiceOpcodes.DAVE_TRANSITION_READY,
+              d: { transition_id: transitionId },
+            });
+          }
+        }
+        break;
+      }
+      case VoiceOpcodes.DAVE_MLS_WELCOME: {
+        const { transitionId, success } = dave.processWelcome(message.payload);
+        if (success) {
+          if (transitionId === 0) {
+            this.emit('transitioned', transitionId);
+          } else {
+            this.sendPacket({
+              op: VoiceOpcodes.DAVE_TRANSITION_READY,
+              d: { transition_id: transitionId },
+            });
+          }
+        }
+        break;
+      }
+      default:
+        this.emit('unknownPacket', message);
+    }
+  }
+
   /**
    * Called whenever the connection to the WebSocket server is lost.
    * @param {CloseEvent} event The WebSocket close event
    */
   onClose(event) {
     this.emit('debug', `[WS] closed with code ${event.code} and reason: ${event.reason}`);
+    if (event.code === 4017) {
+      this.dead = true;
+      this.emit(
+        'error',
+        new Error('VOICE_DAVE_REQUIRED', 'Discord requires DAVE/E2EE protocol support. Ensure @snazzah/davey is installed.'),
+      );
+      return;
+    }
+    if (event.code === 4006) {
+      const isStream = this.connection.constructor.name === 'StreamConnection';
+      this.connection._sessionRetries ??= 0;
+      if (this.connection._sessionRetries < 3) {
+        this.connection._sessionRetries++;
+        this._identified = false;
+        this.reset();
+        this.connection.authentication = {};
+        this.connection.status = VoiceStatus.AUTHENTICATING;
+        if (isStream) {
+          this.connection.serverId = null;
+          if (this.connection.sockets.ws) {
+            this.connection.sockets.ws.shutdown();
+            this.connection.sockets.ws = null;
+          }
+          if (this.connection.sockets.udp) {
+            this.connection.sockets.udp.shutdown();
+            this.connection.sockets.udp = null;
+          }
+          if (this.connection.voiceConnection) {
+            this.connection.voiceConnection.streamConnection = this.connection;
+          }
+          clearTimeout(this.connection.connectTimeout);
+          this.connection.connectTimeout = setTimeout(
+            () => this.connection.authenticateFailed('VOICE_CONNECTION_TIMEOUT'),
+            30_000,
+          ).unref();
+          this.connection.channel.client.ws.broadcast({
+            op: Opcodes.STREAM_DELETE,
+            d: { stream_key: this.connection.streamKey },
+          });
+          setTimeout(() => {
+            this.connection.sendSignalScreenshare();
+          }, 1500).unref();
+        } else {
+          if (this.connection.sockets.ws) {
+            this.connection.sockets.ws.shutdown();
+            this.connection.sockets.ws = null;
+          }
+          if (this.connection.sockets.udp) {
+            this.connection.sockets.udp.shutdown();
+            this.connection.sockets.udp = null;
+          }
+          this.connection.status = VoiceStatus.RECONNECTING;
+          setTimeout(() => {
+            if (this.connection.authentication.token && this.connection.authentication.endpoint) {
+              this.connection.connect();
+            } else {
+              this.connection.sendVoiceStateUpdate();
+            }
+          }, 500).unref();
+        }
+        return;
+      }
+      this.dead = true;
+      this.emit('error', new Error('VOICE_SESSION_EXPIRED'));
+      return;
+    }
     if (!this.dead) setTimeout(this.connect.bind(this), this.attempts * 1000).unref();
   }
 
@@ -162,6 +322,90 @@ class VoiceWebSocket extends EventEmitter {
     this.emit('error', error);
   }
 
+  setupDaveSession(protocolVersion) {
+    const isStream = this.connection.constructor.name === 'StreamConnection';
+    const parentDave = this.connection.voiceConnection?.dave;
+
+    if (isStream && parentDave?.session) {
+      this.connection.dave = parentDave;
+      this.connection.connectedClients.add(this.client.user.id);
+      for (const id of this.connection.voiceConnection.connectedClients) {
+        this.connection.connectedClients.add(id);
+      }
+      this.emit('debug', '[DAVE] Reusing parent voice connection MLS session');
+      return;
+    }
+
+    if (this.connection.dave) {
+      const isSharedDave = isStream && this.connection.dave === parentDave;
+      if (!isSharedDave) {
+        this.connection.dave.destroy();
+        this.connection.dave.removeAllListeners();
+      }
+    }
+
+    if (!protocolVersion || getMaxProtocolVersion() === 0) {
+      this.connection.dave = null;
+      return;
+    }
+
+    const session = new DAVESession(
+      protocolVersion,
+      this.client.user.id,
+      this.connection.channel.id,
+    );
+
+    session.on('debug', msg => this.emit('debug', `[DAVE] ${msg}`));
+    session.on('keyPackage', keyPackage => {
+      this.sendBinaryMessage(VoiceOpcodes.DAVE_MLS_KEY_PACKAGE, keyPackage).catch(e => this.emit('error', e));
+    });
+    session.on('invalidateTransition', transitionId => {
+      this.sendPacket({
+        op: VoiceOpcodes.DAVE_MLS_INVALID_COMMIT_WELCOME,
+        d: { transition_id: transitionId },
+      }).catch(e => this.emit('error', e));
+    });
+    session.on('error', err => this.emit('error', err));
+
+    this.connection.dave = session;
+    this.connection.connectedClients.add(this.client.user.id);
+    if (this.connection.voiceConnection?.connectedClients) {
+      for (const id of this.connection.voiceConnection.connectedClients) {
+        this.connection.connectedClients.add(id);
+      }
+    }
+    session.reinit();
+  }
+
+  handleDavePacket(packet) {
+    const { dave } = this.connection;
+    if (!dave) return;
+
+    switch (packet.op) {
+      case VoiceOpcodes.DAVE_PREPARE_TRANSITION: {
+        const sendReady = dave.prepareTransition(packet.d);
+        if (sendReady) {
+          this.sendPacket({
+            op: VoiceOpcodes.DAVE_TRANSITION_READY,
+            d: { transition_id: packet.d.transition_id },
+          });
+        }
+        if (packet.d.transition_id === 0) this.emit('transitioned', 0);
+        break;
+      }
+      case VoiceOpcodes.DAVE_EXECUTE_TRANSITION: {
+        const transitioned = dave.executeTransition(packet.d.transition_id);
+        if (transitioned) this.emit('transitioned', packet.d.transition_id);
+        break;
+      }
+      case VoiceOpcodes.DAVE_PREPARE_EPOCH:
+        dave.prepareEpoch(packet.d);
+        break;
+      default:
+        break;
+    }
+  }
+
   /**
    * Called whenever a valid packet is received from the WebSocket.
    * @param {Object} packet The received packet
@@ -169,9 +413,24 @@ class VoiceWebSocket extends EventEmitter {
   onPacket(packet) {
     this.emit('debug', `[WS] << ${JSON.stringify(packet)}`);
     if (packet.seq) this._sequenceNumber = packet.seq;
+
+    if (
+      [
+        VoiceOpcodes.DAVE_PREPARE_TRANSITION,
+        VoiceOpcodes.DAVE_EXECUTE_TRANSITION,
+        VoiceOpcodes.DAVE_PREPARE_EPOCH,
+      ].includes(packet.op)
+    ) {
+      if (!this.usesSharedDaveSession()) this.handleDavePacket(packet);
+      return;
+    }
+
     switch (packet.op) {
       case VoiceOpcodes.HELLO:
         this.setHeartbeat(packet.d.heartbeat_interval);
+        this.sendIdentify().catch(() => {
+          this.emit('error', new Error('VOICE_JOIN_SOCKET_CLOSED'));
+        });
         break;
       case VoiceOpcodes.READY:
         /**
@@ -180,11 +439,11 @@ class VoiceWebSocket extends EventEmitter {
          * @event VoiceWebSocket#ready
          */
         this.emit('ready', packet.d);
-        this.connection.setVideoStatus(false);
         break;
       /* eslint-disable no-case-declarations */
       case VoiceOpcodes.SESSION_DESCRIPTION:
         packet.d.secret_key = new Uint8Array(packet.d.secret_key);
+        this.setupDaveSession(packet.d.dave_protocol_version ?? 0);
         /**
          * Emitted once the Voice Websocket receives a description of this voice session.
          * @param {Object} packet The received packet
@@ -192,6 +451,9 @@ class VoiceWebSocket extends EventEmitter {
          */
         this.emit('sessionDescription', packet.d);
         break;
+      case VoiceOpcodes.CLIENTS_CONNECT:
+        for (const id of packet.d.user_ids) this.connection.connectedClients.add(id);
+        break;
       case VoiceOpcodes.CLIENT_CONNECT:
         this.connection.ssrcMap.set(+packet.d.audio_ssrc, {
           userId: packet.d.user_id,
@@ -200,6 +462,7 @@ class VoiceWebSocket extends EventEmitter {
         });
         break;
       case VoiceOpcodes.CLIENT_DISCONNECT:
+        this.connection.connectedClients.delete(packet.d.user_id);
         const streamInfo = this.connection.receiver && this.connection.receiver.packets.streams.get(packet.d.user_id);
         if (streamInfo) {
           this.connection.receiver.packets.streams.delete(packet.d.user_id);
@@ -258,10 +521,7 @@ class VoiceWebSocket extends EventEmitter {
    * Clears a heartbeat interval, if one exists.
    */
   clearHeartbeat() {
-    if (!this.heartbeatInterval) {
-      this.emit('warn', 'Tried to clear a heartbeat interval that does not exist');
-      return;
-    }
+    if (!this.heartbeatInterval) return;
     clearInterval(this.heartbeatInterval);
     this.heartbeatInterval = null;
   }

package/src/client/voice/player/MediaPlayer.js

@@ -214,7 +214,9 @@ class MediaPlayer extends EventEmitter {
       args.push(...FFMPEG_H265_ARGUMENTS(options));
     }
 
-    args.push('-force_key_frames', '00:02');
+    if (options?.fps) {
+      args.push('-g', String(options.fps), '-keyint_min', String(options.fps), '-sc_threshold', '0');
+    }
 
     if (options?.inputFFmpegArgs) {
       args.unshift(...options.inputFFmpegArgs);