magmastream 2.9.0-dev.30 → 2.9.0-dev.32

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Collection } from '@discordjs/collection';
 import { GatewayVoiceStateUpdate } from 'discord-api-types/v10';
 import { EventEmitter } from 'events';
-import WebSocket from 'ws';
+import WebSocket, { WebSocket as WebSocket$1 } from 'ws';
 import { User, ClientUser, Message, Client } from 'discord.js';
 import { Redis } from 'ioredis';
 import { Client as Client$1 } from 'eris';
@@ -28,6 +28,8 @@ declare class Rest {
     private readonly url;
     /** The Manager instance. */
     manager: Manager;
+    /** Whether the node is a NodeLink. */
+    isNodeLink: boolean;
     constructor(node: Node$1, manager: Manager);
     /**
      * Sets the session ID.
@@ -285,7 +287,12 @@ declare enum ManagerEventTypes {
     TrackEnd = "trackEnd",
     TrackError = "trackError",
     TrackStart = "trackStart",
-    TrackStuck = "trackStuck"
+    TrackStuck = "trackStuck",
+    VoiceReceiverDisconnect = "voiceReceiverDisconnect",
+    VoiceReceiverConnect = "voiceReceiverConnect",
+    VoiceReceiverError = "voiceReceiverError",
+    VoiceReceiverStartSpeaking = "voiceReceiverStartSpeaking",
+    VoiceReceiverEndSpeaking = "voiceReceiverEndSpeaking"
 }
 /**
  * Track End Reason Enum
@@ -801,6 +808,11 @@ interface ManagerEvents {
     [ManagerEventTypes.TrackError]: [player: Player, track: Track, payload: TrackExceptionEvent];
     [ManagerEventTypes.TrackStart]: [player: Player, track: Track, payload: TrackStartEvent];
     [ManagerEventTypes.TrackStuck]: [player: Player, track: Track, payload: TrackStuckEvent];
+    [ManagerEventTypes.VoiceReceiverDisconnect]: [player: Player];
+    [ManagerEventTypes.VoiceReceiverConnect]: [player: Player];
+    [ManagerEventTypes.VoiceReceiverError]: [player: Player, error: Error];
+    [ManagerEventTypes.VoiceReceiverStartSpeaking]: [player: Player, data: unknown];
+    [ManagerEventTypes.VoiceReceiverEndSpeaking]: [player: Player, data: unknown];
 }
 /**
  * Voice Packet
@@ -997,6 +1009,8 @@ interface NodeOptions {
     apiRequestTimeoutMs?: number;
     /** Priority of the node. */
     nodePriority?: number;
+    /** Whether the node is a NodeLink. */
+    isNodeLink?: boolean;
 }
 /**
  * NodeOptions interface
@@ -1139,6 +1153,100 @@ interface Lyrics {
     lines: LyricsLine[];
     plugin: object[];
 }
+/**
+ * NodeLink Get Lyrics Multiple interface
+ */
+interface NodeLinkGetLyricsMultiple {
+    loadType: "lyricsMultiple";
+    data: NodeLinkGetLyricsData[];
+}
+/**
+ * NodeLink Get Lyrics Empty interface
+ */
+interface NodeLinkGetLyricsEmpty {
+    loadType: "empty";
+    data: Record<never, never>;
+}
+/**
+ * NodeLink Get Lyrics Data interface
+ */
+interface NodeLinkGetLyricsData {
+    name: string;
+    synced: boolean;
+    data: {
+        startTime?: number;
+        endTime?: number;
+        text: string;
+    }[];
+    rtl: boolean;
+}
+/**
+ * NodeLink Get Lyrics Single interface
+ */
+interface NodeLinkGetLyricsSingle {
+    loadType: "lyricsSingle";
+    data: NodeLinkGetLyricsData;
+}
+/**
+ * NodeLink Get Lyrics Error interface
+ */
+interface NodeLinkGetLyricsError {
+    loadType: "error";
+    data: {
+        message: string;
+        severity: Severity;
+        cause: string;
+        trace?: string;
+    };
+}
+interface StartSpeakingEventVoiceReceiverData {
+    /**
+     * The user ID of the user who started speaking.
+     */
+    userId: string;
+    /**
+     * The guild ID of the guild where the user started speaking.
+     */
+    guildId: string;
+}
+interface EndSpeakingEventVoiceReceiverData {
+    /**
+     * The user ID of the user who stopped speaking.
+     */
+    userId: string;
+    /**
+     * The guild ID of the guild where the user stopped speaking.
+     */
+    guildId: string;
+    /**
+     * The audio data received from the user in base64.
+     */
+    data: string;
+    /**
+     * The type of the audio data. Can be either opus or pcm. Older versions may include ogg/opus.
+     */
+    type: "opus" | "pcm";
+}
+/**
+ * Base Voice Receiver Event interface
+ */
+interface BaseVoiceReceiverEvent {
+    op: "speak";
+}
+/**
+ * Start Speaking Event Voice Receiver interface
+ */
+interface StartSpeakingEventVoiceReceiver extends BaseVoiceReceiverEvent {
+    type: "startSpeakingEvent";
+    data: StartSpeakingEventVoiceReceiverData;
+}
+/**
+ * End Speaking Event Voice Receiver interface
+ */
+interface EndSpeakingEventVoiceReceiver extends BaseVoiceReceiverEvent {
+    type: "endSpeakingEvent";
+    data: EndSpeakingEventVoiceReceiverData;
+}
 /**
  * PlayerOptions interface
  */
@@ -1179,25 +1287,6 @@ interface EqualizerBand {
     /** The gain amount being -0.25 to 1.00, 0.25 being double. */
     gain: number;
 }
-/**
- * PlayerStore interface
- */
-interface PlayerStore {
-    get(guildId: string): Promise<Player | undefined>;
-    set(guildId: string, player: Player): Promise<void>;
-    delete(guildId: string): Promise<void>;
-    keys(): Promise<string[]>;
-    has(guildId: string): Promise<boolean>;
-    filter(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Map<string, Player>>;
-    find(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Player | undefined>;
-    map<T>(callback: (player: Player, guildId: string) => T | Promise<T>): Promise<T[]>;
-    forEach(callback: (player: Player, guildId: string) => void | Promise<void>): Promise<void>;
-    some(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
-    every(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
-    size(): Promise<number>;
-    clear(): Promise<void>;
-    entries(): AsyncIterableIterator<[string, Player]>;
-}
 /**
  * Queue interface
  */
@@ -1270,6 +1359,14 @@ type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExc
  * Load Type Enum type
  */
 type LoadType = keyof typeof LoadTypes;
+/**
+ * NodeLink Get Lyrics Enum type
+ */
+type NodeLinkGetLyrics = NodeLinkGetLyricsSingle | NodeLinkGetLyricsMultiple | NodeLinkGetLyricsEmpty | NodeLinkGetLyricsError;
+/**
+ * Voice Receiver Event Enum type
+ */
+type VoiceReceiverEvent = StartSpeakingEventVoiceReceiver | EndSpeakingEventVoiceReceiver;
 
 declare class Node$1 {
     manager: Manager;
@@ -1285,11 +1382,14 @@ declare class Node$1 {
     readonly rest: Rest;
     /** Actual Lavalink information of the node. */
     info: LavalinkInfo | null;
+    /** Whether the node is a NodeLink. */
+    isNodeLink: boolean;
     private reconnectTimeout?;
     private reconnectAttempts;
     /**
      * Creates an instance of Node.
-     * @param options
+     * @param manager - The manager for the node.
+     * @param options - The options for the node.
      */
     constructor(manager: Manager, options: NodeOptions);
     /** Returns if connected to the Node. */
@@ -1361,6 +1461,12 @@ declare class Node$1 {
      * @emits {nodeDestroy} - Emits a nodeDestroy event if the maximum number of retry attempts is reached.
      */
     private reconnect;
+    /**
+     * Upgrades the node to a NodeLink.
+     *
+     * @param request - The incoming message.
+     */
+    private upgrade;
     /**
      * Handles the "open" event emitted by the WebSocket connection.
      *
@@ -1492,9 +1598,9 @@ declare class Node$1 {
      *
      * @param {Track} track - The track to fetch the lyrics for.
      * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
-     * @returns {Promise<Lyrics>} A promise that resolves with the lyrics data.
+     * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
-    getLyrics(track: Track, skipTrackSource?: boolean): Promise<Lyrics>;
+    getLyrics(track: Track, skipTrackSource?: boolean): Promise<Lyrics | NodeLinkGetLyrics>;
     /**
      * Handles the event when a track becomes stuck during playback.
      * Stops the current track and emits a `trackStuck` event.
@@ -1808,6 +1914,11 @@ declare class Manager extends EventEmitter {
      * This is done to prevent stale state files from accumulating on the file system.
      */
     private cleanupInactivePlayers;
+    /**
+     * Clears all player states from the file system.
+     * This is done to prevent stale state files from accumulating on the file system.
+     */
+    private clearAllPlayerStates;
     /**
      * Returns the nodes that has the least load.
      * The load is calculated by dividing the lavalink load by the number of cores.
@@ -1884,6 +1995,12 @@ declare class Player {
     private dynamicLoopInterval;
     dynamicRepeatIntervalMs: number | null;
     private static _manager;
+    /** Should only be used when the node is a NodeLink */
+    protected voiceReceiverWsClient: WebSocket$1 | null;
+    protected isConnectToVoiceReceiver: boolean;
+    protected voiceReceiverReconnectTimeout: NodeJS.Timeout | null;
+    protected voiceReceiverAttempt: number;
+    protected voiceReceiverReconnectTries: number;
     /**
      * Creates a new player, returns one if it already exists.
      * @param options The player options.
@@ -2116,11 +2233,51 @@ declare class Player {
      */
     getCurrentLyrics(skipTrackSource?: boolean): Promise<Lyrics>;
     /**
-     * Sleeps for a specified amount of time.
-     * @param ms The amount of time to sleep in milliseconds.
-     * @returns A promise that resolves after the specified amount of time.
+     * Sets up the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is set up.
+     * @throws {Error} - If the node is not a NodeLink.
      */
-    private sleep;
+    setupVoiceReceiver(): Promise<void>;
+    /**
+     * Removes the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is removed.
+     * @throws {Error} - If the node is not a NodeLink.
+     */
+    removeVoiceReceiver(): Promise<void>;
+    /**
+     * Closes the voice receiver for the player.
+     * @param {number} code - The code to close the voice receiver with.
+     * @param {string} reason - The reason to close the voice receiver with.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is closed.
+     */
+    private closeVoiceReceiver;
+    /**
+     * Reconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is reconnected.
+     */
+    private reconnectVoiceReceiver;
+    /**
+     * Disconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is disconnected.
+     */
+    private disconnectVoiceReceiver;
+    /**
+     * Opens the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is opened.
+     */
+    private openVoiceReceiver;
+    /**
+     * Handles a voice receiver message.
+     * @param {string} payload - The payload to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver message is handled.
+     */
+    private onVoiceReceiverMessage;
+    /**
+     * Handles a voice receiver error.
+     * @param {Error} error - The error to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver error is handled.
+     */
+    private onVoiceReceiverError;
 }
 
 declare class Filters {
@@ -2604,9 +2761,7 @@ declare abstract class AutoPlayUtils {
      * @returns An array of recommended tracks.
      */
     static getRecommendedTracksFromSource(track: Track, platform: string): Promise<Track[]>;
-    static fetchSecretArray(): Promise<Buffer<ArrayBuffer>>;
-    static transformSecret(buffer: Buffer): Buffer<ArrayBuffer>;
-    static generateTotp(secretBuffer: Buffer): string;
+    static generateTotp(): (string | number)[];
 }
 /** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
 declare abstract class Structure {
@@ -2660,4 +2815,4 @@ declare class OceanicManager extends Manager {
 }
 
 export { AutoPlayPlatform, AutoPlayUtils, AvailableFilters, DetritusManager, DiscordJSManager, ErisManager, Filters, LoadTypes, Manager, ManagerEventTypes, Node$1 as Node, OceanicManager, Player, PlayerStateEventTypes, Plugin$1 as Plugin, Queue, Rest, SearchPlatform, SeverityTypes, SponsorBlockSegment, StateStorageType, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
-export type { CPUStats, DiscordPacket, EqualizerBand, Exception, Extendable, FrameStats, IQueue, LavaPlayer, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerInitOptions, ManagerOptions, MemoryStats, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStateUpdateEvent, PlayerStore, PlayerUpdate, PlayerUpdateVoiceState, PlaylistData, PlaylistInfoData, PlaylistRawData, RedisConfig, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceServer, VoiceServerUpdate, VoiceState, WebSocketClosedEvent };
+export type { CPUStats, DiscordPacket, EndSpeakingEventVoiceReceiver, EndSpeakingEventVoiceReceiverData, EqualizerBand, Exception, Extendable, FrameStats, IQueue, LavaPlayer, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerInitOptions, ManagerOptions, MemoryStats, NodeLinkGetLyrics, NodeLinkGetLyricsEmpty, NodeLinkGetLyricsError, NodeLinkGetLyricsMultiple, NodeLinkGetLyricsSingle, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStateUpdateEvent, PlayerUpdate, PlayerUpdateVoiceState, PlaylistData, PlaylistInfoData, PlaylistRawData, RedisConfig, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, StartSpeakingEventVoiceReceiver, StartSpeakingEventVoiceReceiverData, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceReceiverEvent, VoiceServer, VoiceServerUpdate, VoiceState, WebSocketClosedEvent };

package/dist/structures/Enums.js

@@ -163,6 +163,11 @@ var ManagerEventTypes;
     ManagerEventTypes["TrackError"] = "trackError";
     ManagerEventTypes["TrackStart"] = "trackStart";
     ManagerEventTypes["TrackStuck"] = "trackStuck";
+    ManagerEventTypes["VoiceReceiverDisconnect"] = "voiceReceiverDisconnect";
+    ManagerEventTypes["VoiceReceiverConnect"] = "voiceReceiverConnect";
+    ManagerEventTypes["VoiceReceiverError"] = "voiceReceiverError";
+    ManagerEventTypes["VoiceReceiverStartSpeaking"] = "voiceReceiverStartSpeaking";
+    ManagerEventTypes["VoiceReceiverEndSpeaking"] = "voiceReceiverEndSpeaking";
 })(ManagerEventTypes || (exports.ManagerEventTypes = ManagerEventTypes = {}));
 /**
  * Track End Reason Enum

package/dist/structures/Manager.js

@@ -791,6 +791,9 @@ class Manager extends events_1.EventEmitter {
     async handleShutdown() {
         console.warn("\x1b[31m%s\x1b[0m", "MAGMASTREAM WARNING: Shutting down! Please wait, saving active players...");
         try {
+            if (this.options.stateStorage.type === Enums_1.StateStorageType.Collection) {
+                await this.clearAllPlayerStates();
+            }
             const savePromises = Array.from(this.players.keys()).map(async (guildId) => {
                 try {
                     await this.savePlayerState(guildId);
@@ -925,6 +928,7 @@ class Manager extends events_1.EventEmitter {
             guildId: player.guildId,
             data: { voice: { token, endpoint, sessionId } },
         });
+        this.emit(Enums_1.ManagerEventTypes.Debug, `Updated voice server for player ${player.guildId} with token ${token} and endpoint ${endpoint} and sessionId ${sessionId}`);
         return;
     }
     /**
@@ -935,6 +939,7 @@ class Manager extends events_1.EventEmitter {
      * @emits {playerDisconnect} - Emits a player disconnect event if the channel ID is null.
      */
     async handleVoiceStateUpdate(player, update) {
+        this.emit(Enums_1.ManagerEventTypes.Debug, `Updated voice state for player ${player.guildId} with channel id ${update.channel_id} and session id ${update.session_id}`);
         if (update.channel_id) {
             if (player.voiceChannelId !== update.channel_id) {
                 this.emit(Enums_1.ManagerEventTypes.PlayerMove, player, player.voiceChannelId, update.channel_id);
@@ -946,7 +951,7 @@ class Manager extends events_1.EventEmitter {
         this.emit(Enums_1.ManagerEventTypes.PlayerDisconnect, player, player.voiceChannelId);
         player.voiceChannelId = null;
         player.voiceState = Object.assign({});
-        await player.destroy();
+        await player.pause(true);
         return;
     }
     /**
@@ -1052,6 +1057,64 @@ class Manager extends events_1.EventEmitter {
             this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error cleaning up inactive players: ${error}`);
         }
     }
+    /**
+     * Clears all player states from the file system.
+     * This is done to prevent stale state files from accumulating on the file system.
+     */
+    async clearAllPlayerStates() {
+        switch (this.options.stateStorage.type) {
+            case Enums_1.StateStorageType.Collection: {
+                const configDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
+                try {
+                    // Check if the directory exists, and create it if it doesn't
+                    await promises_1.default.access(configDir).catch(async () => {
+                        await promises_1.default.mkdir(configDir, { recursive: true });
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Created directory: ${configDir}`);
+                    });
+                    const files = await promises_1.default.readdir(configDir);
+                    await Promise.all(files.map((file) => promises_1.default.unlink(path_1.default.join(configDir, file)).catch((err) => console.warn(`Failed to delete file ${file}:`, err))));
+                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Cleared all player state files in ${configDir}`);
+                }
+                catch (err) {
+                    console.error("Error clearing player state files:", err);
+                }
+                break;
+            }
+            case Enums_1.StateStorageType.Redis: {
+                const prefix = this.options.stateStorage.redisConfig.prefix?.endsWith(":")
+                    ? this.options.stateStorage.redisConfig.prefix
+                    : this.options.stateStorage.redisConfig.prefix ?? "magmastream:";
+                const pattern = `${prefix}playerstore:*`;
+                try {
+                    const stream = this.redis.scanStream({
+                        match: pattern,
+                        count: 100,
+                    });
+                    let totalDeleted = 0;
+                    stream.on("data", async (keys) => {
+                        if (keys.length) {
+                            const pipeline = this.redis.pipeline();
+                            keys.forEach((key) => pipeline.unlink(key));
+                            await pipeline.exec();
+                            totalDeleted += keys.length;
+                        }
+                    });
+                    stream.on("end", () => {
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Cleared ${totalDeleted} Redis player state keys (pattern: ${pattern})`);
+                    });
+                    stream.on("error", (err) => {
+                        console.error("Error during Redis SCAN stream:", err);
+                    });
+                }
+                catch (err) {
+                    console.error("Failed to clear Redis player state keys:", err);
+                }
+                break;
+            }
+            default:
+                console.warn("[MANAGER] No valid stateStorage.type set, skipping state clearing.");
+        }
+    }
     /**
      * Returns the nodes that has the least load.
      * The load is calculated by dividing the lavalink load by the number of cores.

package/dist/structures/Node.js

@@ -31,11 +31,14 @@ class Node {
     rest;
     /** Actual Lavalink information of the node. */
     info = null;
+    /** Whether the node is a NodeLink. */
+    isNodeLink = false;
     reconnectTimeout;
     reconnectAttempts = 1;
     /**
      * Creates an instance of Node.
-     * @param options
+     * @param manager - The manager for the node.
+     * @param options - The options for the node.
      */
     constructor(manager, options) {
         this.manager = manager;
@@ -185,6 +188,7 @@ class Node {
         this.socket = new ws_1.default(`ws${this.options.useSSL ? "s" : ""}://${this.address}/v4/websocket`, { headers });
         this.socket.on("open", this.open.bind(this));
         this.socket.on("close", this.close.bind(this));
+        this.socket.on("upgrade", (request) => this.upgrade(request));
         this.socket.on("message", this.message.bind(this));
         this.socket.on("error", this.error.bind(this));
         const debugInfo = {
@@ -287,6 +291,14 @@ class Node {
             this.reconnectAttempts++;
         }, this.options.retryDelayMs);
     }
+    /**
+     * Upgrades the node to a NodeLink.
+     *
+     * @param request - The incoming message.
+     */
+    upgrade(request) {
+        this.isNodeLink = this.options.isNodeLink ?? Boolean(request.headers.isnodelink) ?? false;
+    }
     /**
      * Handles the "open" event emitted by the WebSocket connection.
      *
@@ -727,13 +739,14 @@ class Node {
      *
      * @param {Track} track - The track to fetch the lyrics for.
      * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
-     * @returns {Promise<Lyrics>} A promise that resolves with the lyrics data.
+     * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
     async getLyrics(track, skipTrackSource = false) {
+        if (this.isNodeLink) {
+            return (await this.rest.get(`/v4/lyrics?track=${encodeURIComponent(track.track)}&skipTrackSource=${skipTrackSource}`));
+        }
         if (!this.info.plugins.some((plugin) => plugin.name === "lavalyrics-plugin"))
             throw new RangeError(`there is no lavalyrics-plugin available in the lavalink node: ${this.options.identifier}`);
-        // Make a GET request to the Lavalink node to fetch the lyrics
-        // The request includes the track URL and the skipTrackSource parameter
         return ((await this.rest.get(`/v4/lyrics?track=${encodeURIComponent(track.track)}&skipTrackSource=${skipTrackSource}`)) || {
             source: null,
             provider: null,

package/dist/structures/Player.js

@@ -10,6 +10,7 @@ const playerCheck_1 = tslib_1.__importDefault(require("../utils/playerCheck"));
 const RedisQueue_1 = require("./RedisQueue");
 // import { IQueue, Lyrics, PlayerOptions, PlayerUpdateVoiceState, PlayOptions, SearchQuery, SearchResult, Track, VoiceState } from "./Types";
 const Enums_1 = require("./Enums");
+const ws_1 = require("ws");
 class Player {
     options;
     /** The Queue for the Player. */
@@ -58,6 +59,12 @@ class Player {
     dynamicLoopInterval = null;
     dynamicRepeatIntervalMs = null;
     static _manager;
+    /** Should only be used when the node is a NodeLink */
+    voiceReceiverWsClient;
+    isConnectToVoiceReceiver;
+    voiceReceiverReconnectTimeout;
+    voiceReceiverAttempt;
+    voiceReceiverReconnectTries;
     /**
      * Creates a new player, returns one if it already exists.
      * @param options The player options.
@@ -911,12 +918,132 @@ class Player {
         return result;
     }
     /**
-     * Sleeps for a specified amount of time.
-     * @param ms The amount of time to sleep in milliseconds.
-     * @returns A promise that resolves after the specified amount of time.
+     * Sets up the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is set up.
+     * @throws {Error} - If the node is not a NodeLink.
      */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
+    async setupVoiceReceiver() {
+        if (!this.node.isNodeLink)
+            throw new Error("This function is only available for NodeLinks");
+        if (this.voiceReceiverWsClient)
+            await this.removeVoiceReceiver();
+        const headers = {
+            Authorization: this.node.options.password,
+            "User-Id": this.manager.options.clientId,
+            "Guild-Id": this.guildId,
+            "Client-Name": this.manager.options.clientName,
+        };
+        const { host, useSSL, port } = this.node.options;
+        this.voiceReceiverWsClient = new ws_1.WebSocket(`${useSSL ? "wss" : "ws"}://${host}:${port}/connection/data`, { headers });
+        this.voiceReceiverWsClient.on("open", () => this.openVoiceReceiver());
+        this.voiceReceiverWsClient.on("error", (err) => this.onVoiceReceiverError(err));
+        this.voiceReceiverWsClient.on("message", (data) => this.onVoiceReceiverMessage(data.toString()));
+        this.voiceReceiverWsClient.on("close", (code, reason) => this.closeVoiceReceiver(code, reason.toString()));
+    }
+    /**
+     * Removes the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is removed.
+     * @throws {Error} - If the node is not a NodeLink.
+     */
+    async removeVoiceReceiver() {
+        if (!this.node.isNodeLink)
+            throw new Error("This function is only available for NodeLinks");
+        if (this.voiceReceiverWsClient) {
+            this.voiceReceiverWsClient.close(1000, "destroy");
+            this.voiceReceiverWsClient.removeAllListeners();
+            this.voiceReceiverWsClient = null;
+        }
+        this.isConnectToVoiceReceiver = false;
+    }
+    /**
+     * Closes the voice receiver for the player.
+     * @param {number} code - The code to close the voice receiver with.
+     * @param {string} reason - The reason to close the voice receiver with.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is closed.
+     */
+    async closeVoiceReceiver(code, reason) {
+        await this.disconnectVoiceReceiver();
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Closed voice receiver for player ${this.guildId} with code ${code} and reason ${reason}`);
+        if (code !== 1000)
+            await this.reconnectVoiceReceiver();
+    }
+    /**
+     * Reconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is reconnected.
+     */
+    async reconnectVoiceReceiver() {
+        this.voiceReceiverReconnectTimeout = setTimeout(async () => {
+            if (this.voiceReceiverAttempt > this.voiceReceiverReconnectTries)
+                throw new Error("Failed to reconnect to voice receiver");
+            this.voiceReceiverWsClient?.removeAllListeners();
+            this.voiceReceiverWsClient = null;
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Reconnecting to voice receiver for player ${this.guildId}`);
+            await this.setupVoiceReceiver();
+            this.voiceReceiverAttempt++;
+        }, this.node.options.retryDelayMs);
+    }
+    /**
+     * Disconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is disconnected.
+     */
+    async disconnectVoiceReceiver() {
+        if (!this.isConnectToVoiceReceiver)
+            return;
+        this.voiceReceiverWsClient?.close(1000, "destroy");
+        this.voiceReceiverWsClient?.removeAllListeners();
+        this.voiceReceiverWsClient = null;
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Disconnected from voice receiver for player ${this.guildId}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverDisconnect, this);
+    }
+    /**
+     * Opens the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is opened.
+     */
+    async openVoiceReceiver() {
+        if (this.voiceReceiverReconnectTimeout)
+            clearTimeout(this.voiceReceiverReconnectTimeout);
+        this.voiceReceiverReconnectTimeout = null;
+        this.isConnectToVoiceReceiver = true;
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Opened voice receiver for player ${this.guildId}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverConnect, this);
+    }
+    /**
+     * Handles a voice receiver message.
+     * @param {string} payload - The payload to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver message is handled.
+     */
+    async onVoiceReceiverMessage(payload) {
+        const packet = JSON.parse(payload);
+        if (!packet?.op)
+            return;
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver recieved a payload: ${JSON.stringify(payload)}`);
+        switch (packet.type) {
+            case "startSpeakingEvent": {
+                this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverStartSpeaking, this, packet.data);
+                break;
+            }
+            case "endSpeakingEvent": {
+                const data = {
+                    ...packet.data,
+                    data: Buffer.from(packet.data.data, "base64"),
+                };
+                this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverEndSpeaking, this, data);
+                break;
+            }
+            default: {
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver recieved an unknown payload: ${JSON.stringify(payload)}`);
+                break;
+            }
+        }
+    }
+    /**
+     * Handles a voice receiver error.
+     * @param {Error} error - The error to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver error is handled.
+     */
+    async onVoiceReceiverError(error) {
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver error for player ${this.guildId}: ${error.message}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverError, this, error);
     }
 }
 exports.Player = Player;

package/dist/structures/Rest.js

@@ -16,12 +16,15 @@ class Rest {
     url;
     /** The Manager instance. */
     manager;
+    /** Whether the node is a NodeLink. */
+    isNodeLink = false;
     constructor(node, manager) {
         this.node = node;
         this.url = `http${node.options.useSSL ? "s" : ""}://${node.options.host}:${node.options.port}`;
         this.sessionId = node.sessionId;
         this.password = node.options.password;
         this.manager = manager;
+        this.isNodeLink = node.isNodeLink;
     }
     /**
      * Sets the session ID.

package/dist/structures/Utils.js

@@ -5,7 +5,6 @@ const tslib_1 = require("tslib");
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const jsdom_1 = require("jsdom");
 const crypto_1 = tslib_1.__importDefault(require("crypto"));
-const cheerio_1 = tslib_1.__importDefault(require("cheerio"));
 const Enums_1 = require("./Enums");
 /** @hidden */
 const SIZES = ["0", "1", "2", "3", "default", "mqdefault", "hqdefault", "maxresdefault"];
@@ -278,31 +277,17 @@ class AutoPlayUtils {
                             }
                             track = res.tracks[0];
                         }
-                        const periodMs = 30000;
-                        async function getSpotifyTotpParams() {
-                            try {
-                                const secretBuffer = await AutoPlayUtils.fetchSecretArray();
-                                const transformedSecret = AutoPlayUtils.transformSecret(secretBuffer);
-                                const totp = AutoPlayUtils.generateTotp(transformedSecret);
-                                const timestamp = Math.floor(Date.now() / periodMs) * periodMs;
-                                const params = {
-                                    reason: "transport",
-                                    productType: "embed",
-                                    totp,
-                                    totpVer: 5,
-                                    ts: timestamp,
-                                };
-                                return params;
-                            }
-                            catch (error) {
-                                console.error("Failed to generate Spotify TOTP params:", error);
-                                throw error;
-                            }
-                        }
+                        const [totp, timestamp] = this.generateTotp();
+                        const params = {
+                            reason: "init",
+                            productType: "web-player",
+                            totp: totp,
+                            totpVer: 5,
+                            ts: timestamp,
+                        };
                         let body;
                         try {
-                            const params = await getSpotifyTotpParams();
-                            const response = await axios_1.default.get("https://open.spotify.com/get_access_token", {
+                            const response = await axios_1.default.get("https://open.spotify.com/api/token", {
                                 params,
                                 headers: {
                                     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.6998.178 Spotify/1.2.65.255 Safari/537.36",
@@ -310,13 +295,13 @@ class AutoPlayUtils {
                                     Referer: "https://open.spotify.com/",
                                     Origin: "https://open.spotify.com",
                                     "Accept-Language": "en",
-                                    "Content-Type": "application/json",
                                 },
                             });
                             body = response.data;
                         }
                         catch (error) {
-                            console.error("[AutoPlay] Failed to get spotify access token:", error.response?.status);
+                            const status = error.response?.status ?? "No response";
+                            console.error("[AutoPlay] Failed to get spotify access token:", status);
                             return [];
                         }
                         let json;
@@ -673,51 +658,20 @@ class AutoPlayUtils {
                 return [];
         }
     }
-    static async fetchSecretArray() {
-        // Step 1: Get Spotify homepage HTML
-        const homepageRes = await axios_1.default.get("https://open.spotify.com/");
-        const $ = cheerio_1.default.load(homepageRes.data);
-        // Step 2: Find script URL with "mobile-web-player" but not "vendor"
-        const scriptUrl = $("script[src]")
-            .map((_, el) => $(el).attr("src"))
-            .get()
-            .find((src) => src.includes("mobile-web-player") && !src.includes("vendor"));
-        if (!scriptUrl)
-            throw new Error("Secret script not found");
-        // Full URL fix (if needed)
-        const fullScriptUrl = scriptUrl.startsWith("http") ? scriptUrl : "https://open.spotify.com" + scriptUrl;
-        // Step 3: Fetch the script content
-        const scriptRes = await axios_1.default.get(fullScriptUrl);
-        const scriptContent = scriptRes.data;
-        // Step 4: Extract secret array using regex
-        const secretPattern = /\(\[(\d+(?:,\d+)+)]\)/;
-        const match = secretPattern.exec(scriptContent);
-        if (!match)
-            throw new Error("Secret array not found in script");
-        // Parse the secret array into bytes
-        const secretArray = match[1].split(",").map((n) => parseInt(n.trim(), 10));
-        return Buffer.from(secretArray);
-    }
-    static transformSecret(buffer) {
-        const transformed = Buffer.alloc(buffer.length);
-        for (let i = 0; i < buffer.length; i++) {
-            transformed[i] = buffer[i] ^ ((i % 33) + 9);
-        }
-        return transformed;
-    }
-    static generateTotp(secretBuffer) {
-        const period = 30; // seconds
-        const digits = 6;
-        const counter = Math.floor(Date.now() / 1000 / period);
+    static generateTotp() {
+        const TOTP_SECRET = new Uint8Array([
+            53, 53, 48, 55, 49, 52, 53, 56, 53, 51, 52, 56, 55, 52, 57, 57, 53, 57, 50, 50, 52, 56, 54, 51, 48, 51, 50, 57, 51, 52, 55,
+        ]);
+        const hmac = crypto_1.default.createHmac("sha1", TOTP_SECRET);
+        const counter = Math.floor(Date.now() / 30000);
         const counterBuffer = Buffer.alloc(8);
         counterBuffer.writeBigInt64BE(BigInt(counter));
-        const hmac = crypto_1.default.createHmac("sha1", secretBuffer);
         hmac.update(counterBuffer);
         const hmacResult = hmac.digest();
-        const offset = hmacResult[hmacResult.length - 1] & 0x0f;
-        const binary = ((hmacResult[offset] & 0x7f) << 24) | ((hmacResult[offset + 1] & 0xff) << 16) | ((hmacResult[offset + 2] & 0xff) << 8) | (hmacResult[offset + 3] & 0xff);
-        const otp = binary % 10 ** digits;
-        return otp.toString().padStart(digits, "0");
+        const offset = hmacResult[hmacResult.length - 1] & 15;
+        const truncatedValue = ((hmacResult[offset] & 127) << 24) | ((hmacResult[offset + 1] & 255) << 16) | ((hmacResult[offset + 2] & 255) << 8) | (hmacResult[offset + 3] & 255);
+        const totp = (truncatedValue % 1000000).toString().padStart(6, "0");
+        return [totp, counter * 30000];
     }
 }
 exports.AutoPlayUtils = AutoPlayUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "magmastream",
-	"version": "2.9.0-dev.30",
+	"version": "2.9.0-dev.32",
 	"description": "A user-friendly Lavalink client designed for NodeJS.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/dist/storage/CollectionPlayerStore.js

@@ -1,77 +0,0 @@
-"use strict";
-// THIS WILL BE REMOVED IF YOU DONT FIND A USE FOR IT.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CollectionPlayerStore = void 0;
-const collection_1 = require("@discordjs/collection");
-class CollectionPlayerStore {
-    store = new collection_1.Collection();
-    async get(guildId) {
-        return this.store.get(guildId);
-    }
-    async set(guildId, player) {
-        this.store.set(guildId, player);
-    }
-    async delete(guildId) {
-        this.store.delete(guildId);
-    }
-    async keys() {
-        return [...this.store.keys()];
-    }
-    async has(guildId) {
-        return this.store.has(guildId);
-    }
-    async filter(predicate) {
-        const result = new Map();
-        for (const [guildId, player] of this.store.entries()) {
-            if (await predicate(player, guildId)) {
-                result.set(guildId, player);
-            }
-        }
-        return result;
-    }
-    async find(predicate) {
-        for (const [guildId, player] of this.store.entries()) {
-            if (await predicate(player, guildId))
-                return player;
-        }
-        return undefined;
-    }
-    async map(callback) {
-        const results = [];
-        for (const [guildId, player] of this.store.entries()) {
-            results.push(await callback(player, guildId));
-        }
-        return results;
-    }
-    async forEach(callback) {
-        for (const [guildId, player] of this.store.entries()) {
-            await callback(player, guildId);
-        }
-    }
-    async some(predicate) {
-        for (const [guildId, player] of this.store.entries()) {
-            if (await predicate(player, guildId))
-                return true;
-        }
-        return false;
-    }
-    async every(predicate) {
-        for (const [guildId, player] of this.store.entries()) {
-            if (!(await predicate(player, guildId)))
-                return false;
-        }
-        return true;
-    }
-    async size() {
-        return this.store.size;
-    }
-    async clear() {
-        this.store.clear();
-    }
-    async *entries() {
-        for (const entry of this.store.entries()) {
-            yield entry;
-        }
-    }
-}
-exports.CollectionPlayerStore = CollectionPlayerStore;

package/dist/storage/RedisPlayerStore.js

@@ -1,156 +0,0 @@
-"use strict";
-// THIS WILL BE REMOVED IF YOU DONT FIND A USE FOR IT.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisPlayerStore = void 0;
-class RedisPlayerStore {
-    redis;
-    manager;
-    prefix;
-    constructor(redis, manager, prefix = "magmastream:") {
-        this.redis = redis;
-        this.manager = manager;
-        this.prefix = prefix;
-    }
-    getKey(guildId) {
-        return `${this.prefix}player:${guildId}`;
-    }
-    async get(guildId) {
-        const raw = await this.redis.get(this.getKey(guildId));
-        if (!raw)
-            return undefined;
-        return JSON.parse(raw);
-    }
-    async set(guildId, player) {
-        const serialized = this.manager.serializePlayer(player);
-        await this.redis.set(this.getKey(guildId), JSON.stringify(serialized));
-    }
-    async delete(guildId) {
-        await this.redis.del(this.getKey(guildId));
-    }
-    async keys() {
-        const keys = await this.redis.keys(`${this.prefix}player:*`);
-        return keys.map((key) => key.replace(`${this.prefix}player:`, ""));
-    }
-    async has(guildId) {
-        return (await this.redis.exists(this.getKey(guildId))) === 1;
-    }
-    async filter(predicate) {
-        const keys = await this.keys();
-        const pipeline = this.redis.pipeline();
-        for (const guildId of keys) {
-            pipeline.get(this.getKey(guildId));
-        }
-        const results = await pipeline.exec();
-        const result = new Map();
-        for (let i = 0; i < results.length; i++) {
-            const [err, raw] = results[i];
-            if (err || typeof raw !== "string")
-                continue;
-            const guildId = keys[i];
-            const player = JSON.parse(raw);
-            if (await predicate(player, guildId)) {
-                result.set(guildId, player);
-            }
-        }
-        return result;
-    }
-    async find(predicate) {
-        for (const guildId of await this.keys()) {
-            const raw = await this.redis.get(this.getKey(guildId));
-            if (!raw)
-                continue;
-            const parsed = JSON.parse(raw);
-            if (await predicate(parsed, guildId))
-                return parsed;
-        }
-        return undefined;
-    }
-    async map(callback) {
-        const keys = await this.keys();
-        if (!keys.length)
-            return [];
-        const pipeline = this.redis.pipeline();
-        for (const guildId of keys) {
-            pipeline.get(this.getKey(guildId));
-        }
-        const results = await pipeline.exec();
-        const output = [];
-        for (let i = 0; i < results.length; i++) {
-            const [err, raw] = results[i];
-            if (err || typeof raw !== "string")
-                continue;
-            const guildId = keys[i];
-            const player = JSON.parse(raw);
-            output.push(await callback(player, guildId));
-        }
-        return output;
-    }
-    async forEach(callback) {
-        for (const guildId of await this.keys()) {
-            const raw = await this.redis.get(this.getKey(guildId));
-            if (!raw)
-                continue;
-            const parsed = JSON.parse(raw);
-            await callback(parsed, guildId);
-        }
-    }
-    async some(predicate) {
-        const keys = await this.keys();
-        if (!keys.length)
-            return false;
-        const pipeline = this.redis.pipeline();
-        for (const guildId of keys) {
-            pipeline.get(this.getKey(guildId));
-        }
-        const results = await pipeline.exec();
-        for (let i = 0; i < results.length; i++) {
-            const [err, raw] = results[i];
-            if (err || typeof raw !== "string")
-                continue;
-            const guildId = keys[i];
-            const player = JSON.parse(raw);
-            if (await predicate(player, guildId))
-                return true;
-        }
-        return false;
-    }
-    async every(predicate) {
-        const keys = await this.keys();
-        if (!keys.length)
-            return true;
-        const pipeline = this.redis.pipeline();
-        for (const guildId of keys) {
-            pipeline.get(this.getKey(guildId));
-        }
-        const results = await pipeline.exec();
-        for (let i = 0; i < results.length; i++) {
-            const [err, raw] = results[i];
-            if (err || typeof raw !== "string")
-                continue;
-            const guildId = keys[i];
-            const player = JSON.parse(raw);
-            if (!(await predicate(player, guildId)))
-                return false;
-        }
-        return true;
-    }
-    async size() {
-        const keys = await this.keys();
-        return keys.length;
-    }
-    async clear() {
-        const keys = await this.redis.keys(`${this.prefix}player:*`);
-        if (keys.length) {
-            await this.redis.del(...keys);
-        }
-    }
-    async *entries() {
-        for (const guildId of await this.keys()) {
-            const raw = await this.redis.get(this.getKey(guildId));
-            if (!raw)
-                continue;
-            yield [guildId, JSON.parse(raw)];
-        }
-    }
-}
-exports.RedisPlayerStore = RedisPlayerStore;