djs-selfbot-v13 3.7.32 → 3.7.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-selfbot-v13",
-  "version": "3.7.32",
+  "version": "3.7.33",
   "description": "An unofficial discord.js fork for creating selfbots",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",

package/src/client/Client.js

@@ -9,6 +9,7 @@ const { authenticator } = require('otplib');
 const BaseClient = require('./BaseClient');
 const ActionsManager = require('./actions/ActionsManager');
 const ClientVoiceManager = require('./voice/ClientVoiceManager');
+const StreamSession = require('./voice/StreamSession');
 const WebSocketManager = require('./websocket/WebSocketManager');
 const { Error, TypeError } = require('../errors');
 const BaseGuildEmojiManager = require('../managers/BaseGuildEmojiManager');
@@ -36,7 +37,7 @@ const VoiceRegion = require('../structures/VoiceRegion');
 const Webhook = require('../structures/Webhook');
 const Widget = require('../structures/Widget');
 const Application = require('../structures/interfaces/Application');
-const { Events, Status } = require('../util/Constants');
+const { Events, Status, VoiceStatus } = require('../util/Constants');
 const DataResolver = require('../util/DataResolver');
 const Intents = require('../util/Intents');
 const DiscordAuthWebsocket = require('../util/RemoteAuth');
@@ -895,6 +896,78 @@ class Client extends BaseClient {
     });
   }
 
+  /**
+   * Joins a voice channel, starts a screenshare stream and plays a video.
+   * @param {import('./voice/StreamSession').StartStreamOptions} options Stream options
+   * @returns {Promise<import('./voice/StreamSession')>}
+   * @example
+   * const stream = await client.startStream({
+   *   guildId: '123',
+   *   channelId: '456',
+   *   url: 'video.mp4',
+   *   fps: 60,
+   *   height: 720,
+   *   bitrate: 4500,
+   * });
+   * stream.pause();
+   * stream.resume();
+   * stream.stop();
+   * stream.replay();
+   * stream.disconnect();
+   */
+  async startStream(options = {}) {
+    const {
+      guildId,
+      channelId,
+      url,
+      fps = 30,
+      height,
+      width,
+      bitrate = 2000,
+      audioBitrate,
+      videoCodec = 'H264',
+      preset,
+      audio,
+      video = false,
+    } = options;
+
+    if (!url) throw new Error('STREAM_URL_REQUIRED');
+    if (!guildId || !channelId) throw new Error('STREAM_CHANNEL_REQUIRED');
+
+    const channel =
+      this.guilds.cache.get(guildId)?.channels.cache.get(channelId) ?? this.channels.cache.get(channelId);
+
+    if (!channel) throw new Error('STREAM_CHANNEL_NOT_FOUND');
+
+    const voiceConnection = await this.voice.joinChannel(channel, {
+      selfVideo: Boolean(video),
+      videoCodec,
+    });
+
+    const streamConnection = await voiceConnection.createStreamConnection();
+
+    if (!video && voiceConnection.status === VoiceStatus.CONNECTED) {
+      voiceConnection.setVideoStatus(false);
+    }
+
+    await streamConnection.waitForDaveReady();
+    streamConnection.sendScreenshareState(false);
+
+    const session = new StreamSession(this, voiceConnection, streamConnection, {
+      url,
+      fps,
+      height,
+      width,
+      bitrate,
+      audioBitrate,
+      preset,
+      audio,
+    });
+
+    session._play();
+    return session;
+  }
+
   /**
    * Calls {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/eval} on a script
    * with the client as `this`.

package/src/client/voice/ClientVoiceManager.js

@@ -2,7 +2,7 @@
 
 const VoiceConnection = require('./VoiceConnection');
 const { Error } = require('../../errors');
-const { Events } = require('../../util/Constants');
+const { Events, VoiceStatus, Opcodes } = require('../../util/Constants');
 
 /**
  * Manages voice connections for the client
@@ -60,6 +60,7 @@ class ClientVoiceManager {
 
   onVoiceStateUpdate(payload) {
     const { guild_id, session_id, channel_id } = payload;
+    if (payload.user_id !== this.client.user?.id) return;
     // @discordjs/voice
     if (payload.guild_id && payload.session_id && payload.user_id === this.client.user?.id) {
       this.adapters.get(payload.guild_id)?.onVoiceStateUpdate(payload);
@@ -71,6 +72,9 @@ class ClientVoiceManager {
     this.client.emit('debug', `[VOICE] connection? ${!!connection}, ${guild_id} ${session_id} ${channel_id}`);
     if (!connection) return;
     if (!channel_id) {
+      if (connection.status === VoiceStatus.AUTHENTICATING || connection.status === VoiceStatus.CONNECTING) {
+        return;
+      }
       connection._disconnect();
       this.connection = null;
       return;
@@ -93,6 +97,62 @@ class ClientVoiceManager {
    * @typedef {Object} JoinChannelConfig
    */
 
+  /**
+   * Clears stale voice/stream state before joining a channel.
+   * @param {VoiceChannel} channel The channel to join
+   * @returns {Promise<void>}
+   * @private
+   */
+  preJoinCleanup(channel) {
+    return new Promise(resolve => {
+      const userId = this.client.user?.id;
+      const voiceState = channel.guild?.voiceStates.cache.get(userId);
+      const inTarget = voiceState?.channelId === channel.id;
+      const isStreaming = voiceState?.streaming || this.client.user?.voice?.streaming;
+      const needsCleanup = inTarget && (isStreaming || !this.connection);
+
+      if (!needsCleanup) {
+        resolve();
+        return;
+      }
+
+      const streamKey = `guild:${channel.guild.id}:${channel.id}:${userId}`;
+      let settled = false;
+      const done = () => {
+        if (settled) return;
+        settled = true;
+        this.client.removeListener(Events.VOICE_STATE_UPDATE, onState);
+        setTimeout(resolve, 400).unref();
+      };
+
+      const onState = (_old, newState) => {
+        if (newState.id !== userId) return;
+        if (!newState.channelId && !newState.streaming) done();
+      };
+
+      this.client.on(Events.VOICE_STATE_UPDATE, onState);
+
+      if (isStreaming) {
+        this.client.ws.broadcast({
+          op: Opcodes.STREAM_DELETE,
+          d: { stream_key: streamKey },
+        });
+      }
+
+      this.client.ws.broadcast({
+        op: Opcodes.VOICE_STATE_UPDATE,
+        d: {
+          guild_id: channel.guild.id,
+          channel_id: null,
+          self_mute: false,
+          self_deaf: false,
+        },
+      });
+
+      setTimeout(done, 4000).unref();
+    });
+  }
+
   /**
    * Sets up a request to join a voice channel.
    * @param {VoiceChannel | StageChannel | DMChannel | GroupDMChannel | Snowflake} channel The voice channel to join
@@ -106,28 +166,32 @@ class ClientVoiceManager {
         throw new Error('VOICE_JOIN_CHANNEL', channel.full);
       }
 
+      const startJoin = () => {
       let connection = this.connection;
 
-      if (connection) {
-        if (connection.channel.id !== channel.id) {
-          this.connection.updateChannel(channel);
-        }
+      if (connection?.status === VoiceStatus.CONNECTED && connection.channel.id === channel.id) {
         resolve(connection);
         return;
-      } else {
-        connection = new VoiceConnection(this, channel);
-        if (config?.videoCodec) connection.setVideoCodec(config.videoCodec);
-        connection.on('debug', msg =>
-          this.client.emit('debug', `[VOICE (${channel.guild?.id || channel.id}:${connection.status})]: ${msg}`),
-        );
-        connection.authenticate({
-          self_mute: Boolean(config.selfMute),
-          self_deaf: Boolean(config.selfDeaf),
-          self_video: Boolean(config.selfVideo),
-        });
-        this.connection = connection;
       }
 
+      if (connection) {
+        connection.disconnect();
+        this.connection = null;
+        connection = null;
+      }
+
+      connection = new VoiceConnection(this, channel);
+      if (config?.videoCodec) connection.setVideoCodec(config.videoCodec);
+      connection.on('debug', msg =>
+        this.client.emit('debug', `[VOICE (${channel.guild?.id || channel.id}:${connection.status})]: ${msg}`),
+      );
+      connection.authenticate({
+        self_mute: Boolean(config.selfMute),
+        self_deaf: Boolean(config.selfDeaf),
+        self_video: Boolean(config.selfVideo),
+      });
+      this.connection = connection;
+
       connection.once('failed', reason => {
         this.connection = null;
         reject(reason);
@@ -144,6 +208,9 @@ class ClientVoiceManager {
           this.connection = null;
         });
       });
+      };
+
+      this.preJoinCleanup(channel).then(startJoin).catch(reject);
     });
   }
 }

package/src/client/voice/StreamSession.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const { EventEmitter } = require('events');
+
+/**
+ * Active screenshare session returned by {@link Client#startStream}.
+ * @extends {EventEmitter}
+ */
+class StreamSession extends EventEmitter {
+  /**
+   * @param {import('../Client')} client Discord client
+   * @param {import('./VoiceConnection')} voiceConnection Voice connection
+   * @param {import('./VoiceConnection').StreamConnection} streamConnection Stream connection
+   * @param {StartStreamOptions} options Stream options
+   */
+  constructor(client, voiceConnection, streamConnection, options) {
+    super();
+    this.client = client;
+    this.voiceConnection = voiceConnection;
+    this.streamConnection = streamConnection;
+    this.options = options;
+    this.videoDispatcher = null;
+    this.audioDispatcher = null;
+    this.voiceAudioDispatcher = null;
+    this._positionMs = 0;
+    this._stopped = false;
+
+    const onError = err => this.emit('error', err);
+    streamConnection.on('error', onError);
+    voiceConnection.on('error', onError);
+  }
+
+  _getPositionMs() {
+    if (!this.videoDispatcher) return this._positionMs;
+    return Math.max(0, this.videoDispatcher.totalStreamTime - this.videoDispatcher.pausedTime);
+  }
+
+  _play(seek = 0) {
+    const { url, fps, height, width, bitrate, audioBitrate } = this.options;
+    const streamHeight = height ?? 720;
+    this.streamConnection.videoAttributes = {
+      width: width ?? Math.round((streamHeight * 16) / 9),
+      height: streamHeight,
+      fps: fps ?? 30,
+    };
+    const videoOptions = {
+      fps,
+      bitrate,
+      seek,
+      presetH26x: this.options.preset || 'ultrafast',
+      outputFFmpegArgs: [
+        '-pix_fmt',
+        'yuv420p',
+        '-g',
+        String(fps),
+        '-keyint_min',
+        String(fps),
+        '-sc_threshold',
+        '0',
+        '-force_key_frames',
+        'expr:gte(t,n_forced*1)',
+      ],
+    };
+
+    if (height) {
+      videoOptions.outputFFmpegArgs.unshift('-vf', `scale=-2:${height}`);
+    }
+
+    if (!url.startsWith('http')) {
+      videoOptions.inputFFmpegArgs = ['-re'];
+    }
+
+    this.videoDispatcher = this.streamConnection.playVideo(url, videoOptions);
+
+    if (this.options.audio !== false) {
+      const audioOptions = {
+        type: 'unknown',
+        seek,
+        bitrate: audioBitrate ?? 128,
+      };
+      if (!url.startsWith('http')) {
+        audioOptions.inputFFmpegArgs = ['-re'];
+      }
+      this.voiceAudioDispatcher = this.voiceConnection.playAudio(url, audioOptions);
+      this.audioDispatcher = this.streamConnection.playAudio(url, audioOptions);
+      this.audioDispatcher.setSyncVideoDispatcher(this.videoDispatcher);
+    }
+
+    this._stopped = false;
+    this.videoDispatcher.once('finish', () => {
+      this._positionMs = 0;
+      this.emit('finish');
+    });
+
+    return this.videoDispatcher;
+  }
+
+  /**
+   * Pauses video and audio playback.
+   */
+  pause() {
+    this.videoDispatcher?.pause();
+    this.audioDispatcher?.pause(true);
+    this.voiceAudioDispatcher?.pause(true);
+    this.streamConnection.sendScreenshareState(true);
+  }
+
+  /**
+   * Resumes video and audio playback.
+   */
+  resume() {
+    this.streamConnection.sendScreenshareState(false);
+    this.videoDispatcher?.resume();
+    this.audioDispatcher?.resume();
+    this.voiceAudioDispatcher?.resume();
+  }
+
+  /**
+   * Stops playback while keeping voice/stream connections.
+   */
+  stop() {
+    this._positionMs = this._getPositionMs();
+    this._stopped = true;
+    this.videoDispatcher?.destroy();
+    this.audioDispatcher?.destroy();
+    this.voiceAudioDispatcher?.destroy();
+    this.videoDispatcher = null;
+    this.audioDispatcher = null;
+    this.voiceAudioDispatcher = null;
+  }
+
+  /**
+   * Resumes playback from the last position.
+   * @returns {import('./dispatcher/VideoDispatcher')}
+   */
+  replay() {
+    const seekSec = (this._stopped ? this._positionMs : this._getPositionMs()) / 1000;
+    this.stop();
+    return this._play(seekSec);
+  }
+
+  /**
+   * Stops playback and disconnects from voice and stream.
+   */
+  disconnect() {
+    this.stop();
+    this.streamConnection.disconnect();
+    this.voiceConnection.disconnect();
+  }
+}
+
+module.exports = StreamSession;
+
+/**
+ * @typedef {Object} StartStreamOptions
+ * @property {import('../../util/Snowflake')} guildId Guild id
+ * @property {import('../../util/Snowflake')} channelId Voice channel id
+ * @property {string} url Video URL or file path
+ * @property {number} [fps=30] Video framerate
+ * @property {number} [height] Output height (width auto-scaled)
+ * @property {number} [width] Video width sent to Discord (default: 16:9 from height)
+ * @property {number} [bitrate=2000] Video bitrate in kbps
+ * @property {number} [audioBitrate=128] Audio bitrate in kbps
+ * @property {'H264' | 'VP8'} [videoCodec='H264'] Video codec
+ * @property {string} [preset='ultrafast'] x264 preset
+ * @property {boolean} [audio=true] Whether to play audio
+ * @property {boolean} [video=false] Enable webcam (false = screenshare only)
+ */