ziplayer 0.3.10 → 0.3.12

package/src/structures/FilterManager.ts

@@ -16,7 +16,7 @@ export class FilterManager {
 	private debug: DebugFn;
 	private player: Player;
 	private ffmpeg: FFmpeg | null = null;
-	private currentInputStream: Readable | null = null;
+	private currentInputStream: Readable | null | undefined | string = null;
 	public StreamType: FilterManagerStreamType = "arbitrary";
 	private ffmpegProcess: ChildProcess | null = null;
 	private ffmpegAbortController: AbortController | null = null;
@@ -236,7 +236,7 @@ export class FilterManager {
 		const generation = ++this.ffmpegGeneration;
 		const filterString = this.getFilterString();
 
-		let sourceStream = streamInfo.stream;
+		let sourceStream: Readable | string = streamInfo.stream || streamInfo.url!;
 		let wasRecreated = false;
 
 		if (position >= 0 && streamInfo.recreate) {
@@ -244,8 +244,7 @@ export class FilterManager {
 			wasRecreated = true;
 
 			position = -1;
-			streamInfo.type = "arbitrary";
-			if (!filterString) return { ...streamInfo, stream: sourceStream, wasRecreated };
+			if (!filterString) return { ...streamInfo, type: "arbitrary", stream: sourceStream, wasRecreated };
 		}
 
 		this.debug(`Applying filters and seek — filters: ${filterString || "none"}, seek: ${position}ms`);
@@ -264,7 +263,13 @@ export class FilterManager {
 			return { ...streamInfo, stream };
 		}
 
-		// Trường hợp chỉ apply filter mà không seek (position < 0)
+		if (typeof sourceStream === "string") {
+			return {
+				...streamInfo,
+				stream: await this.createFFmpegFromUrl(sourceStream, filterString),
+			};
+		}
+
 		const args = [
 			"-analyzeduration",
 			"0",
@@ -287,7 +292,6 @@ export class FilterManager {
 		}
 
 		try {
-			// Sử dụng prism.FFmpeg cho trường hợp không seek
 			this.ffmpeg = sourceStream.pipe(new prism.FFmpeg({ args }));
 			return { ...streamInfo, stream: this.ffmpeg };
 		} catch (spawnError) {
@@ -297,7 +301,7 @@ export class FilterManager {
 	}
 
 	private spawnFFmpegInputSeek(
-		stream: Readable,
+		stream: Readable | string,
 		position: number,
 		filterString: string,
 		signal: AbortSignal,
@@ -308,7 +312,11 @@ export class FilterManager {
 
 		// Chuyển sang dùng s16le (Raw PCM) để Discord.js dễ xử lý nhất khi có filter
 		// NOTE: -ss MUST come BEFORE -i for proper seeking and timing
-		const args: string[] = ["-ss", seekSeconds, "-i", "pipe:0", "-analyzeduration", "0", "-loglevel", "0"];
+		//if url is provided, we can let ffmpeg handle it directly without piping, which is more efficient and less error-prone
+		const args: string[] =
+			typeof stream === "string" ?
+				["-ss", seekSeconds, "-i", stream, "-analyzeduration", "0", "-loglevel", "0"]
+			:	["-ss", seekSeconds, "-i", "pipe:0", "-analyzeduration", "0", "-loglevel", "0"];
 
 		if (filterString) {
 			args.push("-af", filterString);
@@ -337,7 +345,11 @@ export class FilterManager {
 			signal.removeEventListener("abort", onAbort);
 
 			try {
-				stream.unpipe(proc.stdin!);
+				if (typeof stream === "string") {
+					// If stream is a URL, no need to unpipe
+				} else {
+					stream.unpipe(proc.stdin!);
+				}
 			} catch {}
 
 			try {
@@ -361,7 +373,11 @@ export class FilterManager {
 		}
 
 		// Pipe source → ffmpeg stdin
-		stream.pipe(proc.stdin!);
+		if (typeof stream === "string") {
+			// If stream is a URL, no need to pipe
+		} else {
+			stream.pipe(proc.stdin!);
+		}
 
 		// Suppress EPIPE on stdin when the process exits early
 		proc.stdin!.on("error", (err: Error) => {
@@ -409,4 +425,59 @@ export class FilterManager {
 
 		return proc.stdout as Readable;
 	}
+	private createFFmpegFromUrl(url: string, filterString: string): Readable {
+		const args = ["-analyzeduration", "0", "-loglevel", "0", "-i", url];
+
+		if (filterString) {
+			args.push("-af", filterString);
+		}
+
+		args.push("-acodec", "libopus", "-f", "opus", "-ar", "48000", "-ac", "2", "pipe:1");
+
+		const proc = spawn(ffmpegPath!, args, {
+			stdio: ["ignore", "pipe", "ignore"],
+		});
+
+		const oldProcess = this.ffmpegProcess;
+		this.ffmpegProcess = proc;
+
+		proc.on("close", (code) => {
+			this.debug(`FFmpeg URL process exited (code: ${code})`);
+
+			if (this.ffmpegProcess === proc) {
+				this.ffmpegProcess = null;
+			}
+		});
+
+		proc.on("error", (err) => {
+			this.debug(`FFmpeg URL process error: ${err.message}`);
+
+			if (this.ffmpegProcess === proc) {
+				this.ffmpegProcess = null;
+			}
+		});
+
+		// kill process cũ sau khi process mới đã sẵn sàng
+		if (oldProcess && oldProcess !== proc) {
+			try {
+				oldProcess.kill("SIGKILL");
+			} catch {}
+		}
+
+		const output = proc.stdout as Readable;
+
+		output.once("close", () => {
+			try {
+				proc.kill("SIGKILL");
+			} catch {}
+		});
+
+		output.once("end", () => {
+			try {
+				proc.kill("SIGKILL");
+			} catch {}
+		});
+
+		return output;
+	}
 }

package/src/structures/Player.ts

@@ -125,6 +125,7 @@ export class Player extends EventEmitter {
 		resource: null,
 		track: null,
 		streamId: null,
+		processedStreamId: null,
 		abortController: null,
 		isValid: false,
 		isLoading: false,
@@ -331,7 +332,11 @@ export class Player extends EventEmitter {
 		const stream = (this.currentResource as any)?.metadata?.stream ?? (this.currentResource as any)?.stream;
 
 		if (stream && typeof stream.destroy === "function") {
-			stream.destroy().catch((e: any) => this.debug("Stream destroy error:", e));
+			try {
+				stream.destroy();
+			} catch (e: any) {
+				this.debug("Stream destroy error:", e);
+			}
 		}
 
 		this.currentResource = null;
@@ -907,7 +912,7 @@ export class Player extends EventEmitter {
 		if (filterString || position > 0) {
 			const processedStream = await this.filter.applyFiltersAndSeek(streamInfo, seekArg);
 
-			const resource = createAudioResource(processedStream.stream, {
+			const resource = createAudioResource(processedStream.stream || processedStream.url!, {
 				metadata: track,
 				inputType:
 					processedStream.wasRecreated && !filterString ? StreamType.Arbitrary
@@ -916,10 +921,10 @@ export class Player extends EventEmitter {
 				inlineVolume: true,
 			});
 
-			return { resource, processedStream: processedStream.stream };
+			return { resource, processedStream: processedStream.stream! };
 		}
 
-		const resource = createAudioResource(streamInfo.stream, {
+		const resource = createAudioResource(streamInfo.stream || streamInfo.url!, {
 			metadata: track,
 			inputType:
 				streamInfo.type === "webm/opus" ? StreamType.WebmOpus
@@ -1128,17 +1133,20 @@ export class Player extends EventEmitter {
 				return await this.playRemote(track, streamInfo);
 			}
 
-			if (!streamInfo?.stream) {
+			if (!streamInfo?.stream && !streamInfo?.url) {
 				throw new Error(`No stream available`);
 			}
 
 			// Register the RAW source stream — this is what we can reuse on seek
-			const rawStreamId = this.streamManager.registerStream(streamInfo.stream, track, {
-				source: track.source || "stream",
-				isPreload: false,
-				isRemote: !!streamInfo?.remote,
-				priority: 10,
-			});
+			const rawStreamId =
+				streamInfo.stream ?
+					this.streamManager.registerStream(streamInfo.stream, track, {
+						source: track.source || "stream",
+						isPreload: false,
+						isRemote: !!streamInfo?.remote,
+						priority: 10,
+					})
+				:	null;
 
 			// createResource now returns both the AudioResource
 			// AND the processedStream (ffmpeg stdout) when filters/seek are involved.
@@ -1159,14 +1167,14 @@ export class Player extends EventEmitter {
 			if (this.currentSlot.streamId && this.currentSlot.streamId !== rawStreamId) {
 				this.streamManager.unregisterStream(this.currentSlot.streamId, true);
 			}
-			if ((this.currentSlot as any).processedStreamId && (this.currentSlot as any).processedStreamId !== playStreamId) {
-				this.streamManager.unregisterStream((this.currentSlot as any).processedStreamId, true);
+			if (this.currentSlot.processedStreamId && this.currentSlot.processedStreamId !== playStreamId) {
+				this.streamManager.unregisterStream(this.currentSlot.processedStreamId, true);
 			}
 
 			this.currentSlot.resource = resource;
 			this.currentSlot.track = track;
 			this.currentSlot.streamId = rawStreamId;
-			(this.currentSlot as any).processedStreamId = processedStream ? playStreamId : null;
+			this.currentSlot.processedStreamId = processedStream ? playStreamId : null;
 			this.currentSlot.isValid = true;
 			this.currentResource = resource;
 			this.seekOffset = 0;
@@ -1980,7 +1988,7 @@ export class Player extends EventEmitter {
 			}
 
 			// Return the stream directly - caller can pipe it to fs.createWriteStream()
-			return finalStream.stream;
+			return finalStream.stream!;
 		} catch (error) {
 			this.debug(`[Player] save error:`, error);
 			this.emit("playerError", error as Error, track);
@@ -2508,10 +2516,10 @@ export class Player extends EventEmitter {
 			}
 
 			// Clean up processedStream first (it's what AudioResource reads)
-			const processedStreamId = (this.currentSlot as any).processedStreamId;
+			const processedStreamId = this.currentSlot.processedStreamId;
 			if (processedStreamId && processedStreamId !== currentStreamId) {
 				this.streamManager.unregisterStream(processedStreamId, true);
-				(this.currentSlot as any).processedStreamId = null;
+				this.currentSlot.processedStreamId = null;
 			}
 
 			if (currentStreamId) {
@@ -2544,7 +2552,7 @@ export class Player extends EventEmitter {
 				streaminfo = await this.getStream(track);
 			}
 
-			if (!streaminfo?.stream) {
+			if (!streaminfo?.stream && !streaminfo?.url) {
 				this.debug(`[Player] No stream available for refresh`);
 				return false;
 			}
@@ -2554,11 +2562,14 @@ export class Player extends EventEmitter {
 			const { resource, processedStream } = await this.createResource(streaminfo, track, createPosition);
 
 			// Register raw source stream
-			const newStreamId = this.streamManager.registerStream(streaminfo.stream, track, {
-				source: track.source || "stream",
-				isPreload: false,
-				priority: 10,
-			});
+			const newStreamId =
+				streaminfo.stream ?
+					this.streamManager.registerStream(streaminfo.stream, track, {
+						source: track.source || "stream",
+						isPreload: false,
+						priority: 10,
+					})
+				:	null;
 
 			let newProcessedStreamId: string | null = null;
 			if (processedStream && processedStream !== streaminfo.stream) {
@@ -2572,7 +2583,7 @@ export class Player extends EventEmitter {
 			this.currentSlot.resource = resource;
 			this.currentSlot.track = track;
 			this.currentSlot.streamId = newStreamId;
-			(this.currentSlot as any).processedStreamId = newProcessedStreamId;
+			this.currentSlot.processedStreamId = newProcessedStreamId;
 			this.currentSlot.isValid = true;
 			this.currentResource = resource;
 

package/src/structures/PlayerManager.ts

@@ -15,9 +15,10 @@ import {
 } from "../types";
 import type { BaseExtension } from "../extensions";
 import { withTimeout } from "../utils/timeout";
-import { PluginManager } from "../plugins";
 
 const GLOBAL_MANAGER_KEY: symbol = Symbol.for("ziplayer.PlayerManager.instance");
+/** Guild id for the internal search-only player (never stored in {@link PlayerManager.players}). */
+const SEARCH_PLAYER_GUILD_ID = "__ziplayer_search__";
 
 export const getGlobalManager = (): PlayerManager | null => {
 	try {
@@ -105,7 +106,8 @@ export class PlayerManager extends EventEmitter {
 	}
 
 	private plugins: SourcePlugin[];
-	private pluginManager: PluginManager;
+	/** Reused player for {@link search}; not registered in {@link players}. */
+	private searchPlayer: Player | null = null;
 	private extensions: any[];
 	private B_debug: boolean = false;
 	private extractorTimeout: number = 10000;
@@ -126,9 +128,6 @@ export class PlayerManager extends EventEmitter {
 	constructor(options: PlayerManagerOptions = {}) {
 		super();
 		this.plugins = [];
-		this.pluginManager = new PluginManager(null as any, this, {
-			extractorTimeout: this.extractorTimeout,
-		});
 		this.searchCache = new Map();
 
 		// Initialize plugins
@@ -145,7 +144,6 @@ export class PlayerManager extends EventEmitter {
 
 				if (instance) {
 					this.plugins.push(instance);
-					this.pluginManager.register(instance);
 				}
 				this.debug(`Registered plugin: ${p.name || "unnamed"}`);
 			} catch (e) {
@@ -249,6 +247,25 @@ export class PlayerManager extends EventEmitter {
 		this.debug(`Auto-cleanup started with interval: ${this.cleanupTimeout}ms`);
 	}
 
+	/**
+	 * Lazy internal player used only for {@link search}.
+	 * Not added to {@link players} and does not forward manager events.
+	 */
+	private getSearchPlayer(): Player {
+		if (this.searchPlayer && !this.searchPlayer.destroyed) {
+			return this.searchPlayer;
+		}
+
+		const player = new Player(SEARCH_PLAYER_GUILD_ID, { extractorTimeout: this.extractorTimeout }, this);
+		for (const plugin of this.plugins) {
+			player.addPlugin(plugin);
+		}
+
+		this.searchPlayer = player;
+		this.debug(`Created internal search player (not stored in players map)`);
+		return player;
+	}
+
 	private startStatsCollection(): void {
 		if (this.statsInterval) {
 			clearInterval(this.statsInterval);
@@ -291,6 +308,10 @@ export class PlayerManager extends EventEmitter {
 	async create(guildOrId: string | { id: string }, options?: PlayerOptions): Promise<Player> {
 		const guildId = this.resolveGuildId(guildOrId);
 
+		if (guildId === SEARCH_PLAYER_GUILD_ID) {
+			throw new Error(`Guild id "${SEARCH_PLAYER_GUILD_ID}" is reserved for internal search.`);
+		}
+
 		if (this.players.has(guildId)) {
 			this.debug(`Player already exists for guildId: ${guildId}, returning existing`);
 			return this.players.get(guildId)!;
@@ -770,6 +791,11 @@ export class PlayerManager extends EventEmitter {
 			player.destroy();
 		}
 
+		if (this.searchPlayer && !this.searchPlayer.destroyed) {
+			this.searchPlayer.destroy();
+		}
+		this.searchPlayer = null;
+
 		this.players.clear();
 		this.searchCache.clear();
 		this.removeAllListeners();
@@ -777,13 +803,11 @@ export class PlayerManager extends EventEmitter {
 	}
 
 	/**
-	 * Search using PluginManager without creating a Player.
+	 * Search via an internal Player instance (all registered plugins) without
+	 * storing it in {@link players}.
 	 *
-	 * Uses the same search pipeline as Player.search():
-	 * - cache
-	 * - plugin deduplication
-	 * - plugin scoring/evaluation
-	 * - fallback handling
+	 * Uses the same search pipeline as {@link Player.search}:
+	 * extension hooks, plugin deduplication, scoring, and fallback handling.
 	 *
 	 * @param {string} query
 	 * @param {string} requestedBy
@@ -792,20 +816,15 @@ export class PlayerManager extends EventEmitter {
 	async search(query: string, requestedBy: string): Promise<SearchResult> {
 		this.debug(`Search called with query: ${query}, requestedBy: ${requestedBy}`);
 
-		// Cache
 		const cached = this.getCachedSearch(query);
 		if (cached) {
 			return cached;
 		}
 
 		try {
-			const result = await this.pluginManager.search(query, requestedBy);
+			const result = await this.getSearchPlayer().search(query, requestedBy);
 
-			if (!result || !Array.isArray(result.tracks) || result.tracks.length === 0) {
-				throw new Error(`No results found for: ${query}`);
-			}
-
-			this.debug(`Plugin search returned ${result.tracks.length} tracks (score: ${result.score?.score ?? "unknown"}%)`);
+			this.debug(`Search returned ${result.tracks.length} tracks (score: ${result.score?.score ?? "unknown"}%)`);
 
 			if (result.score) {
 				this.debug(`Search evaluation - ${result.score.reason}`);
@@ -836,10 +855,13 @@ export class PlayerManager extends EventEmitter {
 	 */
 	registerPlugin(plugin: SourcePlugin): void {
 		this.plugins.push(plugin);
-		this.pluginManager.register(plugin);
 
 		this.debug(`Registered plugin: ${plugin.name}`);
 
+		if (this.searchPlayer && !this.searchPlayer.destroyed) {
+			this.searchPlayer.addPlugin(plugin);
+		}
+
 		for (const player of this.players.values()) {
 			player.addPlugin(plugin);
 		}
@@ -856,7 +878,10 @@ export class PlayerManager extends EventEmitter {
 		if (index === -1) return false;
 
 		this.plugins.splice(index, 1);
-		this.pluginManager.unregister(name);
+
+		if (this.searchPlayer && !this.searchPlayer.destroyed) {
+			this.searchPlayer.removePlugin(name);
+		}
 
 		this.debug(`Unregistered plugin: ${name}`);
 

package/src/structures/PreloadManager.ts

@@ -24,6 +24,7 @@ export class PreloadManager {
 		resource: null,
 		track: null,
 		streamId: null,
+		processedStreamId: null,
 		abortController: null,
 		isValid: false,
 		isLoading: false,
@@ -239,17 +240,20 @@ export class PreloadManager {
 			this.debugLog(`[Preload] Track changed after stream fetch`);
 			throw new Error("PRELOAD_CANCELLED");
 		}
-		if (!streamInfo?.stream) {
+		if (!streamInfo?.stream && !streamInfo?.url) {
 			throw new Error(`No stream available`);
 		}
 
-		const streamId = this.streamManager.registerStream(streamInfo.stream, track, {
-			source: track.source || "preload",
-			isPreload: true,
-			priority: 5,
-		});
+		const streamId =
+			streamInfo.stream ?
+				this.streamManager.registerStream(streamInfo.stream, track, {
+					source: track.source || "preload",
+					isPreload: true,
+					priority: 5,
+				})
+			:	null;
 
-		const resource = createAudioResource(streamInfo.stream, {
+		const resource = createAudioResource(streamInfo.stream || streamInfo.url!, {
 			inlineVolume: true,
 			metadata: { ...track, preloaded: true },
 		});

package/src/types/index.ts

@@ -124,8 +124,9 @@ export interface SearchScore {
  * };
  */
 export interface StreamInfo {
-	stream: Readable;
-	type: "webm/opus" | "ogg/opus" | "arbitrary" | string;
+	stream?: Readable;
+	url?: string;
+	type: "webm/opus" | "ogg/opus" | "arbitrary" | "url" | string;
 	metadata?: Record<string, any>;
 	position?: number;
 	recreate?: (position: number) => Promise<Readable>;
@@ -419,6 +420,7 @@ export interface SaveOptions {
 	/** Seek position in milliseconds to start saving from */
 	seek?: number;
 }
+
 export interface PlayerSession {
 	guildId: string;
 	queue: Track[];
@@ -470,6 +472,7 @@ export interface StreamSlot {
 	resource: AudioResource | null;
 	track: Track | null;
 	streamId: string | null;
+	processedStreamId: string | null;
 	abortController: AbortController | null;
 	isValid: boolean;
 	isLoading: boolean;