magmastream 2.9.3-dev.3 → 2.9.3-dev.30

package/dist/structures/Player.js

@@ -82,7 +82,7 @@ class Player {
                 message: "Manager instance is required.",
             });
         }
-        this.clusterId = this.manager.options.clusterId || 0;
+        this.clusterId = this.manager.options.clusterId ?? 0;
         // Check the player options for errors.
         (0, playerCheck_1.default)(options);
         this.options = {
@@ -260,21 +260,30 @@ class Player {
      */
     async destroy(disconnect = true) {
         this.state = Enums_1.StateTypes.Destroying;
+        if (this.dynamicLoopInterval) {
+            clearInterval(this.dynamicLoopInterval);
+            this.dynamicLoopInterval = null;
+        }
+        if (this.voiceReceiverReconnectTimeout) {
+            clearTimeout(this.voiceReceiverReconnectTimeout);
+            this.voiceReceiverReconnectTimeout = null;
+        }
+        if (this.voiceReceiverWsClient) {
+            this.voiceReceiverWsClient.removeAllListeners();
+            this.voiceReceiverWsClient.close();
+            this.voiceReceiverWsClient = null;
+        }
         if (disconnect) {
-            await this.disconnect().catch((err) => {
-                console.warn(`[Player#destroy] Failed to disconnect player ${this.guildId}:`, err);
-            });
+            await this.disconnect().catch(() => { });
         }
-        await this.node.rest.destroyPlayer(this.guildId).catch((err) => {
-            console.warn(`[Player#destroy] REST failed to destroy player ${this.guildId}:`, err);
-        });
-        await this.queue.clear();
-        await this.queue.clearPrevious();
-        await this.queue.setCurrent(null);
+        await this.node.rest.destroyPlayer(this.guildId).catch(() => { });
+        await this.queue.destroy();
+        this.nowPlayingMessage = undefined;
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerDestroy, this);
         const deleted = this.manager.players.delete(this.guildId);
-        if (this.manager.options.stateStorage.deleteInactivePlayers)
+        if (this.manager.options.stateStorage.deleteDestroyedPlayers) {
             await this.manager.cleanupInactivePlayer(this.guildId);
+        }
         return deleted;
     }
     /**
@@ -387,7 +396,7 @@ class Player {
             },
         });
         this.playing = true;
-        this.position = 0;
+        this.position = finalOptions.startTime || 0;
         return this;
     }
     /**
@@ -806,11 +815,8 @@ class Player {
             if (currentPlayingTrack) {
                 await this.queue.add(currentPlayingTrack, 0);
             }
-            await this.play(lastTrack);
-        }
-        else {
-            await this.play(lastTrack);
         }
+        await this.play(lastTrack);
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
             changeType: Enums_1.PlayerStateEventTypes.TrackChange,
             details: {
@@ -922,7 +928,8 @@ class Player {
             const sessionId = this.voiceState?.sessionId;
             const token = this.voiceState?.event?.token;
             const endpoint = this.voiceState?.event?.endpoint;
-            if (!sessionId || !token || !endpoint) {
+            const channelId = this.voiceState?.channelId;
+            if (!sessionId || !token || !endpoint || !channelId) {
                 this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Voice state is not properly initialized for player ${this.guildId}. The bot might not be connected to a voice channel.`);
                 throw new MagmastreamError_1.MagmaStreamError({
                     code: Enums_1.MagmaStreamErrorCode.PLAYER_STATE_INVALID,
@@ -936,7 +943,7 @@ class Player {
             this.manager.players.set(this.guildId, this);
             await this.node.rest.updatePlayer({
                 guildId: this.guildId,
-                data: { paused: this.paused, volume: this.volume, position: playerPosition, encodedTrack: currentTrack?.track, voice: { token, endpoint, sessionId } },
+                data: { paused: this.paused, volume: this.volume, position: playerPosition, encodedTrack: currentTrack?.track, voice: { token, endpoint, sessionId, channelId } },
             });
             await this.filters.updateFilters();
         }
@@ -953,115 +960,6 @@ class Player {
             console.error(error);
         }
     }
-    /**
-     * Transfers the player to a new server. If the player already exists on the new server
-     * and force is false, this method will return the existing player. Otherwise, a new player
-     * will be created and the current player will be destroyed.
-     * @param {PlayerOptions} newOptions - The new options for the player.
-     * @param {boolean} force - Whether to force the creation of a new player.
-     * @returns {Promise<Player>} - The new player instance.
-     */
-    async switchGuild(newOptions, force = false) {
-        if (!newOptions.guildId) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
-                message: "guildId is required for switchGuild",
-            });
-        }
-        if (!newOptions.voiceChannelId) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
-                message: "voiceChannelId is required for switchGuild",
-            });
-        }
-        if (!newOptions.textChannelId) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
-                message: "textChannelId is required for switchGuild",
-            });
-        }
-        // Check if a player already exists for the new guild
-        let newPlayer = this.manager.getPlayer(newOptions.guildId);
-        // If the player already exists and force is false, return the existing player
-        if (newPlayer && !force)
-            return newPlayer;
-        const oldPlayerProperties = {
-            paused: this.paused,
-            selfMute: this.options.selfMute,
-            selfDeafen: this.options.selfDeafen,
-            volume: this.volume,
-            position: this.position,
-            queue: {
-                current: await this.queue.getCurrent(),
-                tracks: [...(await this.queue.getTracks())],
-                previous: [...(await this.queue.getPrevious())],
-            },
-            trackRepeat: this.trackRepeat,
-            queueRepeat: this.queueRepeat,
-            dynamicRepeat: this.dynamicRepeat,
-            dynamicRepeatIntervalMs: this.dynamicRepeatIntervalMs,
-            ClientUser: this.get("Internal_AutoplayUser"),
-            filters: this.filters,
-            nowPlayingMessage: this.nowPlayingMessage,
-            isAutoplay: this.isAutoplay,
-            applyVolumeAsFilter: this.options.applyVolumeAsFilter,
-            pauseOnDisconnect: this.options.pauseOnDisconnect,
-        };
-        // If force is true, destroy the existing player for the new guild
-        if (force && newPlayer) {
-            await newPlayer.destroy();
-        }
-        newOptions.nodeIdentifier = newOptions.nodeIdentifier ?? this.options.nodeIdentifier;
-        newOptions.selfDeafen = newOptions.selfDeafen ?? oldPlayerProperties.selfDeafen;
-        newOptions.selfMute = newOptions.selfMute ?? oldPlayerProperties.selfMute;
-        newOptions.volume = newOptions.volume ?? oldPlayerProperties.volume;
-        newOptions.applyVolumeAsFilter = newOptions.applyVolumeAsFilter ?? oldPlayerProperties.applyVolumeAsFilter;
-        newOptions.pauseOnDisconnect = newOptions.pauseOnDisconnect ?? oldPlayerProperties.pauseOnDisconnect;
-        // Deep clone the current player
-        const clonedPlayer = this.manager.create(newOptions);
-        // Connect the cloned player to the new voice channel
-        clonedPlayer.connect();
-        // Update the player's state on the Lavalink node
-        await clonedPlayer.node.rest.updatePlayer({
-            guildId: clonedPlayer.guildId,
-            data: {
-                paused: oldPlayerProperties.paused,
-                volume: oldPlayerProperties.volume,
-                position: oldPlayerProperties.position,
-                encodedTrack: oldPlayerProperties.queue.current?.track,
-            },
-        });
-        await clonedPlayer.queue.setCurrent(oldPlayerProperties.queue.current);
-        await clonedPlayer.queue.addPrevious(oldPlayerProperties.queue.previous);
-        await clonedPlayer.queue.add(oldPlayerProperties.queue.tracks);
-        clonedPlayer.filters = oldPlayerProperties.filters;
-        clonedPlayer.isAutoplay = oldPlayerProperties.isAutoplay;
-        clonedPlayer.nowPlayingMessage = oldPlayerProperties.nowPlayingMessage;
-        clonedPlayer.trackRepeat = oldPlayerProperties.trackRepeat;
-        clonedPlayer.queueRepeat = oldPlayerProperties.queueRepeat;
-        clonedPlayer.dynamicRepeat = oldPlayerProperties.dynamicRepeat;
-        clonedPlayer.dynamicRepeatIntervalMs = oldPlayerProperties.dynamicRepeatIntervalMs;
-        clonedPlayer.set("Internal_AutoplayUser", oldPlayerProperties.ClientUser);
-        clonedPlayer.paused = oldPlayerProperties.paused;
-        // Update filters for the cloned player
-        await clonedPlayer.filters.updateFilters();
-        // Debug information
-        const debugInfo = {
-            success: true,
-            message: `Transferred ${await clonedPlayer.queue.size()} tracks successfully to <#${newOptions.voiceChannelId}> bound to <#${newOptions.textChannelId}>.`,
-            player: {
-                guildId: clonedPlayer.guildId,
-                voiceChannelId: clonedPlayer.voiceChannelId,
-                textChannelId: clonedPlayer.textChannelId,
-                volume: clonedPlayer.volume,
-                playing: clonedPlayer.playing,
-                queueSize: clonedPlayer.queue.size,
-            },
-        };
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Transferred player to a new server: ${Utils_1.JSONUtils.safe(debugInfo, 2)}.`);
-        // Return the cloned player
-        return clonedPlayer;
-    }
     /**
      * Retrieves the data associated with the player.
      * @returns {Record<string, unknown>} - The data associated with the player.
@@ -1076,6 +974,13 @@ class Player {
     getDynamicLoopIntervalPublic() {
         return this.dynamicLoopInterval;
     }
+    /**
+     * Retrieves the data associated with the player.
+     * @returns {Record<string, unknown>} - The data associated with the player.
+     */
+    getSerializableData() {
+        return { ...this.data };
+    }
     /**
      * Retrieves the current lyrics for the playing track.
      * @param skipTrackSource - Indicates whether to skip the track source when fetching lyrics.
@@ -1239,5 +1144,26 @@ class Player {
         this.manager.emit(Enums_1.ManagerEventTypes.Debug, `VoiceReceiver error for player ${this.guildId}: ${error.message}`);
         this.manager.emit(Enums_1.ManagerEventTypes.VoiceReceiverError, this, error);
     }
+    /**
+     * Updates the voice state for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice state is updated.
+     */
+    async updateVoice() {
+        const vs = this.voiceState;
+        const ev = vs?.event;
+        if (!vs?.channelId || !vs?.sessionId || !ev?.token || !ev?.endpoint)
+            return;
+        await this.node.rest.updatePlayer({
+            guildId: this.options.guildId,
+            data: {
+                voice: {
+                    token: ev.token,
+                    endpoint: ev.endpoint,
+                    sessionId: vs.sessionId,
+                    channelId: vs.channelId,
+                },
+            },
+        });
+    }
 }
 exports.Player = Player;

package/dist/structures/Plugin.d.ts

@@ -0,0 +1,23 @@
+import { Manager } from "./Manager";
+/**
+ * Base abstract class for all plugins.
+ * Users must extend this and implement load and unload methods.
+ */
+export declare abstract class Plugin {
+    readonly name: string;
+    /**
+     * @param name The name of the plugin
+     */
+    constructor(name: string);
+    /**
+     * Load the plugin.
+     * @param manager The MagmaStream Manager instance
+     */
+    abstract load(manager: Manager): void;
+    /**
+     * Unload the plugin.
+     * Called on shutdown to gracefully cleanup resources or detach listeners.
+     * @param manager The MagmaStream Manager instance
+     */
+    abstract unload(manager: Manager): void;
+}

package/dist/structures/Rest.d.ts

@@ -0,0 +1,93 @@
+import { Node } from "./Node";
+import { Manager } from "./Manager";
+import { LavaPlayer, RestPlayOptions } from "./Types";
+/** Handles the requests sent to the Lavalink REST API. */
+export declare class Rest {
+    /** The Node that this Rest instance is connected to. */
+    private node;
+    /** The ID of the current session. */
+    private sessionId;
+    /** The password for the Node. */
+    private readonly password;
+    /** The URL of the Node. */
+    private readonly url;
+    /** The Manager instance. */
+    manager: Manager;
+    /** Whether the node is a NodeLink. */
+    isNodeLink: boolean;
+    constructor(node: Node, manager: Manager);
+    /**
+     * Sets the session ID.
+     * This method is used to set the session ID after a resume operation is done.
+     * @param {string} sessionId The session ID to set.
+     * @returns {string} Returns the set session ID.
+     */
+    setSessionId(sessionId: string): string;
+    /**
+     * Retrieves one the player that is currently running on the node.
+     * @returns {Promise<unknown>} Returns the result of the GET request.
+     */
+    getPlayer(guildId: string): Promise<LavaPlayer>;
+    /**
+     * Sends a PATCH request to update player related data.
+     * @param {RestPlayOptions} options The options to update the player with.
+     * @returns {Promise<unknown>} Returns the result of the PATCH request.
+     */
+    updatePlayer(options: RestPlayOptions): Promise<unknown>;
+    /**
+     * Sends a DELETE request to the server to destroy the player.
+     * @param {string} guildId The guild ID of the player to destroy.
+     * @returns {Promise<unknown>} Returns the result of the DELETE request.
+     */
+    destroyPlayer(guildId: string): Promise<unknown>;
+    /**
+     * Updates the session status for resuming.
+     * This method sends a PATCH request to update the session's resuming status and timeout.
+     *
+     * @param {boolean} resuming - Indicates whether the session should be set to resuming.
+     * @param {number} timeout - The timeout duration for the session resume.
+     * @returns {Promise<unknown>} The result of the PATCH request.
+     */
+    updateSession(resuming: boolean, timeout: number): Promise<unknown>;
+    /**
+     * Sends a request to the specified endpoint and returns the response data.
+     * @param {string} method The HTTP method to use for the request.
+     * @param {string} endpoint The endpoint to send the request to.
+     * @param {unknown} [body] The data to send in the request body.
+     * @returns {Promise<unknown>} The response data of the request.
+     */
+    private request;
+    /**
+     * Sends a GET request to the specified endpoint and returns the response data.
+     * @param {string} endpoint The endpoint to send the GET request to.
+     * @returns {Promise<unknown>} The response data of the GET request.
+     */
+    get(endpoint: string): Promise<unknown>;
+    /**
+     * Sends a PATCH request to the specified endpoint and returns the response data.
+     * @param {string} endpoint The endpoint to send the PATCH request to.
+     * @param {unknown} body The data to send in the request body.
+     * @returns {Promise<unknown>} The response data of the PATCH request.
+     */
+    patch(endpoint: string, body: unknown): Promise<unknown>;
+    /**
+     * Sends a POST request to the specified endpoint and returns the response data.
+     * @param {string} endpoint The endpoint to send the POST request to.
+     * @param {unknown} body The data to send in the request body.
+     * @returns {Promise<unknown>} The response data of the POST request.
+     */
+    post(endpoint: string, body: unknown): Promise<unknown>;
+    /**
+     * Sends a PUT request to the specified endpoint and returns the response data.
+     * @param {string} endpoint The endpoint to send the PUT request to.
+     * @param {unknown} body The data to send in the request body.
+     * @returns {Promise<unknown>} The response data of the PUT request.
+     */
+    put(endpoint: string, body: unknown): Promise<unknown>;
+    /**
+     * Sends a DELETE request to the specified endpoint.
+     * @param {string} endpoint - The endpoint to send the DELETE request to.
+     * @returns {Promise<unknown>} The response data of the DELETE request.
+     */
+    delete(endpoint: string): Promise<unknown>;
+}

package/dist/structures/Rest.js

@@ -104,35 +104,55 @@ class Rest {
             },
             data: body,
             timeout: this.node.options.apiRequestTimeoutMs,
+            validateStatus: () => true,
         };
+        let response;
         try {
-            const response = await (0, axios_1.default)(config);
-            return response.data;
+            response = await (0, axios_1.default)(config);
         }
         catch (err) {
-            const error = err;
-            if (!error.response) {
-                throw new MagmastreamError_1.MagmaStreamError({
-                    code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
-                    message: `No response from node ${this.node.options.identifier}: ${error.message}`,
-                });
-            }
-            const data = error.response.data;
-            if (data?.message === "Guild not found") {
-                return [];
-            }
-            if (error.response.status === 401) {
-                throw new MagmastreamError_1.MagmaStreamError({
-                    code: Enums_1.MagmaStreamErrorCode.REST_UNAUTHORIZED,
-                    message: `Unauthorized access to node ${this.node.options.identifier}`,
-                });
-            }
-            const dataMessage = typeof data === "string" ? data : data?.message ? data.message : Utils_1.JSONUtils.safe(data, 2);
+            const message = err instanceof Error ? err.message : "Unknown error";
             throw new MagmastreamError_1.MagmaStreamError({
                 code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
-                message: `Request to node ${this.node.options.identifier} failed with status ${error.response.status}: ${dataMessage}`,
+                message: `No response from node ${this.node.options.identifier}: ${message}`,
             });
         }
+        const { status, data } = response;
+        if (status >= 200 && status < 300) {
+            return data;
+        }
+        // Lavalink sometimes returns "Guild not found" for inactive players
+        if (status === 404 && data?.message === "Guild not found") {
+            return [];
+        }
+        if (status === 401) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.REST_UNAUTHORIZED,
+                message: `Unauthorized access to node ${this.node.options.identifier}`,
+            });
+        }
+        if (status >= 400 && status < 500) {
+            const message = typeof data === "string"
+                ? data
+                : typeof data === "object" && data !== null && "message" in data && typeof data.message === "string"
+                    ? data.message
+                    : "Unknown client error";
+            return {
+                status,
+                error: true,
+                message,
+                data,
+            };
+        }
+        const safeMessage = typeof data === "string"
+            ? data
+            : typeof data === "object" && data !== null && "message" in data && typeof data.message === "string"
+                ? data.message
+                : Utils_1.JSONUtils.safe(data, 2);
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
+            message: `Request to node ${this.node.options.identifier} failed (${status}): ${safeMessage}`,
+        });
     }
     /**
      * Sends a GET request to the specified endpoint and returns the response data.