djs-selfbot-v13 3.7.32 → 3.7.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-selfbot-v13",
-  "version": "3.7.32",
+  "version": "3.7.34",
   "description": "An unofficial discord.js fork for creating selfbots",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",
@@ -51,6 +51,8 @@
   },
   "homepage": "https://djs-selfbot.vercel.app/",
   "dependencies": {
+    "@dank074/discord-video-stream": "^6.0.0",
+    "@snazzah/davey": "^0.1.11",
     "@discordjs/builders": "^1.6.3",
     "@discordjs/collection": "^2.1.1",
     "@sapphire/async-queue": "^1.5.5",
@@ -68,6 +70,11 @@
     "werift-rtp": "^0.8.4",
     "ws": "^8.16.0"
   },
+  "optionalDependencies": {
+    "@snazzah/davey-linux-x64-gnu": "0.1.11",
+    "@snazzah/davey-linux-x64-musl": "0.1.11",
+    "@snazzah/davey-win32-x64-msvc": "0.1.11"
+  },
   "engines": {
     "node": ">=20.18"
   },

package/src/client/Client.js

@@ -9,6 +9,8 @@ const { authenticator } = require('otplib');
 const BaseClient = require('./BaseClient');
 const ActionsManager = require('./actions/ActionsManager');
 const ClientVoiceManager = require('./voice/ClientVoiceManager');
+const StreamSession = require('./voice/StreamSession');
+const WebRtcStreamSession = require('./voice/WebRtcStreamSession');
 const WebSocketManager = require('./websocket/WebSocketManager');
 const { Error, TypeError } = require('../errors');
 const BaseGuildEmojiManager = require('../managers/BaseGuildEmojiManager');
@@ -36,7 +38,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 +897,71 @@ 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,
+      height,
+      width,
+      bitrate = 5000,
+      bitrateMax,
+      audioBitrate,
+      preset,
+      tune,
+      audio,
+      livestream = false,
+      downloadHttp = true,
+    } = options;
+
+    if (!url) throw new Error('STREAM_URL_REQUIRED');
+    if (!guildId || !channelId) throw new Error('STREAM_CHANNEL_REQUIRED');
+
+    let playUrl = url;
+    if (typeof url === 'string' && url.startsWith('http') && downloadHttp) {
+      playUrl = await WebRtcStreamSession.resolveUrl(url);
+    }
+
+    const session = new WebRtcStreamSession(this, {
+      guildId,
+      channelId,
+      url: playUrl,
+      fps,
+      height,
+      width,
+      bitrate,
+      bitrateMax,
+      audioBitrate,
+      preset,
+      tune,
+      audio,
+      livestream,
+    });
+
+    await session.start();
+    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,73 @@ 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 guild = channel.guild;
+      if (!guild) {
+        resolve();
+        return;
+      }
+
+      const userId = this.client.user?.id;
+      const voiceState = guild.voiceStates.cache.get(userId);
+      const inVoice = Boolean(voiceState?.channelId);
+      const isStreaming = Boolean(voiceState?.streaming);
+
+      if (this.connection) {
+        this.connection.disconnect();
+        this.connection = null;
+      }
+
+      if (!inVoice && !isStreaming) {
+        resolve();
+        return;
+      }
+
+      const streamKey = `guild:${guild.id}:${voiceState.channelId}:${userId}`;
+      let settled = false;
+      const done = () => {
+        if (settled) return;
+        settled = true;
+        this.client.removeListener(Events.VOICE_STATE_UPDATE, onState);
+        setTimeout(resolve, 500).unref();
+      };
+
+      const onState = (_old, newState) => {
+        if (newState.id !== userId || newState.guild?.id !== guild.id) return;
+        if (!newState.channelId && !newState.streaming) done();
+      };
+
+      this.client.on(Events.VOICE_STATE_UPDATE, onState);
+      this.client.emit('debug', `[VOICE] preJoinCleanup: quitte le salon ${voiceState.channelId}`);
+
+      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: guild.id,
+          channel_id: null,
+          self_mute: false,
+          self_deaf: false,
+        },
+      });
+
+      setTimeout(done, 5000).unref();
+    });
+  }
+
   /**
    * Sets up a request to join a voice channel.
    * @param {VoiceChannel | StageChannel | DMChannel | GroupDMChannel | Snowflake} channel The voice channel to join
@@ -106,28 +177,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 +219,9 @@ class ClientVoiceManager {
           this.connection = null;
         });
       });
+      };
+
+      this.preJoinCleanup(channel).then(startJoin).catch(reject);
     });
   }
 }

package/src/client/voice/StreamSession.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { EventEmitter } = require('events');
+
+/**
+ * Active screenshare session returned by {@link Client#startStream}.
+ * @extends {EventEmitter}
+ */
+class StreamSession extends EventEmitter {
+  /**
+   * Downloads an HTTP(S) video to a temp file (recommended on VPS).
+   * @param {string} url Remote video URL
+   * @returns {Promise<string>} Local file path
+   */
+  static async resolveUrl(url) {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`STREAM_URL_HTTP_${response.status}`);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.length < 1024) throw new Error('STREAM_URL_INVALID');
+    const tmpPath = path.join(os.tmpdir(), `djs-stream-${Date.now()}.mp4`);
+    fs.writeFileSync(tmpPath, buffer);
+    console.log(`[stream] vidéo téléchargée: ${tmpPath} (${(buffer.length / 1024 / 1024).toFixed(2)} Mo)`);
+    return tmpPath;
+  }
+  /**
+   * @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'];
+    } else {
+      videoOptions.inputFFmpegArgs = ['-reconnect', '1', '-reconnect_at_eof', '1', '-reconnect_streamed', '1'];
+    }
+
+    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'];
+      } else {
+        audioOptions.inputFFmpegArgs = ['-reconnect', '1', '-reconnect_at_eof', '1', '-reconnect_streamed', '1'];
+      }
+      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)
+ * @property {boolean} [downloadHttp=true] Download HTTP URLs locally before playback
+ * @property {number} [bitrateMax] Max video bitrate in kbps
+ * @property {boolean} [livestream=false] Enable readrateInitialBurst (live sources)
+ */