magmastream 2.9.0-dev.34 → 2.9.0-dev.36

package/dist/structures/Manager.js

@@ -13,8 +13,9 @@ const promises_1 = tslib_1.__importDefault(require("fs/promises"));
 const path_1 = tslib_1.__importDefault(require("path"));
 const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
 const Enums_1 = require("./Enums");
+const package_json_1 = require("../../package.json");
 /**
- * The main hub for interacting with Lavalink and using Magmastream,
+ * The main hub for interacting with Lavalink and using Magmastream.
  */
 class Manager extends events_1.EventEmitter {
     /** The map of players. */
@@ -58,23 +59,33 @@ class Manager extends events_1.EventEmitter {
         if (options.send && !this._send)
             this._send = options.send;
         this.options = {
-            enabledPlugins: [],
-            nodes: [
+            ...options,
+            enabledPlugins: options.enabledPlugins ?? [],
+            nodes: options.nodes ?? [
                 {
-                    identifier: "default",
-                    host: "localhost",
+                    identifier: "Cheap lavalink hosting @",
+                    host: "https://blackforthosting.com/products?category=lavalink",
+                    port: 443,
+                    password: "Try BlackForHosting",
+                    useSSL: true,
                     enableSessionResumeOption: false,
                     sessionTimeoutMs: 1000,
+                    nodePriority: 69,
                 },
             ],
-            playNextOnEnd: true,
-            enablePriorityMode: false,
-            clientName: "Magmastream",
-            defaultSearchPlatform: Enums_1.SearchPlatform.YouTube,
-            useNode: Enums_1.UseNodeOptions.LeastPlayers,
+            playNextOnEnd: options.playNextOnEnd ?? true,
+            enablePriorityMode: options.enablePriorityMode ?? false,
+            clientName: options.clientName ?? `Magmastream@${package_json_1.version}`,
+            defaultSearchPlatform: options.defaultSearchPlatform ?? Enums_1.SearchPlatform.YouTube,
+            useNode: options.useNode ?? Enums_1.UseNodeOptions.LeastPlayers,
             maxPreviousTracks: options.maxPreviousTracks ?? 20,
-            stateStorage: { type: Enums_1.StateStorageType.Collection },
-            ...options,
+            normalizeYouTubeTitles: options.normalizeYouTubeTitles ?? false,
+            stateStorage: {
+                ...options.stateStorage,
+                type: options.stateStorage?.type ?? Enums_1.StateStorageType.Memory,
+                deleteInactivePlayers: options.stateStorage?.deleteInactivePlayers ?? true,
+            },
+            autoPlaySearchPlatforms: options.autoPlaySearchPlatforms ?? [Enums_1.AutoPlayPlatform.YouTube],
         };
         Utils_1.AutoPlayUtils.init(this);
         if (this.options.nodes) {
@@ -92,7 +103,7 @@ class Manager extends events_1.EventEmitter {
                 }, 2000);
             }
             catch (error) {
-                console.error("Error during shutdown:", error);
+                console.error(`[MANAGER] Error during shutdown: ${error}`);
                 process.exit(1);
             }
         });
@@ -104,7 +115,7 @@ class Manager extends events_1.EventEmitter {
                 process.exit(0);
             }
             catch (error) {
-                console.error("Error during SIGTERM shutdown:", error);
+                console.error(`[MANAGER] Error during SIGTERM shutdown: ${error}`);
                 process.exit(1);
             }
         });
@@ -127,7 +138,7 @@ class Manager extends events_1.EventEmitter {
             this.options.clientId = clientId;
         }
         if (typeof clusterId !== "number") {
-            console.warn('"clusterId" is not a valid number, defaulting to 0.');
+            console.warn(`[MANAGER] "clusterId" is not a valid number, defaulting to 0.`);
             this.options.clusterId = 0;
         }
         else {
@@ -148,7 +159,7 @@ class Manager extends events_1.EventEmitter {
                 plugin.load(this);
             }
         }
-        if (this.options.stateStorage?.type === Enums_1.StateStorageType.Redis) {
+        if (this.options.stateStorage.type === Enums_1.StateStorageType.Redis) {
             const config = this.options.stateStorage.redisConfig;
             this.redis = new ioredis_1.default({
                 host: config.host,
@@ -278,7 +289,6 @@ class Manager extends events_1.EventEmitter {
         if (!player)
             return;
         await player.destroy();
-        await this.cleanupInactivePlayers();
     }
     /**
      * Creates a new node or returns an existing one if it already exists.
@@ -385,21 +395,22 @@ class Manager extends events_1.EventEmitter {
      */
     async savePlayerState(guildId) {
         switch (this.options.stateStorage.type) {
-            case Enums_1.StateStorageType.Collection:
+            case Enums_1.StateStorageType.Memory:
+            case Enums_1.StateStorageType.JSON:
                 {
                     try {
                         const playerStateFilePath = await this.getPlayerFilePath(guildId);
                         const player = this.getPlayer(guildId);
                         if (!player || player.state === Enums_1.StateTypes.Disconnected || !player.voiceChannelId) {
-                            console.warn(`Skipping save for inactive player: ${guildId}`);
+                            console.warn(`[MANAGER] Skipping save for inactive player: ${guildId}`);
                             return;
                         }
-                        const serializedPlayer = this.serializePlayer(player);
+                        const serializedPlayer = await this.serializePlayer(player);
                         await promises_1.default.writeFile(playerStateFilePath, JSON.stringify(serializedPlayer, null, 2), "utf-8");
                         this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Player state saved: ${guildId}`);
                     }
                     catch (error) {
-                        console.error(`Error saving player state for guild ${guildId}:`, error);
+                        console.error(`[MANAGER] Error saving player state for guild ${guildId}:`, error);
                     }
                 }
                 break;
@@ -408,10 +419,10 @@ class Manager extends events_1.EventEmitter {
                     try {
                         const player = this.getPlayer(guildId);
                         if (!player || player.state === Enums_1.StateTypes.Disconnected || !player.voiceChannelId) {
-                            console.warn(`Skipping save for inactive player: ${guildId}`);
+                            console.warn(`[MANAGER] Skipping save for inactive player: ${guildId}`);
                             return;
                         }
-                        const serializedPlayer = this.serializePlayer(player);
+                        const serializedPlayer = await this.serializePlayer(player);
                         const redisKey = `${this.options.stateStorage.redisConfig.prefix?.endsWith(":")
                             ? this.options.stateStorage.redisConfig.prefix
                             : this.options.stateStorage.redisConfig.prefix ?? "magmastream:"}playerstore:${guildId}`;
@@ -419,7 +430,7 @@ class Manager extends events_1.EventEmitter {
                         this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Player state saved to Redis: ${guildId}`);
                     }
                     catch (error) {
-                        console.error(`Error saving player state to Redis for guild ${guildId}:`, error);
+                        console.error(`[MANAGER] Error saving player state to Redis for guild ${guildId}:`, error);
                     }
                 }
                 break;
@@ -447,9 +458,9 @@ class Manager extends events_1.EventEmitter {
             throw new Error(`Could not find node: ${nodeId}`);
         const info = (await node.rest.getAllPlayers());
         switch (this.options.stateStorage.type) {
-            case Enums_1.StateStorageType.Collection:
+            case Enums_1.StateStorageType.JSON:
                 {
-                    const playerStatesDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
+                    const playerStatesDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "playerStore");
                     try {
                         // Check if the directory exists, and create it if it doesn't
                         await promises_1.default.access(playerStatesDir).catch(async () => {
@@ -491,39 +502,72 @@ class Manager extends events_1.EventEmitter {
                                     const tracks = [];
                                     const currentTrack = state.queue.current;
                                     const queueTracks = state.queue.tracks;
-                                    if (lavaPlayer) {
-                                        if (lavaPlayer.track) {
-                                            tracks.push(...queueTracks);
-                                            if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
-                                                await player.queue.setCurrent(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
-                                            }
+                                    if (state.isAutoplay) {
+                                        Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
+                                        player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
+                                    }
+                                    if (lavaPlayer?.track) {
+                                        // If lavaPlayer has a track, push all queue tracks
+                                        tracks.push(...queueTracks);
+                                        // Set current track if matches lavaPlayer's track URI
+                                        if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
+                                            await player.queue.setCurrent(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
                                         }
-                                        else {
-                                            if (!currentTrack) {
-                                                const payload = {
-                                                    reason: Enums_1.TrackEndReasonTypes.Finished,
-                                                };
-                                                await node.queueEnd(player, currentTrack, payload);
-                                            }
-                                            else {
-                                                tracks.push(currentTrack, ...queueTracks);
-                                            }
+                                        // Add tracks to queue
+                                        if (tracks.length > 0) {
+                                            await player.queue.clear();
+                                            await player.queue.add(tracks);
                                         }
                                     }
                                     else {
-                                        if (!currentTrack) {
-                                            const payload = {
+                                        // LavaPlayer missing track or lavaPlayer is falsy
+                                        if (currentTrack) {
+                                            if (queueTracks.length > 0) {
+                                                tracks.push(...queueTracks);
+                                                await player.queue.clear();
+                                                await player.queue.add(tracks);
+                                            }
+                                            await node.trackEnd(player, currentTrack, {
                                                 reason: Enums_1.TrackEndReasonTypes.Finished,
-                                            };
-                                            await node.queueEnd(player, currentTrack, payload);
+                                                type: "TrackEndEvent",
+                                            });
                                         }
                                         else {
-                                            tracks.push(currentTrack, ...queueTracks);
+                                            // No current track, check previous queue for last track
+                                            const previousQueue = await player.queue.getPrevious();
+                                            const lastTrack = previousQueue?.at(-1);
+                                            if (lastTrack) {
+                                                if (queueTracks.length === 0) {
+                                                    // If no tracks in queue, end last track
+                                                    await node.trackEnd(player, lastTrack, {
+                                                        reason: Enums_1.TrackEndReasonTypes.Finished,
+                                                        type: "TrackEndEvent",
+                                                    });
+                                                }
+                                                else {
+                                                    // If there are queued tracks, add them
+                                                    tracks.push(...queueTracks);
+                                                    if (tracks.length > 0) {
+                                                        await player.queue.clear();
+                                                        await player.queue.add(tracks);
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                if (queueTracks.length > 0) {
+                                                    tracks.push(...queueTracks);
+                                                    if (tracks.length > 0) {
+                                                        await player.queue.clear();
+                                                        await player.queue.add(tracks);
+                                                    }
+                                                    await node.trackEnd(player, lastTrack, {
+                                                        reason: Enums_1.TrackEndReasonTypes.Finished,
+                                                        type: "TrackEndEvent",
+                                                    });
+                                                }
+                                            }
                                         }
                                     }
-                                    if (tracks.length > 0) {
-                                        await player.queue.add(tracks);
-                                    }
                                     if (state.queue.previous.length > 0) {
                                         await player.queue.addPrevious(state.queue.previous);
                                     }
@@ -543,10 +587,6 @@ class Manager extends events_1.EventEmitter {
                                     if (state.dynamicRepeat) {
                                         player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval._idleTimeout);
                                     }
-                                    if (state.isAutoplay) {
-                                        Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
-                                        player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
-                                    }
                                     if (state.data) {
                                         for (const [name, value] of Object.entries(state.data)) {
                                             player.set(name, value);
@@ -661,39 +701,72 @@ class Manager extends events_1.EventEmitter {
                                     const tracks = [];
                                     const currentTrack = state.queue.current;
                                     const queueTracks = state.queue.tracks;
-                                    if (lavaPlayer) {
-                                        if (lavaPlayer.track) {
-                                            tracks.push(...queueTracks);
-                                            if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
-                                                await player.queue.setCurrent(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
-                                            }
+                                    if (state.isAutoplay) {
+                                        Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
+                                        player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
+                                    }
+                                    if (lavaPlayer?.track) {
+                                        // If lavaPlayer has a track, push all queue tracks
+                                        tracks.push(...queueTracks);
+                                        // Set current track if matches lavaPlayer's track URI
+                                        if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
+                                            await player.queue.setCurrent(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
                                         }
-                                        else {
-                                            if (!currentTrack) {
-                                                const payload = {
-                                                    reason: Enums_1.TrackEndReasonTypes.Finished,
-                                                };
-                                                await node.queueEnd(player, currentTrack, payload);
-                                            }
-                                            else {
-                                                tracks.push(currentTrack, ...queueTracks);
-                                            }
+                                        // Add tracks to queue
+                                        if (tracks.length > 0) {
+                                            await player.queue.clear();
+                                            await player.queue.add(tracks);
                                         }
                                     }
                                     else {
-                                        if (!currentTrack) {
-                                            const payload = {
+                                        // LavaPlayer missing track or lavaPlayer is falsy
+                                        if (currentTrack) {
+                                            if (queueTracks.length > 0) {
+                                                tracks.push(...queueTracks);
+                                                await player.queue.clear();
+                                                await player.queue.add(tracks);
+                                            }
+                                            await node.trackEnd(player, currentTrack, {
                                                 reason: Enums_1.TrackEndReasonTypes.Finished,
-                                            };
-                                            await node.queueEnd(player, currentTrack, payload);
+                                                type: "TrackEndEvent",
+                                            });
                                         }
                                         else {
-                                            tracks.push(currentTrack, ...queueTracks);
+                                            // No current track, check previous queue for last track
+                                            const previousQueue = await player.queue.getPrevious();
+                                            const lastTrack = previousQueue?.at(-1);
+                                            if (lastTrack) {
+                                                if (queueTracks.length === 0) {
+                                                    // If no tracks in queue, end last track
+                                                    await node.trackEnd(player, lastTrack, {
+                                                        reason: Enums_1.TrackEndReasonTypes.Finished,
+                                                        type: "TrackEndEvent",
+                                                    });
+                                                }
+                                                else {
+                                                    // If there are queued tracks, add them
+                                                    tracks.push(...queueTracks);
+                                                    if (tracks.length > 0) {
+                                                        await player.queue.clear();
+                                                        await player.queue.add(tracks);
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                if (queueTracks.length > 0) {
+                                                    tracks.push(...queueTracks);
+                                                    if (tracks.length > 0) {
+                                                        await player.queue.clear();
+                                                        await player.queue.add(tracks);
+                                                    }
+                                                    await node.trackEnd(player, lastTrack, {
+                                                        reason: Enums_1.TrackEndReasonTypes.Finished,
+                                                        type: "TrackEndEvent",
+                                                    });
+                                                }
+                                            }
                                         }
                                     }
-                                    if (tracks.length > 0) {
-                                        await player.queue.add(tracks);
-                                    }
                                     if (state.queue.previous.length > 0) {
                                         await player.queue.addPrevious(state.queue.previous);
                                     }
@@ -713,10 +786,6 @@ class Manager extends events_1.EventEmitter {
                                     if (state.dynamicRepeat) {
                                         player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval._idleTimeout);
                                     }
-                                    if (state.isAutoplay) {
-                                        Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
-                                        player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
-                                    }
                                     if (state.data) {
                                         for (const [name, value] of Object.entries(state.data)) {
                                             player.set(name, value);
@@ -804,26 +873,25 @@ 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();
-            }
+            await this.clearAllStoredPlayers();
             const savePromises = Array.from(this.players.keys()).map(async (guildId) => {
                 try {
                     await this.savePlayerState(guildId);
                 }
                 catch (error) {
-                    console.error(`Error saving player state for guild ${guildId}:`, error);
+                    console.error(`[MANAGER] Error saving player state for guild ${guildId}:`, error);
                 }
             });
+            if (this.options.stateStorage.deleteInactivePlayers)
+                await this.cleanupInactivePlayers();
             await Promise.allSettled(savePromises);
-            await this.cleanupInactivePlayers();
             setTimeout(() => {
                 console.warn("\x1b[32m%s\x1b[0m", "MAGMASTREAM INFO: Shutting down complete, exiting...");
                 process.exit(0);
             }, 500);
         }
         catch (error) {
-            console.error("Unexpected error during shutdown:", error);
+            console.error(`[MANAGER] Unexpected error during shutdown:`, error);
             process.exit(1);
         }
     }
@@ -973,13 +1041,13 @@ class Manager extends events_1.EventEmitter {
      * @returns {string} The path to the player's JSON file
      */
     async getPlayerFilePath(guildId) {
-        const configDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
+        const configDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "playerStore");
         try {
             await promises_1.default.mkdir(configDir, { recursive: true });
             return path_1.default.join(configDir, `${guildId}.json`);
         }
         catch (err) {
-            console.error("Error ensuring player data directory exists:", err);
+            console.error(`[MANAGER] Error ensuring player data directory exists: ${err}`);
             throw new Error(`Failed to resolve player file path for guild ${guildId}`);
         }
     }
@@ -988,8 +1056,12 @@ class Manager extends events_1.EventEmitter {
      * @param player The Player instance to serialize
      * @returns The serialized Player instance
      */
-    serializePlayer(player) {
+    async serializePlayer(player) {
         const seen = new WeakSet();
+        // Fetch async queue data once before serializing
+        const current = await player.queue.getCurrent();
+        const tracks = Array.isArray(await player.queue.getTracks()) ? await player.queue.getTracks() : [];
+        const previous = Array.isArray(await player.queue.getPrevious()) ? await player.queue.getPrevious() : [];
         /**
          * Recursively serializes an object, avoiding circular references.
          * @param obj The object to serialize
@@ -1025,9 +1097,9 @@ class Manager extends events_1.EventEmitter {
             }
             if (key === "queue") {
                 return {
-                    current: value.current || null,
-                    tracks: Array.isArray(value) ? [...value] : [],
-                    previous: Array.isArray(value.previous) ? [...value.previous] : [],
+                    current,
+                    tracks,
+                    previous,
                 };
             }
             if (key === "data") {
@@ -1039,45 +1111,135 @@ class Manager extends events_1.EventEmitter {
         }));
     }
     /**
-     * Checks for players that are no longer active and deletes their saved state files.
+     * Cleans up inactive players by removing their state files from the file system.
      * This is done to prevent stale state files from accumulating on the file system.
      */
     async cleanupInactivePlayers() {
-        const playerStatesDir = 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(playerStatesDir).catch(async () => {
-                await promises_1.default.mkdir(playerStatesDir, { recursive: true });
-                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Created directory: ${playerStatesDir}`);
-            });
-            // Get the list of player state files
-            const playerFiles = await promises_1.default.readdir(playerStatesDir);
-            // Get the set of active guild IDs from the manager's player collection
-            const activeGuildIds = new Set(this.players.keys());
-            // Iterate over the player state files
-            for (const file of playerFiles) {
-                // Get the guild ID from the file name
-                const guildId = path_1.default.basename(file, ".json");
-                // If the guild ID is not in the set of active guild IDs, delete the file
-                if (!activeGuildIds.has(guildId)) {
-                    const filePath = path_1.default.join(playerStatesDir, file);
-                    await promises_1.default.unlink(filePath); // Delete the file asynchronously
-                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleting inactive player: ${guildId}`);
+        switch (this.options.stateStorage.type) {
+            case Enums_1.StateStorageType.JSON:
+                {
+                    const playersStoreDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "playersStore");
+                    const playersDataDir = this.options.stateStorage?.jsonConfig?.path ?? path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
+                    try {
+                        await promises_1.default.mkdir(playersStoreDir, { recursive: true });
+                        await promises_1.default.mkdir(playersDataDir, { recursive: true });
+                        const activeGuildIds = new Set(this.players.keys());
+                        // Clean up playersStore/*.json
+                        const playerStateFiles = await promises_1.default.readdir(playersStoreDir);
+                        for (const file of playerStateFiles) {
+                            const guildId = path_1.default.basename(file, ".json");
+                            if (!activeGuildIds.has(guildId)) {
+                                const filePath = path_1.default.join(playersStoreDir, file);
+                                await promises_1.default.unlink(filePath);
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted inactive player state: ${guildId}`);
+                            }
+                        }
+                        // Clean up players/<guildId>/ folders
+                        const guildDirs = await promises_1.default.readdir(playersDataDir, { withFileTypes: true });
+                        for (const dirent of guildDirs) {
+                            if (!dirent.isDirectory())
+                                continue;
+                            const guildId = dirent.name;
+                            if (!activeGuildIds.has(guildId)) {
+                                const guildPath = path_1.default.join(playersDataDir, guildId);
+                                await promises_1.default.rm(guildPath, { recursive: true, force: true });
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted inactive player data folder: ${guildId}`);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error cleaning up inactive JSON players: ${error}`);
+                    }
+                    return;
                 }
-            }
+                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}queue:*:current`;
+                    const stream = this.redis.scanStream({
+                        match: pattern,
+                        count: 100,
+                    });
+                    for await (const keys of stream) {
+                        for (const key of keys) {
+                            // Extract guildId from queue key
+                            const match = key.match(new RegExp(`^${prefix}queue:(.+):current$`));
+                            if (!match)
+                                continue;
+                            const guildId = match[1];
+                            // If player is not active in memory, clean up all keys
+                            if (!this.players.has(guildId)) {
+                                await this.redis.del(`${prefix}playerstore:${guildId}`, `${prefix}queue:${guildId}:current`, `${prefix}queue:${guildId}:tracks`, `${prefix}queue:${guildId}:previous`);
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Cleaned inactive Redis player data: ${guildId}`);
+                            }
+                        }
+                    }
+                    return;
+                }
+                break;
+            default:
+                break;
         }
-        catch (error) {
-            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error cleaning up inactive players: ${error}`);
+    }
+    /**
+     * Cleans up an inactive player by removing its state files from the file system.
+     * This is done to prevent stale state files from accumulating on the file system.
+     * @param guildId The guild ID of the player to clean up.
+     */
+    async cleanupInactivePlayer(guildId) {
+        switch (this.options.stateStorage.type) {
+            case Enums_1.StateStorageType.JSON:
+                {
+                    const playersStoreDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "playersStore");
+                    const playersDataDir = this.options.stateStorage?.jsonConfig?.path ?? path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
+                    try {
+                        if (!this.players.has(guildId)) {
+                            await promises_1.default.unlink(path_1.default.join(playersStoreDir, `${guildId}.json`));
+                            await promises_1.default.rm(path_1.default.join(playersDataDir, guildId), { recursive: true, force: true });
+                            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleting inactive player files: ${guildId}`);
+                        }
+                    }
+                    catch (error) {
+                        if (error.code !== "ENOENT") {
+                            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error deleting player files for ${guildId}: ${error}`);
+                        }
+                    }
+                }
+                break;
+            case Enums_1.StateStorageType.Redis:
+                {
+                    const player = this.getPlayer(guildId);
+                    if (!player) {
+                        const prefix = this.options.stateStorage.redisConfig.prefix?.endsWith(":")
+                            ? this.options.stateStorage.redisConfig.prefix
+                            : `${this.options.stateStorage.redisConfig.prefix ?? "magmastream"}:`;
+                        const keysToDelete = [
+                            `${prefix}playerstore:${guildId}`,
+                            `${prefix}queue:${guildId}:tracks`,
+                            `${prefix}queue:${guildId}:current`,
+                            `${prefix}queue:${guildId}:previous`,
+                        ];
+                        await this.redis.del(...keysToDelete);
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted Redis player and queue data for: ${guildId}`);
+                    }
+                }
+                break;
+            default:
+                break;
         }
     }
     /**
      * Clears all player states from the file system.
      * This is done to prevent stale state files from accumulating on the file system.
      */
-    async clearAllPlayerStates() {
+    async clearAllStoredPlayers() {
         switch (this.options.stateStorage.type) {
-            case Enums_1.StateStorageType.Collection: {
-                const configDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
+            case Enums_1.StateStorageType.Memory:
+            case Enums_1.StateStorageType.JSON: {
+                const configDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "playerStore");
                 try {
                     // Check if the directory exists, and create it if it doesn't
                     await promises_1.default.access(configDir).catch(async () => {
@@ -1085,11 +1247,11 @@ class Manager extends events_1.EventEmitter {
                         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))));
+                    await Promise.all(files.map((file) => promises_1.default.unlink(path_1.default.join(configDir, file)).catch((err) => console.warn(`[MANAGER] 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);
+                    console.error("[MANAGER] Error clearing player state files:", err);
                 }
                 break;
             }
@@ -1116,11 +1278,11 @@ class Manager extends events_1.EventEmitter {
                         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);
+                        console.error("[MANAGER] Error during Redis SCAN stream:", err);
                     });
                 }
                 catch (err) {
-                    console.error("Failed to clear Redis player state keys:", err);
+                    console.error("[MANAGER] Failed to clear Redis player state keys:", err);
                 }
                 break;
             }