djs-selfbot-v13 3.7.34 → 3.7.35

package/package.json

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

package/src/client/voice/WebRtcStreamSession.js

@@ -53,14 +53,44 @@ class WebRtcStreamSession extends EventEmitter {
     this._abort = new AbortController();
     this._playPromise = null;
     this._command = null;
+    this._ffmpegProc = null;
     this._started = false;
+    this._running = false;
+    this._paused = false;
+    this._stopped = false;
+    this._positionMs = 0;
+    this._runStartWall = 0;
+    this._pausedAt = 0;
+    this._pausedTotalMs = 0;
+  }
+
+  _getPositionMs() {
+    if (!this._running) return this._positionMs;
+    if (this._paused) return this._positionMs;
+    return this._positionMs + (Date.now() - this._runStartWall - this._pausedTotalMs);
+  }
+
+  _resetRunClock() {
+    this._runStartWall = Date.now();
+    this._pausedAt = 0;
+    this._pausedTotalMs = 0;
+  }
+
+  _signalFfmpeg(signal) {
+    const pid = this._ffmpegProc?.pid;
+    if (!pid) return;
+    try {
+      process.kill(pid, signal);
+    } catch {
+      // process already exited
+    }
   }
 
   /**
    * Construit la commande ffmpeg : transcode en H264 + Opus, sortie nut.
    * Pas de filtre azmq (compatibilité ffmpeg sans libzmq).
    */
-  _buildFfmpeg(url) {
+  _buildFfmpeg(url, seekSec = 0) {
     const {
       fps,
       height = 720,
@@ -78,6 +108,8 @@ class WebRtcStreamSession extends EventEmitter {
     const output = new PassThrough();
     const command = ffmpeg(url);
 
+    if (seekSec > 0) command.seekInput(seekSec);
+
     const isHttp = typeof url === 'string' && /^https?:\/\//i.test(url);
     if (isHttp) {
       command.inputOptions([
@@ -123,13 +155,21 @@ class WebRtcStreamSession extends EventEmitter {
     return { command, output };
   }
 
-  async _run(url, signal) {
+  async _run(url, signal, seekSec = 0) {
     await ensureFfmpegPath();
 
-    const { command, output } = this._buildFfmpeg(url);
+    const { command, output } = this._buildFfmpeg(url, seekSec);
     this._command = command;
+    this._ffmpegProc = null;
+    this._running = true;
+    this._paused = false;
+    this._stopped = false;
+    this._resetRunClock();
 
-    command.on('start', cmd => this.emit('debug', `[cmd] ${cmd}`));
+    command.on('start', cmd => {
+      this._ffmpegProc = command.ffmpegProc ?? null;
+      this.emit('debug', `[cmd] ${cmd}`);
+    });
     command.on('stderr', line => this.emit('debug', String(line)));
 
     command.on('error', (err, _stdout, stderr) => {
@@ -139,7 +179,12 @@ class WebRtcStreamSession extends EventEmitter {
       this.emit('error', new Error(stderr ? `${msg}\n${stderr}` : msg));
     });
 
-    signal.addEventListener('abort', () => command.kill('SIGTERM'), { once: true });
+    const onAbort = () => {
+      this._running = false;
+      this._ffmpegProc = null;
+      command.kill('SIGTERM');
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
     command.run();
 
     const { livestream } = this.options;
@@ -149,8 +194,17 @@ class WebRtcStreamSession extends EventEmitter {
     this._playPromise = playStream(output, this.streamer, playOptions, signal);
 
     this._playPromise
-      .then(() => this.emit('finish'))
+      .then(() => {
+        this._running = false;
+        this._ffmpegProc = null;
+        if (!signal.aborted) {
+          this._positionMs = 0;
+          this.emit('finish');
+        }
+      })
       .catch(err => {
+        this._running = false;
+        this._ffmpegProc = null;
         if (signal.aborted || err?.name === 'AbortError') return;
         this.emit('error', err);
       });
@@ -171,14 +225,56 @@ class WebRtcStreamSession extends EventEmitter {
     void this._run(url, this._abort.signal);
   }
 
+  /**
+   * Met en pause la lecture (ffmpeg suspendu, connexion vocale conservée).
+   */
+  pause() {
+    if (!this._running || this._paused || this._stopped) return;
+    this._positionMs = this._getPositionMs();
+    this._pausedAt = Date.now();
+    this._signalFfmpeg('SIGSTOP');
+    this._paused = true;
+  }
+
+  /**
+   * Reprend la lecture (après pause ou stop).
+   */
+  async resume() {
+    if (this._stopped) {
+      const seekSec = this._positionMs / 1000;
+      this._stopped = false;
+      await this._run(this.options.url, this._abort.signal, seekSec);
+      return;
+    }
+    if (!this._running || !this._paused) return;
+    this._pausedTotalMs += Date.now() - this._pausedAt;
+    this._pausedAt = 0;
+    this._signalFfmpeg('SIGCONT');
+    this._paused = false;
+  }
+
+  /**
+   * Arrête la lecture en conservant la position et la connexion vocale.
+   */
   stop() {
+    if (!this._running) return;
+    this._positionMs = this._getPositionMs();
+    this._stopped = true;
+    this._paused = false;
+    this._running = false;
+    this._ffmpegProc = null;
     this._abort.abort();
+    this._abort = new AbortController();
   }
 
+  /**
+   * Relance depuis la dernière position enregistrée.
+   */
   async replay() {
-    this.stop();
-    this._abort = new AbortController();
-    await this._run(this.options.url, this._abort.signal);
+    const seekSec = (this._running ? this._getPositionMs() : this._positionMs) / 1000;
+    if (this._running) this.stop();
+    this._stopped = false;
+    await this._run(this.options.url, this._abort.signal, seekSec);
   }
 
   disconnect() {

package/typings/index.d.ts

@@ -918,7 +918,7 @@ export class Client<Ready extends boolean = boolean> extends BaseClient {
       }
     >
   >;
-  public startStream(options: StartStreamOptions): Promise<StreamSession>;
+  public startStream(options: StartStreamOptions): Promise<WebRtcStreamSession>;
 
   public on<K extends keyof ClientEvents>(event: K, listener: (...args: ClientEvents[K]) => Awaitable<void>): this;
   public on<S extends string | symbol>(
@@ -1208,10 +1208,30 @@ export interface StartStreamOptions {
   downloadHttp?: boolean;
   /** Max video bitrate in kbps. Default: bitrate * 1.5 */
   bitrateMax?: number;
+  /** x264 tune (ex. film). */
+  tune?: string;
+  /** readrateInitialBurst pour sources live. */
+  livestream?: boolean;
   /** Low-latency encoding and playback. Default true. */
   lowLatency?: boolean;
 }
 
+/** Session Go Live WebRTC retournée par {@link Client#startStream}. */
+export class WebRtcStreamSession extends EventEmitter {
+  public readonly client: Client;
+  public pause(): void;
+  public resume(): Promise<void>;
+  public stop(): void;
+  public replay(): Promise<void>;
+  public disconnect(): void;
+  public on(event: 'finish', listener: () => void): this;
+  public on(event: 'debug', listener: (message: string) => void): this;
+  public on(event: 'error', listener: (error: Error) => void): this;
+  public once(event: 'finish', listener: () => void): this;
+  public once(event: 'debug', listener: (message: string) => void): this;
+  public once(event: 'error', listener: (error: Error) => void): this;
+}
+
 export class StreamSession extends EventEmitter {
   public readonly client: Client;
   public readonly voiceConnection: VoiceConnection;