safeness-sb-new 0.0.1

package/src/client/voice/receiver/PacketHandler.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const EventEmitter = require('events');
+const { Buffer } = require('node:buffer');
+const { setTimeout } = require('node:timers');
+const { IvfJoinner } = require('./video/IvfJoinner');
+const Speaking = require('../../../util/Speaking');
+const secretbox = require('../util/Secretbox');
+const { SILENCE_FRAME } = require('../util/Silence');
+
+// The delay between packets when a user is considered to have stopped speaking
+// https://github.com/discordjs/discord.js/issues/3524#issuecomment-540373200
+const DISCORD_SPEAKING_DELAY = 250;
+
+class Readable extends require('stream').Readable {
+  _read() {} // eslint-disable-line no-empty-function
+}
+
+class PacketHandler extends EventEmitter {
+  constructor(receiver) {
+    super();
+    this.nonce = Buffer.alloc(24);
+    this.receiver = receiver;
+    this.streams = new Map();
+    this.videoStreams = new Map();
+    this.speakingTimeouts = new Map();
+  }
+
+  get connection() {
+    return this.receiver.connection;
+  }
+
+  _stoppedSpeaking(userId) {
+    const streamInfo = this.streams.get(userId);
+    if (streamInfo && streamInfo.end === 'silence') {
+      this.streams.delete(userId);
+      streamInfo.stream.push(null);
+    }
+  }
+
+  makeStream(user, end) {
+    if (this.streams.has(user)) return this.streams.get(user).stream;
+    const stream = new Readable();
+    stream.on('end', () => this.streams.delete(user));
+    this.streams.set(user, { stream, end });
+    return stream;
+  }
+
+  makeVideoStream(user) {
+    if (this.videoStreams.has(user)) return this.videoStreams.get(user);
+    const stream = new IvfJoinner('VP8'); // Test VP8 ok
+    stream.stream.on('end', () => this.videoStreams.delete(user));
+    this.videoStreams.set(user, stream);
+    return stream;
+  }
+
+  parseBuffer(buffer) {
+    const { secret_key, mode } = this.receiver.connection.authentication;
+
+    // Choose correct nonce depending on encryption
+    let end;
+    if (mode === 'xsalsa20_poly1305_lite') {
+      buffer.copy(this.nonce, 0, buffer.length - 4);
+      end = buffer.length - 4;
+    } else if (mode === 'xsalsa20_poly1305_suffix') {
+      buffer.copy(this.nonce, 0, buffer.length - 24);
+      end = buffer.length - 24;
+    } else {
+      buffer.copy(this.nonce, 0, 0, 12);
+    }
+
+    // Open packet
+    if (!secret_key) return new Error('secret_key cannot be null or undefined');
+    let packet = secretbox.methods.open(buffer.slice(12, end), this.nonce, secret_key);
+    if (!packet) return new Error('Failed to decrypt voice packet');
+    packet = Buffer.from(packet);
+
+    // Strip RTP Header Extensions (one-byte only)
+    if (packet[0] === 0xbe && packet[1] === 0xde) {
+      const headerExtensionLength = packet.readUInt16BE(2);
+      packet = packet.subarray(4 + 4 * headerExtensionLength);
+    }
+
+    // Ex VP8
+    // <Buffer 90 80 80 00 30 b7 01 9d 01 2a 80 07 38 04 0b c7 08 85 85 88 99 84 88 3f 82 00 06 16 04 f7 06 81 64 9f 6b db 9b 27 38 7b 27 38 7b 27 38 7b 27 38 7b 27 ... 1154 more bytes>
+    // 90 80: payloadDescriptorBuf (90 80 if first frame | 80 80 else)
+    // 80 00: pictureIdBuf
+    // n bytes: chunk raw (Ivf splitter)
+
+    return packet;
+  }
+
+  push(buffer) {
+    const ssrc = buffer.readUInt32BE(8);
+    const userStat = this.connection.ssrcMap.get(ssrc) || this.connection.ssrcMap.get(ssrc - 1); // Maybe vidoe_ssrc ?
+
+    if (!userStat) return;
+
+    let opusPacket;
+    const streamInfo = this.streams.get(userStat.userId);
+    const videoStreamInfo = this.videoStreams.get(userStat.userId);
+
+    // If the user is in video, we need to check if the packet is just silence
+    if (userStat.hasVideo) {
+      opusPacket = this.parseBuffer(buffer);
+      if (opusPacket instanceof Error) {
+        // Only emit an error if we were actively receiving packets from this user
+        if (streamInfo || videoStreamInfo) {
+          this.emit('error', opusPacket);
+        }
+        return;
+      }
+      if (SILENCE_FRAME.equals(opusPacket)) {
+        // If this is a silence frame, pretend we never received it
+        return;
+      }
+    }
+
+    let speakingTimeout = this.speakingTimeouts.get(ssrc);
+    // Only for voice... idk
+    if (this.connection.ssrcMap.has(ssrc)) {
+      if (typeof speakingTimeout === 'undefined') {
+        // Ensure at least the speaking bit is set.
+        // As the object is by reference, it's only needed once per client re-connect.
+        if (userStat.speaking === 0) {
+          userStat.speaking = Speaking.FLAGS.SPEAKING;
+        }
+        this.connection.onSpeaking({ user_id: userStat.userId, ssrc: ssrc, speaking: userStat.speaking });
+        speakingTimeout = setTimeout(() => {
+          try {
+            this.connection.onSpeaking({ user_id: userStat.userId, ssrc: ssrc, speaking: 0 });
+            clearTimeout(speakingTimeout);
+            this.speakingTimeouts.delete(ssrc);
+          } catch {
+            // Connection already closed, ignore
+          }
+        }, DISCORD_SPEAKING_DELAY).unref();
+        this.speakingTimeouts.set(ssrc, speakingTimeout);
+      } else {
+        speakingTimeout.refresh();
+      }
+    }
+
+    if (streamInfo) {
+      const { stream } = streamInfo;
+      if (!opusPacket) {
+        opusPacket = this.parseBuffer(buffer);
+        if (opusPacket instanceof Error) {
+          this.emit('error', opusPacket);
+          return;
+        }
+      }
+      stream.push(opusPacket);
+    }
+
+    if (videoStreamInfo) {
+      const stream = videoStreamInfo;
+      if (!opusPacket) {
+        opusPacket = this.parseBuffer(buffer);
+        if (opusPacket instanceof Error) {
+          this.emit('error', opusPacket);
+          return;
+        }
+      }
+      stream.push(opusPacket); // VP8 ? idk
+    }
+  }
+}
+
+module.exports = PacketHandler;

package/src/client/voice/receiver/Receiver.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const EventEmitter = require('events');
+const prism = require('prism-media');
+const PacketHandler = require('./PacketHandler');
+const { Error } = require('../../../errors');
+
+/**
+ * Receives audio packets from a voice connection.
+ * @example
+ * const receiver = connection.createReceiver();
+ * // opusStream is a ReadableStream - that means you could play it back to a voice channel if you wanted to!
+ * const opusStream = receiver.createStream(user);
+ */
+class VoiceReceiver extends EventEmitter {
+  constructor(connection) {
+    super();
+    this.connection = connection;
+    this.packets = new PacketHandler(this);
+    /**
+     * Emitted whenever there is a warning
+     * @event VoiceReceiver#debug
+     * @param {Error|string} error The error or message to debug
+     */
+    this.packets.on('error', err => this.emit('debug', err));
+  }
+
+  /**
+   * Options passed to `VoiceReceiver#createStream`.
+   * @typedef {Object} ReceiveStreamOptions
+   * @property {string} [mode='opus'] The mode for audio output. This defaults to opus, meaning discord.js won't decode
+   * the packets for you. You can set this to 'pcm' so that the stream's output will be 16-bit little-endian stereo
+   * audio
+   * @property {string} [end='silence'] When the stream should be destroyed. If `silence`, this will be when the user
+   * stops talking. Otherwise, if `manual`, this should be handled by you.
+   */
+
+  /**
+   * Creates a new audio receiving stream. If a stream already exists for a user, then that stream will be returned
+   * rather than generating a new one.
+   * @param {UserResolvable} user The user to start listening to.
+   * @param {ReceiveStreamOptions} options Options.
+   * @returns {ReadableStream}
+   */
+  createStream(user, { mode = 'opus', end = 'silence' } = {}) {
+    user = this.connection.client.users.resolve(user);
+    if (!user) throw new Error('VOICE_USER_MISSING');
+    const stream = this.packets.makeStream(user.id, end);
+    if (mode === 'pcm') {
+      const decoder = new prism.opus.Decoder({ channels: 2, rate: 48000, frameSize: 960 });
+      stream.pipe(decoder);
+      return decoder;
+    }
+    return stream;
+  }
+
+  /**
+   * Creates a new video receiving stream. If a stream already exists for a user, then that stream will be returned
+   * rather than generating a new one.
+   * @param {UserResolvable} user The user to start listening to.
+   * @returns {IvfJoinner}
+   * @deprecated Only support VP8
+   * @example
+   * const video = connection.receiver.createVideoStream('1071734918972985395');
+   * video.stream.pipe(fs.createWriteStream('test.ivf'));
+   * setTimeout(() => {
+   *   video.stop();
+   *   video.createFinalFile(
+   * 		fs.createReadStream('test.ivf'),
+   * 	  fs.createWriteStream('final.ivf'),
+   *   );
+   * }, 10_000);
+   */
+  createVideoStream(user) {
+    user = this.connection.client.users.resolve(user);
+    if (!user) throw new Error('VOICE_USER_MISSING');
+    const stream = this.packets.makeVideoStream(user.id);
+    return stream;
+  }
+}
+
+module.exports = VoiceReceiver;

package/src/client/voice/receiver/video/IvfJoinner.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const { Buffer } = require('buffer');
+const { setTimeout } = require('timers');
+
+class Readable extends require('stream').Readable {
+  _read() {} // eslint-disable-line no-empty-function
+}
+
+/**
+ * Receives video packets from a voice connection.
+ */
+class IvfJoinner {
+  constructor(codec = 'VP8') {
+    this.codec = codec;
+    this.ivfHeader = this.getHeaderIvf();
+    this.count = 0;
+    /**
+     * Readable stream
+     * @type {Readable}
+     */
+    this.stream = new Readable();
+    this._tempBuffer = null;
+    this._fps = 0;
+    this.timeConvert = null;
+    this.lastConvert = null;
+    this.firstFrame = Buffer.from([0x90, 0x80]);
+    this._timeoutFps = null;
+  }
+  getHeaderIvf() {
+    const ivfHeader = Buffer.alloc(32);
+    ivfHeader.write('DKIF'); // Signature
+    ivfHeader.writeUInt16LE(0, 4); // Version
+    ivfHeader.writeUInt16LE(32, 6); // Header length
+    ivfHeader.write(`${this.codec}0`, 8); // Codec FourCC
+    ivfHeader.writeUInt16LE(0, 12); // Width
+    ivfHeader.writeUInt16LE(0, 14); // Height
+    ivfHeader.writeUInt32LE(this._fps, 16); // Frame rate
+    ivfHeader.writeUInt32LE(1, 20); // Framerate denominator
+    ivfHeader.writeUInt32LE(this.count + 1, 24); // Frame count
+    return ivfHeader;
+  }
+  getFramedata() {
+    const frameHeader = Buffer.alloc(12);
+    frameHeader.writeUInt32LE(this._tempBuffer.length, 0); // Frame size
+    frameHeader.writeUInt32LE(this.count, 4); // Timestamp
+    return frameHeader;
+  }
+  push(bufferRaw) {
+    if (!this._timeoutFps) {
+      this._timeoutFps = setTimeout(() => {
+        if (this.stream.destroyed) return;
+        this._fps = Math.round((this.lastConvert - this.timeConvert) / this.count);
+        // ! Todo: need improved
+        this._timeoutFps = null;
+      }, 500).unref();
+    }
+    if (!this.timeConvert) {
+      this.timeConvert = performance.now();
+    }
+    // Ex VP8
+    // <Buffer 90 80 80 00 30 b7 01 9d 01 2a 80 07 38 04 0b c7 08 85 85 88 99 84 88 3f 82 00 06 16 04 f7 06 81 64 9f 6b db 9b 27 38 7b 27 38 7b 27 38 7b 27 38 7b 27 ... 1154 more bytes>
+    // 90 80: payloadDescriptorBuf (90 80 if first frame | 80 80 else)
+    // 80 00: pictureIdBuf
+    // n bytes: chunk raw (Ivf splitter)
+    const payloadDescriptorBuf = bufferRaw.slice(0, 2);
+    const data = bufferRaw.slice(4);
+    const isFirstFrame = Buffer.compare(payloadDescriptorBuf, this.firstFrame) === 0;
+    if (isFirstFrame && this._tempBuffer) {
+      this.count++;
+      this.lastConvert = performance.now();
+      this.stream.push(Buffer.concat([this.getFramedata(), this._tempBuffer]));
+      this._tempBuffer = null;
+    }
+    if (!this._tempBuffer) {
+      this._tempBuffer = data;
+    } else {
+      this._tempBuffer = Buffer.concat([this._tempBuffer, data]);
+    }
+  }
+  /**
+   * Force stop stream
+   * @returns {void}
+   */
+  stop() {
+    this.stream.push(null);
+    this.stream.emit('end'); // Force close stream;
+    this.stream.destroy();
+  }
+  /**
+   * Convert partial file to full file
+   * @param {Readable} readable File created by stream (Raw)
+   * @param {Writable} writeable Output (Ivf)
+   * @returns {void}
+   */
+  createFinalFile(readable, writeable) {
+    if (this.stream.destroyed) {
+      writeable.write(this.getHeaderIvf());
+      readable.pipe(writeable);
+    }
+  }
+}
+
+module.exports = {
+  IvfJoinner,
+};

package/src/client/voice/util/Function.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function parseStreamKey(key) {
+  const Arr = key.split(':');
+  const type = Arr[0];
+  const guildId = type == 'guild' ? Arr[1] : null;
+  const channelId = type == 'guild' ? Arr[2] : Arr[1];
+  const userId = type == 'guild' ? Arr[3] : Arr[2];
+  return { type, guildId, channelId, userId };
+}
+
+module.exports = {
+  parseStreamKey,
+};

package/src/client/voice/util/PlayInterface.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const { Readable } = require('stream');
+const prism = require('prism-media');
+const { Error } = require('../../../errors');
+
+/**
+ * Options that can be passed to stream-playing methods:
+ * @typedef {Object} StreamOptions
+ * @property {StreamType} [type='unknown'] The type of stream.
+ * @property {number} [seek=0] The time to seek to, will be ignored when playing `ogg/opus` or `webm/opus` streams
+ * @property {number|boolean} [volume=1] The volume to play at. Set this to false to disable volume transforms for
+ * this stream to improve performance.
+ * @property {number} [plp] Expected packet loss percentage
+ * @property {boolean} [fec] Enabled forward error correction
+ * @property {number|string} [bitrate=96] The bitrate (quality) of the audio in kbps.
+ * If set to 'auto', the voice channel's bitrate will be used
+ * @property {number} [highWaterMark=12] The maximum number of opus packets to make and store before they are
+ * actually needed. See https://nodejs.org/en/docs/guides/backpressuring-in-streams/. Setting this value to
+ * 1 means that changes in volume will be more instant.
+ */
+
+/**
+ * An option passed as part of `StreamOptions` specifying the type of the stream.
+ * * `unknown`: The default type, streams/input will be passed through to ffmpeg before encoding.
+ * Will play most streams.
+ * * `converted`: Play a stream of 16bit signed stereo PCM data, skipping ffmpeg.
+ * * `opus`: Play a stream of opus packets, skipping ffmpeg. You lose the ability to alter volume.
+ * * `ogg/opus`: Play an ogg file with the opus encoding, skipping ffmpeg. You lose the ability to alter volume.
+ * * `webm/opus`: Play a webm file with opus audio, skipping ffmpeg. You lose the ability to alter volume.
+ * @typedef {string} StreamType
+ */
+
+/**
+ * An interface class to allow you to play audio over VoiceConnections.
+ */
+class PlayInterface {
+  constructor(player) {
+    this.player = player;
+  }
+
+  /**
+   * Play an audio resource.
+   * @param {ReadableStream|string} resource The resource to play.
+   * @param {StreamOptions} [options] The options to play.
+   * @example
+   * // Play a local audio file
+   * connection.playAudio('/home/hydrabolt/audio.mp3', { volume: 0.5 });
+   * @example
+   * // Play a ReadableStream
+   * connection.playAudio(ytdl('https://www.youtube.com/watch?v=ZlAU_w7-Xp8', { quality: 'highestaudio' }));
+   * @example
+   * // Using different protocols: https://ffmpeg.org/ffmpeg-protocols.html
+   * connection.playAudio('http://www.sample-videos.com/audio/mp3/wave.mp3');
+   * @returns {AudioDispatcher}
+   */
+  playAudio(resource, options = {}) {
+    if (resource instanceof Readable || typeof resource === 'string') {
+      const type = options.type || 'unknown';
+      if (type === 'unknown') {
+        return this.player.playUnknown(resource, options);
+      } else if (type === 'converted') {
+        return this.player.playPCMStream(resource, options);
+      } else if (type === 'opus') {
+        return this.player.playOpusStream(resource, options);
+      } else if (type === 'ogg/opus') {
+        if (!(resource instanceof Readable)) throw new Error('VOICE_PRISM_DEMUXERS_NEED_STREAM');
+        return this.player.playOpusStream(resource.pipe(new prism.opus.OggDemuxer()), options);
+      } else if (type === 'webm/opus') {
+        if (!(resource instanceof Readable)) throw new Error('VOICE_PRISM_DEMUXERS_NEED_STREAM');
+        return this.player.playOpusStream(resource.pipe(new prism.opus.WebmDemuxer()), options);
+      }
+    }
+    throw new Error('VOICE_PLAY_INTERFACE_BAD_TYPE');
+  }
+
+  /**
+   * Options that can be passed to stream-playing methods:
+   * @typedef {Object} VideoOptions
+   * @property {number} [seek=0] The time to seek to, will be ignored when playing `ogg/opus` or `webm/opus` streams
+   * @property {number} [fps=30] Video fps
+   * @property {number} [highWaterMark=12] The maximum number of opus packets to make and store before they are
+   * actually needed. See https://nodejs.org/en/docs/guides/backpressuring-in-streams/. Setting this value to
+   * 1 means that changes in volume will be more instant.
+   * @property {'ultrafast' | 'superfast' | 'veryfast' | 'faster' | 'fast' | 'medium' | 'slow' | 'slower' | 'veryslow'} [presetH26x='veryfast'] ffmpeg preset h254 / h265
+   * @property {boolean} [hwAccel=false]  Enables hardware accelerated video decoding. Enabling this option might result in an exception
+   * being thrown by Ffmpeg process if your system does not support hardware acceleration
+   * @property {string[]} [inputFFmpegArgs] input ffmpeg
+   * Ex: ['-config1', 'value1', '-config2', 'value2']
+   * @property {string[]} [outputFFmpegArgs] output ffmpeg
+   * Ex: ['-config1', 'value1', '-config2', 'value2']
+   * @property {number|'auto'} [bitrate=2000] The bitrate (quality) of the video in kbps.
+   * If set to 'auto', ffmpeg will automatically select
+   */
+
+  /**
+   * Play an video resource.
+   * @param {ReadableStream|string} resource The resource to play.
+   * @param {VideoOptions} [options] The options to play.
+   * @example
+   * // Play a local video file
+   * connection.playVideo('/home/hydrabolt/video.mp4');
+   * @example
+   * // Using different protocols: https://ffmpeg.org/ffmpeg-protocols.html
+   * connection.playVideo('http://www.sample-videos.com/video/mp4/wave.mp4');
+   * @returns {VideoDispatcher}
+   */
+  playVideo(resource, options = {}) {
+    if (resource instanceof Readable || typeof resource === 'string') {
+      return this.player.playUnknownVideo(resource, options);
+    }
+    throw new Error('VOICE_PLAY_INTERFACE_BAD_TYPE');
+  }
+
+  static applyToClass(structure) {
+    for (const prop of ['playAudio', 'playVideo']) {
+      Object.defineProperty(structure.prototype, prop, Object.getOwnPropertyDescriptor(PlayInterface.prototype, prop));
+    }
+  }
+}
+
+module.exports = PlayInterface;

package/src/client/voice/util/Secretbox.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const libs = {
+  sodium: sodium => ({
+    open: sodium.api.crypto_secretbox_open_easy,
+    close: sodium.api.crypto_secretbox_easy,
+    random: n => sodium.randombytes_buf(n),
+  }),
+  'libsodium-wrappers': sodium => ({
+    open: sodium.crypto_secretbox_open_easy,
+    close: sodium.crypto_secretbox_easy,
+    random: n => sodium.randombytes_buf(n),
+  }),
+  tweetnacl: tweetnacl => ({
+    open: tweetnacl.secretbox.open,
+    close: tweetnacl.secretbox,
+    random: n => tweetnacl.randomBytes(n),
+  }),
+};
+
+function NoLib() {
+  throw new Error(
+    'Cannot play audio as no valid encryption package is installed.\n- Install sodium, libsodium-wrappers, or tweetnacl.',
+  );
+}
+
+exports.methods = {
+  open: NoLib,
+  close: NoLib,
+  random: NoLib,
+};
+
+(async () => {
+  for (const libName of Object.keys(libs)) {
+    try {
+      const lib = require(libName);
+      if (libName === 'libsodium-wrappers' && lib.ready) await lib.ready; // eslint-disable-line no-await-in-loop
+      exports.methods = libs[libName](lib);
+      break;
+    } catch {} // eslint-disable-line no-empty
+  }
+})();

package/src/client/voice/util/Silence.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const { Readable } = require('stream');
+
+const SILENCE_FRAME = Buffer.from([0xf8, 0xff, 0xfe]);
+
+class Silence extends Readable {
+  _read() {
+    this.push(SILENCE_FRAME);
+  }
+}
+
+Silence.SILENCE_FRAME = SILENCE_FRAME;
+
+module.exports = Silence;

package/src/client/voice/util/Socket.js

@@ -0,0 +1,62 @@
+'use strict';
+
+/*
+Credit: https://github.com/dank074/Discord-video-stream
+The use of video streaming in this library is an incomplete implementation with many bugs, primarily aimed at lazy users.
+The video streaming features in this library are sourced from https://github.com/dank074/Discord-video-stream.
+
+Please use the @dank074/discord-video-stream library to access all advanced and professional features,
+along with comprehensive support. I will not actively fix bugs related to streaming and encourage everyone to
+use https://github.com/dank074/Discord-video-stream for stable and smooth streaming.
+
+To reiterate: This is an incomplete implementation of the library https://github.com/dank074/Discord-video-stream.
+
+Thanks to dank074 and longnguyen2004 for implementing new codecs (H264, H265).
+Thanks to mrjvs for discovering how Discord transmits data and the VP8 codec.
+
+Please use the @dank074/discord-video-stream library for the best support.
+*/
+
+const fs = require('fs');
+const net = require('net');
+const path = require('path');
+const process = require('process');
+
+let counter = 0;
+
+class UnixStream {
+  constructor(stream, onSocket) {
+    if (process.platform === 'win32') {
+      const pipePrefix = '\\\\.\\pipe\\';
+      const pipeName = `node-webrtc.${++counter}.sock`;
+      this.socketPath = path.join(pipePrefix, pipeName);
+      this.url = this.socketPath;
+    } else {
+      this.socketPath = `./${++counter}.sock`;
+      this.url = `unix:${this.socketPath}`;
+    }
+
+    try {
+      fs.statSync(this.socketPath);
+      fs.unlinkSync(this.socketPath);
+    } catch (err) {
+      // Null
+    }
+
+    const server = net.createServer(onSocket);
+    stream.on('finish', () => {
+      server.close();
+    });
+    server.listen(this.socketPath);
+  }
+}
+
+function StreamInput(stream) {
+  return new UnixStream(stream, socket => stream.pipe(socket));
+}
+
+function StreamOutput(stream) {
+  return new UnixStream(stream, socket => socket.pipe(stream));
+}
+
+module.exports = { StreamOutput, StreamInput, UnixStream };