piixishstream 0.0.0-stage → 1.0.2

package/package.json

@@ -1,6 +1,83 @@
-{
-  "name": "piixishstream",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+{
+    "name": "piixishstream",
+    "version": "1.0.2",
+    "description": "Experiment for making video streaming work for discord selfbots",
+    "main": "./dist/index.js",
+    "exports": "./dist/index.js",
+    "types": "dist/index.d.ts",
+    "type": "module",
+    "files": [
+        "dist",
+        "src"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "@lng2004/node-datachannel": "0.32.0-20260202",
+        "@snazzah/davey": "^0.1.8",
+        "debug-level": "^4.1.1",
+        "fluent-ffmpeg": "^2.1.3",
+        "node-av": "^5.2.2",
+        "p-debounce": "^5.1.0",
+        "sharp": "^0.34.5",
+        "zeromq": "^6.5.0"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "2.3.8",
+        "@types/fluent-ffmpeg": "^2.1.28",
+        "@types/node": "^25.0.1",
+        "discord.js-selfbot-v13": "^3.7.1",
+        "pkg-pr-new": "^0.0.62",
+        "typescript": "^5.9.3"
+    },
+    "peerDependencies": {
+        "discord.js-selfbot-v13": "^3.6.0"
+    },
+    "engines": {
+        "node": ">=22.4.0"
+    },
+    "scripts": {
+        "build": "tsc",
+        "lint": "biome lint --error-on-warnings .",
+        "lint:fix": "biome lint --write .",
+        "check": "biome check .",
+        "check:fix": "biome check --write ."
+    },
+    "keywords": [
+        "discord",
+        "video",
+        "voice",
+        "stream",
+        "go-live",
+        "webrtc",
+        "dave",
+        "selfbot",
+        "performance",
+        "60fps"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dank074/Discord-video-stream.git"
+    },
+    "contributors": [
+        "Piixish",
+        "Long Nguyen <nguyen.long.908132@gmail.com>",
+        "s074 <torresefrain10@gmail.com>",
+        "mrjvs <jellevs@gmail.com>",
+        "Elysia <71698422+aiko-chan-ai@users.noreply.github.com>",
+        "Fede14 <fede.ferri2001@gmail.com>",
+        "Malthe Morsing Larsen <57196060+malthemorsing@users.noreply.github.com>"
+    ],
+    "license": "ISC",
+    "bugs": {
+        "url": "https://github.com/dank074/Discord-video-stream/issues"
+    },
+    "homepage": "https://github.com/dank074/Discord-video-stream#readme",
+    "pnpm": {
+        "onlyBuiltDependencies": [
+            "@lng2004/node-datachannel",
+            "node-datachannel"
+        ]
+    }
 }

package/src/client/GatewayEvents.ts

@@ -0,0 +1,48 @@
+type GatewayEventGeneric<Type extends string = string, Data = unknown> = {
+  t: Type;
+  d: Data;
+};
+
+export namespace GatewayEvent {
+  export type VoiceStateUpdate = GatewayEventGeneric<
+    "VOICE_STATE_UPDATE",
+    {
+      user_id: string;
+      session_id: string;
+    }
+  >;
+  export type VoiceServerUpdate = GatewayEventGeneric<
+    "VOICE_SERVER_UPDATE",
+    {
+      guild_id: string;
+      channel_id?: string;
+      endpoint: string;
+      token: string;
+    }
+  >;
+  export type StreamCreate = GatewayEventGeneric<
+    "STREAM_CREATE",
+    {
+      stream_key: string;
+      rtc_server_id: string;
+    }
+  >;
+  export type StreamServerUpdate = GatewayEventGeneric<
+    "STREAM_SERVER_UPDATE",
+    {
+      stream_key: string;
+      endpoint: string;
+      token: string;
+    }
+  >;
+}
+
+export type GatewayEvent =
+  | GatewayEvent.VoiceStateUpdate
+  | GatewayEvent.VoiceServerUpdate
+  | GatewayEvent.StreamCreate
+  | GatewayEvent.StreamServerUpdate;
+
+export type GatewayEventMap = {
+  [E in GatewayEvent as E["t"]]: [E["d"]];
+};

package/src/client/GatewayOpCodes.ts

@@ -0,0 +1,40 @@
+export enum GatewayOpCodes {
+  DISPATCH = 0,
+  HEARTBEAT = 1,
+  IDENTIFY = 2,
+  PRESENCE_UPDATE = 3,
+  VOICE_STATE_UPDATE = 4,
+  VOICE_SERVER_PING = 5,
+  RESUME = 6,
+  RECONNECT = 7,
+  REQUEST_GUILD_MEMBERS = 8,
+  INVALID_SESSION = 9,
+  HELLO = 10,
+  HEARTBEAT_ACK = 11,
+  CALL_CONNECT = 13,
+  GUILD_SUBSCRIPTIONS = 14,
+  LOBBY_CONNECT = 15,
+  LOBBY_DISCONNECT = 16,
+  LOBBY_VOICE_STATES_UPDATE = 17,
+  STREAM_CREATE = 18,
+  STREAM_DELETE = 19,
+  STREAM_WATCH = 20,
+  STREAM_PING = 21,
+  STREAM_SET_PAUSED = 22,
+  REQUEST_GUILD_APPLICATION_COMMANDS = 24,
+  EMBEDDED_ACTIVITY_LAUNCH = 25,
+  EMBEDDED_ACTIVITY_CLOSE = 26,
+  EMBEDDED_ACTIVITY_UPDATE = 27,
+  REQUEST_FORUM_UNREADS = 28,
+  REMOTE_COMMAND = 29,
+  GET_DELETED_ENTITY_IDS_NOT_MATCHING_HASH = 30,
+  REQUEST_SOUNDBOARD_SOUNDS = 31,
+  SPEED_TEST_CREATE = 32,
+  SPEED_TEST_DELETE = 33,
+  REQUEST_LAST_MESSAGES = 34,
+  SEARCH_RECENT_MEMBERS = 35,
+  REQUEST_CHANNEL_STATUSES = 36,
+  GUILD_SUBSCRIPTIONS_BULK = 37,
+  GUILD_CHANNELS_RESYNC = 38,
+  REQUEST_CHANNEL_MEMBER_COUNT = 39,
+}

package/src/client/Streamer.ts

@@ -0,0 +1,259 @@
+import { EventEmitter } from "node:events";
+import { VoiceConnection } from "./voice/VoiceConnection.js";
+import { StreamConnection } from "./voice/StreamConnection.js";
+import { GatewayOpCodes } from "./GatewayOpCodes.js";
+import type {
+  Client,
+  DMChannel,
+  GroupDMChannel,
+  VoiceBasedChannel,
+} from "discord.js-selfbot-v13";
+import type { GatewayEvent, GatewayEventMap } from "./GatewayEvents.js";
+import type { WebRtcConnWrapper } from "./voice/WebRtcWrapper.js";
+import { generateStreamKey, parseStreamKey } from "../utils.js";
+
+export class Streamer {
+  private _voiceConnection?: VoiceConnection;
+  private _client: Client;
+  private _gatewayEmitter = new EventEmitter<GatewayEventMap>();
+
+  constructor(client: Client) {
+    this._client = client;
+
+    //listen for messages
+    this.client.on("raw", (packet: GatewayEvent) => {
+      // @ts-expect-error I don't know how to make this work with TypeScript, so whatever
+      this._gatewayEmitter.emit(packet.t, packet.d);
+    });
+  }
+
+  public get client(): Client {
+    return this._client;
+  }
+
+  public get opts() {
+    return {};
+  }
+
+  public get voiceConnection(): VoiceConnection | undefined {
+    return this._voiceConnection;
+  }
+
+  public sendOpcode(code: number, data: unknown): void {
+    this.client.ws.broadcast({
+      op: code,
+      d: data,
+    });
+  }
+
+  public joinVoiceChannel(
+    channel: DMChannel | GroupDMChannel | VoiceBasedChannel,
+  ): Promise<WebRtcConnWrapper> {
+    let guildId: string | null = null;
+
+    if (
+      channel.type === "GUILD_STAGE_VOICE" ||
+      channel.type === "GUILD_VOICE"
+    ) {
+      guildId = channel.guildId;
+    }
+
+    return this.joinVoice(guildId, channel.id);
+  }
+
+  /**
+   * Joins a voice channel and returns a WebRtcConnWrapper object.
+   * @param guild_id the guild id of the voice channel. If null, it will join a DM voice channel.
+   * @param channel_id the channel id of the voice channel
+   * @returns the WebRtcConnWrapper object
+   * @throws Error if the client is not logged in
+   */
+  public joinVoice(
+    guild_id: string | null,
+    channel_id: string,
+  ): Promise<WebRtcConnWrapper> {
+    return new Promise<WebRtcConnWrapper>((resolve, reject) => {
+      if (!this.client.user) {
+        reject("Client not logged in");
+        return;
+      }
+      const user_id = this.client.user.id;
+      const voiceConn = new VoiceConnection(
+        this,
+        guild_id,
+        user_id,
+        channel_id,
+        (conn) => {
+          resolve(conn);
+        },
+      );
+      this._voiceConnection = voiceConn;
+      this._gatewayEmitter.on("VOICE_STATE_UPDATE", (d) => {
+        if (user_id !== d.user_id) return;
+        voiceConn.setSession(d.session_id);
+      });
+      this._gatewayEmitter.on("VOICE_SERVER_UPDATE", (d) => {
+        if (guild_id !== d.guild_id) return;
+
+        // channel_id is not set for guild voice calls
+        if (d.channel_id && channel_id !== d.channel_id) return;
+
+        voiceConn.setTokens(d.endpoint, d.token);
+      });
+      this.signalVideo(false);
+    });
+  }
+
+  public createStream(): Promise<WebRtcConnWrapper> {
+    return new Promise<WebRtcConnWrapper>((resolve, reject) => {
+      if (!this.client.user) {
+        reject("Client not logged in");
+        return;
+      }
+      if (!this.voiceConnection) {
+        reject("cannot start stream without first joining voice channel");
+        return;
+      }
+
+      this.signalStream();
+      const {
+        guildId: clientGuildId,
+        channelId: clientChannelId,
+        session_id,
+      } = this.voiceConnection;
+      const { id: clientUserId } = this.client.user;
+
+      if (!session_id) throw new Error("Session doesn't exist yet");
+      const streamConn = new StreamConnection(
+        this,
+        clientGuildId,
+        clientUserId,
+        clientChannelId,
+        (conn) => {
+          resolve(conn);
+        },
+      );
+      this.voiceConnection.streamConnection = streamConn;
+      this._gatewayEmitter.on("STREAM_CREATE", (d) => {
+        const { channelId, guildId, userId } = parseStreamKey(d.stream_key);
+
+        if (
+          clientGuildId !== guildId ||
+          clientChannelId !== channelId ||
+          clientUserId !== userId
+        )
+          return;
+
+        streamConn.serverId = d.rtc_server_id;
+        streamConn.streamKey = d.stream_key;
+        streamConn.setSession(session_id);
+      });
+      this._gatewayEmitter.on("STREAM_SERVER_UPDATE", (d) => {
+        const { channelId, guildId, userId } = parseStreamKey(d.stream_key);
+
+        if (
+          clientGuildId !== guildId ||
+          clientChannelId !== channelId ||
+          clientUserId !== userId
+        )
+          return;
+
+        streamConn.setTokens(d.endpoint, d.token);
+      });
+    });
+  }
+
+  public async setStreamPreview(image: Buffer): Promise<void> {
+    if (!this.client.token) throw new Error("Please login :)");
+    if (!this.voiceConnection?.streamConnection?.guildId) return;
+    const data = `data:image/jpeg;base64,${image.toString("base64")}`;
+    const { guildId } = this.voiceConnection.streamConnection;
+    const server = await this.client.guilds.fetch(guildId);
+    await server.members.me?.voice.postPreview(data);
+  }
+
+  public stopStream(): void {
+    const stream = this.voiceConnection?.streamConnection;
+
+    if (!stream) return;
+
+    stream.stop();
+
+    this.signalStopStream();
+
+    this.voiceConnection.streamConnection = undefined;
+    this._gatewayEmitter.removeAllListeners("STREAM_CREATE");
+    this._gatewayEmitter.removeAllListeners("STREAM_SERVER_UPDATE");
+  }
+
+  public leaveVoice(): void {
+    this.voiceConnection?.stop();
+
+    this.signalLeaveVoice();
+
+    this._voiceConnection = undefined;
+    this._gatewayEmitter.removeAllListeners("VOICE_STATE_UPDATE");
+    this._gatewayEmitter.removeAllListeners("VOICE_SERVER_UPDATE");
+  }
+
+  public signalVideo(video_enabled: boolean): void {
+    if (!this.voiceConnection) return;
+    const { guildId: guild_id, channelId: channel_id } = this.voiceConnection;
+    this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
+      guild_id: guild_id,
+      channel_id,
+      self_mute: false,
+      self_deaf: true,
+      self_video: video_enabled,
+    });
+  }
+
+  public signalStream(): void {
+    if (!this.voiceConnection) return;
+    const {
+      type,
+      guildId: guild_id,
+      channelId: channel_id,
+      botId: user_id,
+    } = this.voiceConnection;
+
+    const streamKey = generateStreamKey(type, guild_id, channel_id, user_id);
+
+    this.sendOpcode(GatewayOpCodes.STREAM_CREATE, {
+      type,
+      guild_id,
+      channel_id,
+      preferred_region: null,
+    });
+
+    this.sendOpcode(GatewayOpCodes.STREAM_SET_PAUSED, {
+      stream_key: streamKey,
+      paused: false,
+    });
+  }
+
+  public signalStopStream(): void {
+    if (!this.voiceConnection) return;
+    const {
+      type,
+      guildId: guild_id,
+      channelId: channel_id,
+      botId: user_id,
+    } = this.voiceConnection;
+
+    const streamKey = generateStreamKey(type, guild_id, channel_id, user_id);
+    this.sendOpcode(GatewayOpCodes.STREAM_DELETE, {
+      stream_key: streamKey,
+    });
+  }
+
+  public signalLeaveVoice(): void {
+    this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
+      guild_id: null,
+      channel_id: null,
+      self_mute: true,
+      self_deaf: false,
+      self_video: false,
+    });
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,3 @@
+export * from "./voice/index.js";
+export * from "./GatewayOpCodes.js";
+export * from "./Streamer.js";

package/src/client/processing/AnnexBBitstreamReaderWriter.ts

@@ -0,0 +1,148 @@
+export class AnnexBBitstreamReader {
+  private _buffer: Buffer;
+  private _byteOffset = 0;
+  private _bitOffset = 0;
+
+  constructor(buffer: Buffer) {
+    this._buffer = buffer;
+  }
+  public readBits(count: number) {
+    if (count === 0) return 0;
+    let result = 0;
+    while (count > 0) {
+      if (this._byteOffset >= this._buffer.length)
+        throw new Error("Bad byte offset");
+      if (
+        this._bitOffset === 0 &&
+        this._byteOffset >= 2 &&
+        this._buffer[this._byteOffset - 2] === 0 &&
+        this._buffer[this._byteOffset - 1] === 0 &&
+        this._buffer[this._byteOffset] === 3
+      ) {
+        // Skip over emulation prevention
+        this._byteOffset++;
+      }
+      if (this._bitOffset === 0 && count >= 8) {
+        // We're byte aligned, read whole bytes and push in
+        result = (result << 8) | this._buffer[this._byteOffset++];
+        count -= 8;
+      } else {
+        // Read just enough to get us to the next byte
+        const numBitsToRead = Math.min(count, 8 - this._bitOffset);
+        const mask = (1 << numBitsToRead) - 1;
+        const newBits =
+          (this._buffer[this._byteOffset] >>
+            (8 - this._bitOffset - numBitsToRead)) &
+          mask;
+        result = (result << numBitsToRead) | newBits;
+        count -= numBitsToRead;
+        this._bitOffset += numBitsToRead;
+        if (this._bitOffset === 8) {
+          this._bitOffset = 0;
+          this._byteOffset++;
+        }
+      }
+    }
+    return result;
+  }
+  public readUnsigned(bits: number) {
+    return this.readBits(bits);
+  }
+  public readSigned(bits: number) {
+    const unsigned = this.readUnsigned(bits);
+    if (unsigned & (1 << (bits - 1))) return unsigned - (1 << bits);
+    return unsigned;
+  }
+  public readUnsignedExpGolomb() {
+    let leading0 = 0;
+    while (this.readBits(1) === 0) leading0++;
+
+    return (1 << leading0) + this.readBits(leading0) - 1;
+  }
+  public readSignedExpGolomb() {
+    // Mapping: x <= 0 => -2x, x > 0 => 2x - 1
+    const unsigned = this.readUnsignedExpGolomb();
+    if (unsigned % 2 === 0) return unsigned / -2;
+    return (unsigned + 1) / 2;
+  }
+}
+
+export class AnnexBBitstreamWriter {
+  private _arr: number[] = [];
+  private _pendingByte = 0;
+  private _bitOffset = 0;
+
+  public toBuffer() {
+    return Buffer.from(this._arr);
+  }
+  public flush() {
+    // Write the pending byte into the array and reset, taking care of emulation prevention
+    if (
+      this._pendingByte <= 3 &&
+      this._arr.at(-1) === 0 &&
+      this._arr.at(-2) === 0
+    )
+      this._arr.push(3);
+    this._arr.push(this._pendingByte);
+    this._pendingByte = 0;
+    this._bitOffset = 0;
+  }
+  public writeBits(bits: number, count: number) {
+    while (count > 0) {
+      if (this._bitOffset === 0) {
+        if (count >= 8) {
+          // We're byte aligned and has more than 1 byte left to write, write a whole byte
+          this._pendingByte = (bits >> (count - 8)) & 0xff;
+          count -= 8;
+          this.flush();
+        } else {
+          // We have less than 1 byte, write the rest in
+          const mask = (1 << count) - 1;
+          this._pendingByte |= (bits & mask) << (8 - count);
+          this._bitOffset = count;
+          count = 0;
+        }
+      } else {
+        // Write the minimum number of bits to get us byte aligned again
+        const numBitsToWrite = Math.min(8 - this._bitOffset, count);
+        const bitsToWrite =
+          (bits >> (count - numBitsToWrite)) & ((1 << numBitsToWrite) - 1);
+        this._pendingByte |=
+          bitsToWrite << (8 - this._bitOffset - numBitsToWrite);
+        count -= numBitsToWrite;
+        this._bitOffset += numBitsToWrite;
+        if (this._bitOffset === 8) {
+          this._bitOffset = 0;
+          this.flush();
+        }
+      }
+    }
+  }
+  public writeUnsigned(num: number, count: number) {
+    if (num < 0) throw new Error("Expected a non-negative number");
+    this.writeBits(num, count);
+  }
+  public writeSigned(num: number, count: number) {
+    if (count <= 0) return;
+    if (count > 32) throw new Error("writeSigned supports up to 32 bits");
+
+    // Build mask for `count` bits. Handle 32-bit as a special case.
+    const mask =
+      count === 32 ? 0xffffffff >>> 0 : (((1 << count) >>> 0) - 1) >>> 0;
+
+    // Convert to two's-complement unsigned representation and write
+    const unsigned = (num & mask) >>> 0;
+    this.writeBits(unsigned, count);
+  }
+  public writeUnsignedExpGolomb(num: number) {
+    if (num < 0) throw new Error("Expected a non-negative number");
+    num++;
+    const bitCount = 32 - Math.clz32(num >>> 0);
+    this.writeBits(0, bitCount - 1);
+    this.writeBits(num, bitCount);
+  }
+  public writeSignedExpGolomb(num: number) {
+    if (num < 0) this.writeUnsignedExpGolomb(-2 * num);
+    else this.writeUnsignedExpGolomb(2 * num - 1);
+  }
+}