ziplayer 0.2.1 → 0.2.3-dev-1

package/src/structures/Player.ts

@@ -13,7 +13,6 @@ import {
 	StreamType,
 } from "@discordjs/voice";
 
-import { VoiceChannel } from "discord.js";
 import { Readable } from "stream";
 import type { BaseExtension } from "../extensions";
 import type {
@@ -26,6 +25,7 @@ import type {
 	LoopMode,
 	StreamInfo,
 	SaveOptions,
+	VoiceChannel,
 	ExtensionPlayRequest,
 	ExtensionPlayResponse,
 	ExtensionAfterPlayPayload,
@@ -160,6 +160,25 @@ export class Player extends EventEmitter {
 		}
 	}
 
+	/**
+	 * Destroy current stream to prevent memory leaks
+	 * @private
+	 */
+	private destroyCurrentStream(): void {
+		try {
+			// Get the metadata from current resource to find the stream
+			if (this.currentResource) {
+				const stream = (this.currentResource as any)?.metadata?.stream || (this.currentResource as any)?.stream;
+				if (stream && typeof stream.destroy === "function") {
+					stream.destroy();
+					this.debug(`[Player] Destroyed current stream`);
+				}
+			}
+		} catch (error) {
+			this.debug(`[Player] Error destroying current stream:`, error);
+		}
+	}
+
 	//#region Search
 
 	/**
@@ -335,13 +354,21 @@ export class Player extends EventEmitter {
 		};
 	}
 
-	private async generateWillNext(): Promise<void> {
-		const lastTrack = this.queue.previousTracks[this.queue.previousTracks.length - 1] ?? this.queue.currentTrack;
-		if (!lastTrack) return;
+	/**
+	 * Get related tracks for a given track
+	 * @param {Track} track Track to find related tracks for
+	 * @returns {Track[]} Related tracks or empty array
+	 * @example
+	 * const related = await player.getRelatedTracks(track);
+	 * console.log(`Found ${related.length} related tracks`);
+	 */
+	async getRelatedTracks(track: Track): Promise<Track[]> {
+		if (!track) return [];
+
+		const preferred = this.pluginManager.findPlugin(track.url) || this.pluginManager.get(track.source);
 
-		// Build list of candidate plugins: preferred first, then others with getRelatedTracks
-		const preferred = this.pluginManager.findPlugin(lastTrack.url) || this.pluginManager.get(lastTrack.source);
 		const all = this.pluginManager.getAll();
+
 		const candidates = [...(preferred ? [preferred] : []), ...all.filter((p) => p !== preferred)].filter(
 			(p) => typeof (p as any).getRelatedTracks === "function",
 		);
@@ -350,7 +377,7 @@ export class Player extends EventEmitter {
 			try {
 				this.debug(`[Player] Trying related from plugin: ${p.name}`);
 				const related = await withTimeout(
-					(p as any).getRelatedTracks(lastTrack.url, {
+					(p as any).getRelatedTracks(track.url, {
 						limit: 10,
 						history: this.queue.previousTracks,
 					}),
@@ -359,20 +386,29 @@ export class Player extends EventEmitter {
 				);
 
 				if (Array.isArray(related) && related.length > 0) {
-					const randomchoice = Math.floor(Math.random() * related.length);
-					const nextTrack = this.queue.nextTrack ? this.queue.nextTrack : related[randomchoice];
-					this.queue.willNextTrack(nextTrack);
-					this.queue.relatedTracks(related);
-					this.debug(`[Player] Will next track if autoplay: ${nextTrack?.title} (via ${p.name})`);
-					this.emit("willPlay", nextTrack, related);
-					return; // success
+					return related; // success
 				}
 				this.debug(`[Player] ${p.name} returned no related tracks`);
 			} catch (err) {
 				this.debug(`[Player] getRelatedTracks error from ${p.name}:`, err);
+				return [];
 				// try next candidate
 			}
 		}
+		return [];
+	}
+
+	private async generateWillNext(): Promise<void> {
+		const lastTrack = this.queue.previousTracks[this.queue.previousTracks.length - 1] ?? this.queue.currentTrack;
+		if (!lastTrack) return;
+		const related = await this.getRelatedTracks(lastTrack);
+		if (!related || related.length === 0) return;
+		const randomchoice = Math.floor(Math.random() * related.length);
+		const nextTrack = this.queue.nextTrack ? this.queue.nextTrack : related[randomchoice];
+		this.queue.willNextTrack(nextTrack);
+		this.queue.relatedTracks(related);
+		this.debug(`[Player] Will next track if autoplay: ${nextTrack?.title}]`);
+		this.emit("willPlay", nextTrack, related);
 	}
 	//#endregion
 	//#region Play
@@ -393,13 +429,10 @@ export class Player extends EventEmitter {
 	 */
 	async play(query: string | Track | SearchResult | null, requestedBy?: string): Promise<boolean> {
 		const debugInfo =
-			query === null
-				? "null"
-				: typeof query === "string"
-				? query
-				: "tracks" in query
-				? `${query.tracks.length} tracks`
-				: query.title || "unknown";
+			query === null ? "null"
+			: typeof query === "string" ? query
+			: "tracks" in query ? `${query.tracks.length} tracks`
+			: query.title || "unknown";
 		this.debug(`[Player] Play called with query: ${debugInfo}`);
 		this.clearLeaveTimeout();
 		let tracksToAdd: Track[] = [];
@@ -567,11 +600,9 @@ export class Player extends EventEmitter {
 			const resource = createAudioResource(stream, {
 				metadata: track,
 				inputType:
-					streamInfo.type === "webm/opus"
-						? StreamType.WebmOpus
-						: streamInfo.type === "ogg/opus"
-						? StreamType.OggOpus
-						: StreamType.Arbitrary,
+					streamInfo.type === "webm/opus" ? StreamType.WebmOpus
+					: streamInfo.type === "ogg/opus" ? StreamType.OggOpus
+					: StreamType.Arbitrary,
 				inlineVolume: true,
 			});
 
@@ -583,11 +614,9 @@ export class Player extends EventEmitter {
 				const resource = createAudioResource(streamInfo.stream, {
 					metadata: track,
 					inputType:
-						streamInfo.type === "webm/opus"
-							? StreamType.WebmOpus
-							: streamInfo.type === "ogg/opus"
-							? StreamType.OggOpus
-							: StreamType.Arbitrary,
+						streamInfo.type === "webm/opus" ? StreamType.WebmOpus
+						: streamInfo.type === "ogg/opus" ? StreamType.OggOpus
+						: StreamType.Arbitrary,
 					inlineVolume: true,
 				});
 				return resource;
@@ -615,6 +644,18 @@ export class Player extends EventEmitter {
 			// Kiểm tra nếu có stream thực sự để tạo AudioResource
 			if (streamInfo && (streamInfo as any).stream) {
 				try {
+					// Destroy the old stream and resource before creating a new one
+					this.destroyCurrentStream();
+					if (this.currentResource) {
+						try {
+							const oldStream = (this.currentResource as any)._readableState?.stream || (this.currentResource as any).stream;
+							if (oldStream && typeof oldStream.destroy === "function") {
+								oldStream.destroy();
+							}
+						} catch {}
+						this.currentResource = null;
+					}
+
 					this.currentResource = await this.createResource(streamInfo, track, 0);
 					if (this.volumeInterval) {
 						clearInterval(this.volumeInterval);
@@ -635,11 +676,9 @@ export class Player extends EventEmitter {
 						const fallbackResource = createAudioResource(streamInfo.stream, {
 							metadata: track,
 							inputType:
-								streamInfo.type === "webm/opus"
-									? StreamType.WebmOpus
-									: streamInfo.type === "ogg/opus"
-									? StreamType.OggOpus
-									: StreamType.Arbitrary,
+								streamInfo.type === "webm/opus" ? StreamType.WebmOpus
+								: streamInfo.type === "ogg/opus" ? StreamType.OggOpus
+								: StreamType.Arbitrary,
 							inlineVolume: true,
 						});
 
@@ -735,6 +774,9 @@ export class Player extends EventEmitter {
 			this.audioPlayer.state.status === AudioPlayerStatus.Playing ||
 			this.audioPlayer.state.status === AudioPlayerStatus.Buffering;
 
+		let ttsResource: AudioResource | null = null;
+		let ttsStream: any = null;
+
 		try {
 			if (!this.connection) throw new Error("No voice connection for TTS");
 			const ttsPlayer = this.ensureTTSPlayer();
@@ -744,10 +786,12 @@ export class Player extends EventEmitter {
 			if (!streamInfo) {
 				throw new Error("No stream available for track: ${track.title}");
 			}
+			ttsStream = streamInfo.stream;
 			const resource = await this.createResource(streamInfo as StreamInfo, track);
 			if (!resource) {
 				throw new Error("No resource available for track: ${track.title}");
 			}
+			ttsResource = resource;
 			if (resource.volume) {
 				resource.volume.setVolume((this.options?.tts?.volume ?? this?.volume ?? 100) / 100);
 			}
@@ -767,8 +811,15 @@ export class Player extends EventEmitter {
 			// Derive timeoutMs from resource/track duration when available, with a sensible cap
 			const md: any = (resource as any)?.metadata ?? {};
 			const declared =
-				typeof md.duration === "number" ? md.duration : typeof track?.duration === "number" ? track.duration : undefined;
-			const declaredMs = declared ? (declared > 1000 ? declared : declared * 1000) : undefined;
+				typeof md.duration === "number" ? md.duration
+				: typeof track?.duration === "number" ? track.duration
+				: undefined;
+			const declaredMs =
+				declared ?
+					declared > 1000 ?
+						declared
+					:	declared * 1000
+				:	undefined;
 			const cap = this.options?.tts?.Max_Time_TTS ?? 60_000;
 			const idleTimeout = declaredMs ? Math.min(cap, Math.max(1_000, declaredMs + 1_500)) : cap;
 			await entersState(ttsPlayer, AudioPlayerStatus.Idle, idleTimeout).catch(() => null);
@@ -779,6 +830,15 @@ export class Player extends EventEmitter {
 			this.debug("[TTS] error while playing:", err);
 			this.emit("playerError", err as Error);
 		} finally {
+			// Clean up TTS stream and resource
+			try {
+				if (ttsStream && typeof ttsStream.destroy === "function") {
+					ttsStream.destroy();
+				}
+			} catch (error) {
+				this.debug("[TTS] Error destroying stream:", error);
+			}
+
 			if (wasPlaying) {
 				try {
 					this.resume();
@@ -1052,9 +1112,20 @@ export class Player extends EventEmitter {
 
 			// Apply filters if any are active
 			let finalStream = streamInfo.stream;
-			if (this.filter.getActiveFilters().length > 0) {
+
+			if (saveOptions.filter || saveOptions.seek) {
+				try {
+					this.filter.clearAll();
+					this.filter.applyFilters(saveOptions.filter || []);
+				} catch (err) {
+					this.debug(`[Player] Error applying save filters:`, err);
+				}
+
 				this.debug(`[Player] Applying filters to save stream: ${this.filter.getFilterString() || "none"}`);
-				finalStream = await this.filter.applyFiltersAndSeek(streamInfo.stream);
+				finalStream = await this.filter.applyFiltersAndSeek(streamInfo.stream, saveOptions.seek || 0).catch((err) => {
+					this.debug(`[Player] Error applying filters to save stream:`, err);
+					return streamInfo!.stream; // Fallback to original stream
+				});
 			}
 
 			// Return the stream directly - caller can pipe it to fs.createWriteStream()
@@ -1338,6 +1409,9 @@ export class Player extends EventEmitter {
 			this.leaveTimeout = null;
 		}
 
+		// Destroy current stream before stopping audio
+		this.destroyCurrentStream();
+
 		this.audioPlayer.stop(true);
 
 		if (this.ttsPlayer) {
@@ -1358,6 +1432,13 @@ export class Player extends EventEmitter {
 		this.extensionManager.destroy();
 		this.isPlaying = false;
 		this.isPaused = false;
+
+		// Clear any remaining intervals
+		if (this.volumeInterval) {
+			clearInterval(this.volumeInterval);
+			this.volumeInterval = null;
+		}
+
 		this.emit("playerDestroy");
 		this.removeAllListeners();
 	}
@@ -1409,11 +1490,24 @@ export class Player extends EventEmitter {
 			// Create AudioResource with filters and seek to current position
 			const resource = await this.createResource(streaminfo, track, currentPosition);
 
-			// Stop current playback and start new one
+			// Stop current playback and destroy old resource/stream
 			const wasPlaying = this.isPlaying;
 			const wasPaused = this.isPaused;
 
 			this.audioPlayer.stop();
+
+			// Properly destroy the old resource and stream
+			try {
+				if (this.currentResource) {
+					const oldStream = (this.currentResource as any)._readableState?.stream || (this.currentResource as any).stream;
+					if (oldStream && typeof oldStream.destroy === "function") {
+						oldStream.destroy();
+					}
+				}
+			} catch (error) {
+				this.debug(`[Player] Error destroying old stream in refeshPlayerResource:`, error);
+			}
+
 			this.currentResource = resource;
 
 			// Subscribe to new resource

package/src/types/extension.ts

@@ -0,0 +1,129 @@
+import type { VoiceConnection } from "@discordjs/voice";
+import type { Player } from "../structures/Player";
+import type { PlayerManager } from "../structures/PlayerManager";
+import type { Track, SearchResult, StreamInfo } from ".";
+
+/**
+ * Extension interface
+ *
+ * @example
+ * const extension: SourceExtension = {
+ *   name: "YouTube",
+ *   version: "1.0.0"
+ * };
+ */
+export interface SourceExtension {
+	name: string;
+	version: string;
+	connection?: VoiceConnection;
+	player: Player | null;
+	active(alas: any): boolean | Promise<boolean>;
+	onRegister?(context: ExtensionContext): void | Promise<void>;
+	onDestroy?(context: ExtensionContext): void | Promise<void>;
+	beforePlay?(
+		context: ExtensionContext,
+		payload: ExtensionPlayRequest,
+	): Promise<ExtensionPlayResponse | void> | ExtensionPlayResponse | void;
+	afterPlay?(context: ExtensionContext, payload: ExtensionAfterPlayPayload): Promise<void> | void;
+	provideSearch?(
+		context: ExtensionContext,
+		payload: ExtensionSearchRequest,
+	): Promise<SearchResult | null | undefined> | SearchResult | null | undefined;
+	provideStream?(
+		context: ExtensionContext,
+		payload: ExtensionStreamRequest,
+	): Promise<StreamInfo | null | undefined> | StreamInfo | null | undefined;
+}
+
+/**
+ * Context for the extension
+ *
+ * @example
+ * const context: ExtensionContext = {
+ *   player: player,
+ *   manager: manager
+ * };
+ */
+export interface ExtensionContext {
+	player: Player;
+	manager: PlayerManager;
+}
+
+/**
+ * Request for the extension to play a track
+ *
+ * @example
+ * const request: ExtensionPlayRequest = {
+ *   query: "Song Name",
+ *   requestedBy: "user123"
+ * };
+ */
+export interface ExtensionPlayRequest {
+	query: string | Track;
+	requestedBy?: string;
+}
+
+/**
+ * Response for the extension to play a track
+ *
+ * @example
+ * const response: ExtensionPlayResponse = {
+ *   handled: true,
+ *   query: "Song Name",
+ *   requestedBy: "user123"
+ * };
+ */
+export interface ExtensionPlayResponse {
+	handled?: boolean;
+	query?: string | Track;
+	requestedBy?: string;
+	tracks?: Track[];
+	isPlaylist?: boolean;
+	success?: boolean;
+	error?: Error;
+}
+
+/**
+ * Payload for the extension to play a track
+ *
+ * @example
+ * const payload: ExtensionAfterPlayPayload = {
+ *   success: true,
+ *   query: "Song Name",
+ *   requestedBy: "user123"
+ * };
+ */
+export interface ExtensionAfterPlayPayload {
+	success: boolean;
+	query: string | Track;
+	requestedBy?: string;
+	tracks?: Track[];
+	isPlaylist?: boolean;
+	error?: Error;
+}
+
+/**
+ * Request for the extension to stream a track
+ *
+ * @example
+ * const request: ExtensionStreamRequest = {
+ *   track: track
+ * };
+ */
+export interface ExtensionStreamRequest {
+	track: Track;
+}
+
+/**
+ * Request for the extension to search for a track
+ *
+ * @example
+ * const request: ExtensionSearchRequest = {
+ *   query: "Song Name",
+ *   requestedBy: "user123"
+ * };
+ */
+export interface ExtensionSearchRequest {
+	query: string;
+	requestedBy: string;
+}