@ziplayer/ytexecplug 0.0.1

package/README.md

@@ -0,0 +1,216 @@
+<img width="1175" height="305" alt="logo" src="https://raw.githubusercontent.com/ZiProject/ZiPlayer/refs/heads/main/publish/logo.png" />
+
+# @ziplayer/plugin
+
+Official plugin bundle for ZiPlayer. It ships a set of ready‑to‑use source plugins you can register on your `PlayerManager`:
+
+- YouTubePlugin: search + stream YouTube videos and playlists
+- SoundCloudPlugin: search + stream SoundCloud tracks and sets
+- SpotifyPlugin: resolve tracks/albums/playlists, stream via fallbacks
+- TTSPlugin: Text‑to‑Speech playback from simple `tts:` queries
+- AttachmentsPlugin: handle Discord attachment URLs and direct audio file URLs
+
+ZiPlayer is an audio player built on top of `@discordjs/voice` and `discord.js`. This package provides sources; the core player
+lives in `ziplayer`.
+
+## Installation
+
+```bash
+npm install @ziplayer/plugin ziplayer @discordjs/voice discord.js
+```
+
+The TTS plugin uses a lightweight Google TTS wrapper and HTTP fetches:
+
+```bash
+npm install @zibot/zitts axios
+```
+
+## Quick Start
+
+```ts
+import { PlayerManager } from "ziplayer";
+import { YouTubePlugin, SoundCloudPlugin, SpotifyPlugin, TTSPlugin, AttachmentsPlugin } from "@ziplayer/plugin";
+import { YTexec } from "@ziplayer/ytexecplug";
+
+const ytbplg = new YouTubePlugin({ player: null });
+
+ytbplg.getStream = new YTexec().getStream;
+
+//create Player Manager
+const manager = new PlayerManager({
+	plugins: [new TTSPlugin(), ytbplg, new SoundCloudPlugin(), new SpotifyPlugin(), new AttachmentsPlugin()],
+	extensions: [new lyricsExt(), new voiceExt(null, { client, minimalVoiceMessageDuration: 1 })],
+});
+
+// Create and connect a player (discord.js VoiceChannel instance)
+const player = await manager.create(guildId, { userdata: { channel: textChannel } });
+await player.connect(voiceChannel);
+
+// Search & play
+await player.play("never gonna give you up", requestedBy);
+
+// Play a playlist URL directly
+await player.play("https://www.youtube.com/playlist?list=...", requestedBy);
+
+// Speak with TTS
+await player.play("tts:en:Hello there!", requestedBy);
+
+// Play Discord attachment
+await player.play("https://cdn.discordapp.com/attachments/123/456/audio.mp3", requestedBy);
+
+// Handle events via the manager
+manager.on("trackStart", (plr, track) => {
+	plr.userdata?.channel?.send?.(`Now playing: ${track.title}`);
+});
+```
+
+## Included Plugins
+
+### YouTubePlugin
+
+- Resolves YouTube videos and playlists.
+- Uses `youtubei.js` under the hood.
+
+```ts
+import { YouTubePlugin } from "@ziplayer/plugin";
+const youtube = new YouTubePlugin();
+```
+
+### SoundCloudPlugin
+
+- Resolves tracks and sets. You may further tune streaming by combining with other plugins that provide fallbacks.
+
+```ts
+import { SoundCloudPlugin } from "@ziplayer/plugin";
+const sc = new SoundCloudPlugin();
+```
+
+### SpotifyPlugin
+
+- Resolves track/album/playlist metadata from Spotify.
+- Streaming typically uses fallback sources (e.g., YouTube) discovered by your plugin set.
+
+```ts
+import { SpotifyPlugin } from "@ziplayer/plugin";
+const sp = new SpotifyPlugin();
+```
+
+### TTSPlugin (Text‑to‑Speech)
+
+- Plays spoken audio from text using a lightweight Google TTS wrapper.
+- **Accurate duration analysis**: Generates sample audio to measure actual duration instead of estimating.
+- Supported query formats:
+  - `tts: <text>`
+  - `tts:<lang>:<text>` (e.g., `tts:vi:xin chao`)
+  - `tts:<lang>:1:<text>` (set `slow = true`, `0` = normal)
+
+```ts
+import { TTSPlugin } from "@ziplayer/plugin";
+const tts = new TTSPlugin({ defaultLang: "en", slow: false });
+
+// The plugin automatically analyzes TTS duration
+const result = await tts.search("tts:en:Hello world", "user123");
+console.log(`Duration: ${result.tracks[0].duration}s`); // Real duration from audio analysis
+console.log(`Language: ${result.tracks[0].metadata.language}`); // "en"
+console.log(`Slow mode: ${result.tracks[0].metadata.slowMode}`); // false
+
+await player.play("tts:en:1:good morning", requestedBy);
+```
+
+Note: Please comply with the service’s terms and provide your own quotas. The wrapper is intended for lightweight usage and may
+change without notice.
+
+Advanced: custom TTS provider
+
+You can override audio generation by passing a `createStream` function. It receives the text and context and can return a Node
+`Readable`, an HTTP(S) URL string, or a `Buffer`.
+
+```ts
+const tts = new TTSPlugin({
+	defaultLang: "vi",
+	async createStream(text, ctx) {
+		// Example: integrate with Azure, CAMB.AI, etc.
+		// Return a URL and the plugin will stream it
+		const url = await myTTSService(text, { lang: ctx?.lang, slow: ctx?.slow });
+		return url; // or Readable / Buffer
+	},
+});
+```
+
+### AttachmentsPlugin
+
+- Handles Discord attachment URLs and direct audio file URLs.
+- Supports various audio formats (mp3, wav, ogg, m4a, flac, etc.).
+- **Audio metadata analysis**: Extracts duration, title, artist, album, bitrate, etc.
+- Includes file size validation and proper error handling.
+- Uses Range requests to efficiently analyze metadata without downloading entire files.
+
+```ts
+import { AttachmentsPlugin } from "@ziplayer/plugin";
+const attachments = new AttachmentsPlugin({
+	maxFileSize: 25 * 1024 * 1024, // 25MB
+	allowedExtensions: ["mp3", "wav", "ogg", "m4a", "flac"],
+	debug: true, // Enable to see metadata analysis process
+});
+
+// The plugin automatically analyzes audio metadata
+const result = await attachments.search("https://cdn.discordapp.com/attachments/123/456/song.mp3", "user123");
+console.log(`Duration: ${result.tracks[0].duration}s`); // Real duration from metadata
+console.log(`Title: ${result.tracks[0].title}`); // May be extracted from metadata
+console.log(`Artist: ${result.tracks[0].metadata.artist}`); // From metadata
+```
+
+## Writing Your Own Plugin
+
+Plugins implement the `BasePlugin` contract from `ziplayer`:
+
+```ts
+import { BasePlugin, Track, SearchResult, StreamInfo } from "ziplayer";
+
+export class MyPlugin extends BasePlugin {
+	name = "myplugin";
+	version = "1.0.0";
+
+	canHandle(query: string): boolean {
+		// Return true if this plugin can handle a given query/URL
+		return query.includes("mysite.com");
+	}
+
+	async search(query: string, requestedBy: string): Promise<SearchResult> {
+		// Return one or more tracks for the query
+		return {
+			tracks: [
+				{
+					id: "abc",
+					title: "My Track",
+					url: "https://mysite.com/track/abc",
+					duration: 180,
+					requestedBy,
+					source: this.name,
+				},
+			],
+		};
+	}
+
+	async getStream(track: Track): Promise<StreamInfo> {
+		// Return a Node Readable stream and an input type
+		return { stream, type: "arbitrary" };
+	}
+}
+```
+
+Tips
+
+- Keep network calls bounded; ZiPlayer applies timeouts to extractor operations.
+- For sources that require indirection (like Spotify), consider a `getFallback` strategy via other plugins.
+- Use `track.metadata` for any source‑specific fields you want to carry along.
+
+## Requirements
+
+- Node.js 18+
+- `discord.js` 14 and `@discordjs/voice` 0.19+
+- For TTS: `@zibot/zitts` and `axios`
+
+## License
+
+MIT

package/dist/YouTubePlugin.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=YouTubePlugin.d.ts.map

package/dist/YouTubePlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YouTubePlugin.d.ts","sourceRoot":"","sources":["../src/YouTubePlugin.ts"],"names":[],"mappings":""}

package/dist/YouTubePlugin.js

@@ -0,0 +1,343 @@
+"use strict";
+// import { BasePlugin, Track, SearchResult, StreamInfo, Player } from "ziplayer";
+// export interface PluginOptions {
+// 	player: Player;
+// 	debug?: boolean;
+// }
+// /**
+//  * A plugin for handling YouTube audio content including videos, playlists, and search functionality.
+//  *
+//  * This plugin provides comprehensive support for:
+//  * - YouTube video URLs (youtube.com, youtu.be, music.youtube.com)
+//  * - YouTube playlist URLs and dynamic mixes
+//  * - YouTube search queries
+//  * - Audio stream extraction from YouTube videos
+//  * - Related track recommendations
+//  *
+//  * @example
+//  * const youtubePlugin = new YouTubePlugin();
+//  *
+//  * // Add to PlayerManager
+//  * const manager = new PlayerManager({
+//  *   plugins: [youtubePlugin]
+//  * });
+//  *
+//  * // Search for videos
+//  * const result = await youtubePlugin.search("Never Gonna Give You Up", "user123");
+//  *
+//  * // Get audio stream
+//  * const stream = await youtubePlugin.getStream(result.tracks[0]);
+//  *
+//  * @since 1.0.0
+//  */
+// export class YouTubePlugin extends BasePlugin {
+// 	name = "youtube";
+// 	version = "1.0.0";
+// 	private ready: Promise<void>;
+// 	private player: Player | undefined;
+// 	private options: PluginOptions;
+// 	/**
+// 	 * Creates a new YouTubePlugin instance.
+// 	 *
+// 	 * The plugin will automatically initialize YouTube clients for both video playback
+// 	 * and search functionality. Initialization is asynchronous and handled internally.
+// 	 *
+// 	 * @example
+// 	 * const plugin = new YouTubePlugin();
+// 	 * // Plugin is ready to use after initialization completes
+// 	 */
+// 	constructor(options: PluginOptions) {
+// 		super();
+// 		this.player = options?.player ?? undefined;
+// 		this.options = options ?? {};
+// 		this.ready = this.init();
+// 	}
+// 	private async init(): Promise<void> {}
+// 	private debug(message?: any, ...optionalParams: any[]): void {
+// 		if (this.options?.debug && this?.player && this.player?.listenerCount("debug") > 0) {
+// 			this.player.emit("debug", `[YouTubePlugin] ${message}`, ...optionalParams);
+// 		}
+// 	}
+// 	// Build a Track from various YouTube object shapes (search item, playlist item, watch_next feed, basic_info, info)
+// 	private buildTrack(raw: any, requestedBy: string, extra?: { playlist?: string }): Track {
+// 		const pickFirst = (...vals: any[]) => vals.find((v) => v !== undefined && v !== null && v !== "");
+// 		// Try to resolve from multiple common shapes
+// 		const id = pickFirst(
+// 			raw?.id,
+// 			raw?.video_id,
+// 			raw?.videoId,
+// 			raw?.content_id,
+// 			raw?.identifier,
+// 			raw?.basic_info?.id,
+// 			raw?.basic_info?.video_id,
+// 			raw?.basic_info?.videoId,
+// 			raw?.basic_info?.content_id,
+// 		);
+// 		const title = pickFirst(
+// 			raw?.metadata?.title?.text,
+// 			raw?.title?.text,
+// 			raw?.title,
+// 			raw?.headline,
+// 			raw?.basic_info?.title,
+// 			"Unknown title",
+// 		);
+// 		const durationValue = pickFirst(
+// 			raw?.length_seconds,
+// 			raw?.duration?.seconds,
+// 			raw?.duration?.text,
+// 			raw?.duration,
+// 			raw?.length_text,
+// 			raw?.basic_info?.duration,
+// 		);
+// 		const duration = Number(toSeconds(durationValue)) || 0;
+// 		const thumb = pickFirst(
+// 			raw?.thumbnails?.[0]?.url,
+// 			raw?.thumbnail?.[0]?.url,
+// 			raw?.thumbnail?.url,
+// 			raw?.thumbnail?.thumbnails?.[0]?.url,
+// 			raw?.content_image?.image?.[0]?.url,
+// 			raw?.basic_info?.thumbnail?.[0]?.url,
+// 			raw?.basic_info?.thumbnail?.[raw?.basic_info?.thumbnail?.length - 1]?.url,
+// 			raw?.thumbnails?.[raw?.thumbnails?.length - 1]?.url,
+// 		);
+// 		const author = pickFirst(raw?.author?.name, raw?.author, raw?.channel?.name, raw?.owner?.name, raw?.basic_info?.author);
+// 		const views = pickFirst(
+// 			raw?.view_count,
+// 			raw?.views,
+// 			raw?.short_view_count,
+// 			raw?.stats?.view_count,
+// 			raw?.basic_info?.view_count,
+// 		);
+// 		const url = pickFirst(raw?.url, id ? `https://www.youtube.com/watch?v=${id}` : undefined);
+// 		this.debug("Track build:", {
+// 			id: String(id),
+// 			title: String(title),
+// 			url: String(url),
+// 			duration,
+// 			thumbnail: thumb,
+// 			requestedBy,
+// 			source: this.name,
+// 		});
+// 		return {
+// 			id: String(id),
+// 			title: String(title),
+// 			url: String(url),
+// 			duration,
+// 			thumbnail: thumb,
+// 			requestedBy,
+// 			source: this.name,
+// 			metadata: {
+// 				author,
+// 				views,
+// 				...(extra?.playlist ? { playlist: extra.playlist } : {}),
+// 			},
+// 		} as Track;
+// 	}
+// 	/**
+// 	 * Determines if this plugin can handle the given query.
+// 	 *
+// 	 * @param query - The search query or URL to check
+// 	 * @returns `true` if the plugin can handle the query, `false` otherwise
+// 	 *
+// 	 * @example
+// 	 * plugin.canHandle("https://www.youtube.com/watch?v=dQw4w9WgXcQ"); // true
+// 	 * plugin.canHandle("Never Gonna Give You Up"); // true
+// 	 * plugin.canHandle("spotify:track:123"); // false
+// 	 */
+// 	canHandle(query: string): boolean {
+// 		const q = (query || "").trim().toLowerCase();
+// 		const isUrl = q.startsWith("http://") || q.startsWith("https://");
+// 		if (isUrl) {
+// 			try {
+// 				const parsed = new URL(query);
+// 				const allowedHosts = ["youtube.com", "www.youtube.com", "music.youtube.com", "youtu.be", "www.youtu.be"];
+// 				return allowedHosts.includes(parsed.hostname.toLowerCase());
+// 			} catch (e) {
+// 				return false;
+// 			}
+// 		}
+// 		// Avoid intercepting explicit patterns for other extractors
+// 		if (q.startsWith("tts:") || q.startsWith("say ")) return false;
+// 		if (q.startsWith("spotify:") || q.includes("open.spotify.com")) return false;
+// 		if (q.includes("soundcloud")) return false;
+// 		// Treat remaining non-URL free text as YouTube-searchable
+// 		return true;
+// 	}
+// 	/**
+// 	 * Validates if a URL is a valid YouTube URL.
+// 	 *
+// 	 * @param url - The URL to validate
+// 	 * @returns `true` if the URL is a valid YouTube URL, `false` otherwise
+// 	 *
+// 	 * @example
+// 	 * plugin.validate("https://www.youtube.com/watch?v=dQw4w9WgXcQ"); // true
+// 	 * plugin.validate("https://youtu.be/dQw4w9WgXcQ"); // true
+// 	 * plugin.validate("https://spotify.com/track/123"); // false
+// 	 */
+// 	validate(url: string): boolean {
+// 		try {
+// 			const parsed = new URL(url);
+// 			const allowedHosts = ["youtube.com", "www.youtube.com", "music.youtube.com", "youtu.be", "www.youtu.be", "m.youtube.com"];
+// 			return allowedHosts.includes(parsed.hostname.toLowerCase());
+// 		} catch (e) {
+// 			return false;
+// 		}
+// 	}
+// 	/**
+// 	 * Retrieves the audio stream for a YouTube track using sabr download.
+// 	 *
+// 	 * This method extracts the audio stream from a YouTube video using the sabr download
+// 	 * method which provides better quality and more reliable streaming.
+// 	 *
+// 	 * @param track - The Track object to get the stream for
+// 	 * @returns A StreamInfo object containing the audio stream and metadata
+// 	 * @throws {Error} If the track ID is invalid or stream extraction fails
+// 	 *
+// 	 * @example
+// 	 * const track = { id: "dQw4w9WgXcQ", title: "Never Gonna Give You Up", ... };
+// 	 * const streamInfo = await plugin.getStream(track);
+// 	 * console.log(streamInfo.type); // "arbitrary"
+// 	 * console.log(streamInfo.stream); // Readable stream
+// 	 */
+// 	async getStream(track: Track): Promise<StreamInfo> {
+// 		await this.ready;
+// 		const id = this.extractVideoId(track.url) || track.id;
+// 		if (!id) throw new Error("Invalid track id");
+// 		try {
+// 			this.debug("🚀 Attempting sabr download for video ID:", id);
+// 			// Use sabr download for better quality and reliability
+// 			const { streamResults } = await createSabrStream(id, DEFAULT_SABR_OPTIONS);
+// 			const { audioStream, selectedFormats, videoTitle } = streamResults;
+// 			this.debug("✅ Sabr download successful, converting Web Stream to Node.js Stream");
+// 			// Convert Web Stream to Node.js Readable Stream
+// 			const nodeStream = webStreamToNodeStream(audioStream);
+// 			this.debug("✅ Stream conversion complete, returning Node.js stream");
+// 			// Return the converted Node.js stream
+// 			return {
+// 				stream: nodeStream,
+// 				type: "arbitrary",
+// 				metadata: {
+// 					...track.metadata,
+// 					itag: selectedFormats.audioFormat.itag,
+// 					mime: selectedFormats.audioFormat.mimeType,
+// 				},
+// 			};
+// 		} catch (e: any) {
+// 			this.debug("⚠️ Sabr download failed, falling back to youtubei.js:", e.message);
+// 			// Fallback to original youtubei.js method if sabr download fails
+// 			try {
+// 				const stream: any = await (this.client as any).download(id, {
+// 					type: "audio",
+// 					quality: "best",
+// 				});
+// 				// Check if it's a Web Stream and convert it
+// 				this.debug("🔍 Checking stream type:", typeof stream, stream?.constructor?.name);
+// 				if (stream && typeof stream.getReader === "function") {
+// 					this.debug("🔄 Converting Web Stream to Node.js Stream");
+// 					const nodeStream = webStreamToNodeStream(stream);
+// 					this.debug("✅ Stream converted successfully");
+// 					return {
+// 						stream: nodeStream,
+// 						type: "arbitrary",
+// 						metadata: track.metadata,
+// 					};
+// 				} else {
+// 					this.debug("⚠️ Stream is not a Web Stream or is null");
+// 				}
+// 				return {
+// 					stream,
+// 					type: "arbitrary",
+// 					metadata: track.metadata,
+// 				};
+// 			} catch (fallbackError: any) {
+// 				try {
+// 					const info: any = await (this.client as any).getBasicInfo(id);
+// 					// Prefer m4a audio-only formats first
+// 					let format: any = info?.chooseFormat?.({
+// 						type: "audio",
+// 						quality: "best",
+// 					});
+// 					if (!format && info?.formats?.length) {
+// 						const audioOnly = info.formats.filter((f: any) => f.mime_type?.includes("audio"));
+// 						audioOnly.sort((a: any, b: any) => (b.bitrate || 0) - (a.bitrate || 0));
+// 						format = audioOnly[0];
+// 					}
+// 					if (!format) throw new Error("No audio format available");
+// 					let url: string | undefined = undefined;
+// 					if (typeof format.decipher === "function") {
+// 						url = format.decipher((this.client as any).session.player);
+// 					}
+// 					if (!url) url = format.url;
+// 					if (!url) throw new Error("No valid URL to decipher");
+// 					const res = await fetch(url);
+// 					if (!res.ok || !res.body) {
+// 						throw new Error(`HTTP ${res.status}`);
+// 					}
+// 					// Convert Web Stream to Node.js Stream
+// 					this.debug("🔄 Converting fetch response Web Stream to Node.js Stream");
+// 					const nodeStream = webStreamToNodeStream(res.body);
+// 					return {
+// 						stream: nodeStream,
+// 						type: "arbitrary",
+// 						metadata: {
+// 							...track.metadata,
+// 							itag: format.itag,
+// 							mime: format.mime_type,
+// 						},
+// 					};
+// 				} catch (inner: any) {
+// 					throw new Error(`Failed to get YouTube stream: ${inner?.message || inner}`);
+// 				}
+// 			}
+// 		}
+// 	}
+// 	async getFallback(track: Track): Promise<StreamInfo> {
+// 		try {
+// 			const result = await this.search(track.title, track.requestedBy);
+// 			const first = result.tracks[0];
+// 			this.debug("Fallback track:", first);
+// 			if (!first) throw new Error("No fallback track found");
+// 			return await this.getStream(first);
+// 		} catch (e: any) {
+// 			throw new Error(`YouTube fallback search failed: ${e?.message || e}`);
+// 		}
+// 	}
+// 	private extractVideoId(input: string): string | null {
+// 		try {
+// 			const u = new URL(input);
+// 			const allowedShortHosts = ["youtu.be"];
+// 			const allowedLongHosts = ["youtube.com", "www.youtube.com", "music.youtube.com", "m.youtube.com"];
+// 			if (allowedShortHosts.includes(u.hostname)) {
+// 				return u.pathname.split("/").filter(Boolean)[0] || null;
+// 			}
+// 			if (allowedLongHosts.includes(u.hostname)) {
+// 				// watch?v=, shorts/, embed/
+// 				if (u.searchParams.get("v")) return u.searchParams.get("v");
+// 				const path = u.pathname;
+// 				if (path.startsWith("/shorts/")) return path.replace("/shorts/", "");
+// 				if (path.startsWith("/embed/")) return path.replace("/embed/", "");
+// 			}
+// 			return null;
+// 		} catch {
+// 			return null;
+// 		}
+// 	}
+// }
+// function toSeconds(d: any): number | undefined {
+// 	if (typeof d === "number") return d;
+// 	if (typeof d === "string") {
+// 		// mm:ss or hh:mm:ss
+// 		const parts = d.split(":").map(Number);
+// 		if (parts.some((n) => Number.isNaN(n))) return undefined;
+// 		if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
+// 		if (parts.length === 2) return parts[0] * 60 + parts[1];
+// 		const asNum = Number(d);
+// 		return Number.isFinite(asNum) ? asNum : undefined;
+// 	}
+// 	if (d && typeof d === "object") {
+// 		if (typeof (d as any).seconds === "number") return (d as any).seconds;
+// 		if (typeof (d as any).milliseconds === "number") return Math.floor((d as any).milliseconds / 1000);
+// 	}
+// 	return undefined;
+// }
+//# sourceMappingURL=YouTubePlugin.js.map

package/dist/YouTubePlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"YouTubePlugin.js","sourceRoot":"","sources":["../src/YouTubePlugin.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { BasePlugin } from "ziplayer";
+import { Track, SearchResult, StreamInfo } from "ziplayer";
+import { Readable } from "stream";
+/**
+ * Converts a Web ReadableStream to a Node.js Readable stream
+ */
+export declare function webStreamToNodeStream(webStream: ReadableStream): Readable;
+export declare class YTexec extends BasePlugin {
+    name: string;
+    version: string;
+    canHandle(query: string): boolean;
+    search(query: string, requestedBy: string): Promise<SearchResult>;
+    getStream(track: Track): Promise<StreamInfo>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAGlC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,cAAc,GAAG,QAAQ,CA8BzE;AAoBD,qBAAa,MAAO,SAAQ,UAAU;IACrC,IAAI,SAAY;IAChB,OAAO,SAAW;IAElB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAe3B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAIjE,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC;CAqBlD"}

package/dist/index.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YTexec = void 0;
+exports.webStreamToNodeStream = webStreamToNodeStream;
+const ziplayer_1 = require("ziplayer");
+const stream_1 = require("stream");
+const youtube_dl_exec_1 = __importDefault(require("youtube-dl-exec"));
+/**
+ * Converts a Web ReadableStream to a Node.js Readable stream
+ */
+function webStreamToNodeStream(webStream) {
+    const nodeStream = new stream_1.Readable({
+        read() {
+            // This will be handled by the Web Stream reader
+        },
+    });
+    // Create a reader from the Web Stream
+    const reader = webStream.getReader();
+    // Read chunks and push to Node.js stream
+    const pump = async () => {
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    nodeStream.push(null); // End the stream
+                    break;
+                }
+                nodeStream.push(Buffer.from(value));
+            }
+        }
+        catch (error) {
+            nodeStream.destroy(error);
+        }
+    };
+    // Start pumping data
+    pump();
+    return nodeStream;
+}
+async function getYoutubeStream(url) {
+    const info = await (0, youtube_dl_exec_1.default)(url, {
+        dumpSingleJson: true,
+        noCheckCertificates: true,
+        noWarnings: true,
+        preferFreeFormats: true,
+        format: "bestaudio/best",
+        addHeader: ["referer:youtube.com", "user-agent:googlebot"],
+    });
+    const videourl = typeof info === "object" ? info?.url : info;
+    if (!videourl) {
+        return null;
+    }
+    return videourl;
+}
+class YTexec extends ziplayer_1.BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = "YTexec";
+        this.version = "1.0.0";
+    }
+    canHandle(query) {
+        const q = (query || "").trim().toLowerCase();
+        const isUrl = q.startsWith("http://") || q.startsWith("https://");
+        if (isUrl) {
+            try {
+                const parsed = new URL(query);
+                const allowedHosts = ["youtube.com", "www.youtube.com", "music.youtube.com", "youtu.be", "www.youtu.be"];
+                return allowedHosts.includes(parsed.hostname.toLowerCase());
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        return false;
+    }
+    async search(query, requestedBy) {
+        return { tracks: [] };
+    }
+    async getStream(track) {
+        try {
+            const youtubeUrl = await getYoutubeStream(track.url);
+            if (!youtubeUrl) {
+                throw new Error("Failed to get YouTube stream URL");
+            }
+            const response = await fetch(youtubeUrl);
+            if (!response.ok || !response.body) {
+                throw new Error("Failed to fetch YouTube stream");
+            }
+            const stream = webStreamToNodeStream(response.body);
+            return {
+                stream,
+                type: "arbitrary",
+                metadata: track.metadata,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get YouTube stream: ${error}`);
+        }
+    }
+}
+exports.YTexec = YTexec;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@ziplayer/ytexecplug",
+	"version": "0.0.1",
+	"description": "A modular Discord voice player with plugin system",
+	"keywords": [
+		"ZiPlayer",
+		"@ziplayer/plugin",
+		"discord",
+		"music",
+		"player",
+		"voice"
+	],
+	"homepage": "https://player.ziji.world",
+	"bugs": {
+		"url": "https://github.com/ZiProject/ZiPlayer/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/ZiProject/ZiPlayer.git"
+	},
+	"license": "MIT",
+	"author": "Ziji",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"prepare": "npm run build"
+	},
+	"dependencies": {
+		"youtube-dl-exec": "^3.0.30",
+		"ziplayer": "^0.2.1"
+	},
+	"devDependencies": {
+		"@types/node": "^20.0.0",
+		"typescript": "^5.0.0"
+	}
+}

package/src/index.ts

@@ -0,0 +1,103 @@
+import { BasePlugin } from "ziplayer";
+import { Track, SearchResult, StreamInfo } from "ziplayer";
+import { Readable } from "stream";
+import youtubedl from "youtube-dl-exec";
+
+/**
+ * Converts a Web ReadableStream to a Node.js Readable stream
+ */
+export function webStreamToNodeStream(webStream: ReadableStream): Readable {
+	const nodeStream = new Readable({
+		read() {
+			// This will be handled by the Web Stream reader
+		},
+	});
+
+	// Create a reader from the Web Stream
+	const reader = webStream.getReader();
+
+	// Read chunks and push to Node.js stream
+	const pump = async () => {
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					nodeStream.push(null); // End the stream
+					break;
+				}
+				nodeStream.push(Buffer.from(value));
+			}
+		} catch (error) {
+			nodeStream.destroy(error as Error);
+		}
+	};
+
+	// Start pumping data
+	pump();
+
+	return nodeStream;
+}
+
+async function getYoutubeStream(url: string): Promise<string | null> {
+	const info = await youtubedl(url, {
+		dumpSingleJson: true,
+		noCheckCertificates: true,
+		noWarnings: true,
+		preferFreeFormats: true,
+		format: "bestaudio/best",
+		addHeader: ["referer:youtube.com", "user-agent:googlebot"],
+	});
+
+	const videourl = typeof info === "object" ? (info as any)?.url : info;
+	if (!videourl) {
+		return null;
+	}
+
+	return videourl;
+}
+
+export class YTexec extends BasePlugin {
+	name = "YTexec";
+	version = "1.0.0";
+
+	canHandle(query: string): boolean {
+		const q = (query || "").trim().toLowerCase();
+		const isUrl = q.startsWith("http://") || q.startsWith("https://");
+		if (isUrl) {
+			try {
+				const parsed = new URL(query);
+				const allowedHosts = ["youtube.com", "www.youtube.com", "music.youtube.com", "youtu.be", "www.youtu.be"];
+				return allowedHosts.includes(parsed.hostname.toLowerCase());
+			} catch (e) {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	async search(query: string, requestedBy: string): Promise<SearchResult> {
+		return { tracks: [] };
+	}
+
+	async getStream(track: Track): Promise<StreamInfo> {
+		try {
+			const youtubeUrl = await getYoutubeStream(track.url);
+			if (!youtubeUrl) {
+				throw new Error("Failed to get YouTube stream URL");
+			}
+			const response = await fetch(youtubeUrl);
+			if (!response.ok || !response.body) {
+				throw new Error("Failed to fetch YouTube stream");
+			}
+			const stream = webStreamToNodeStream(response.body as ReadableStream) as unknown as Readable;
+
+			return {
+				stream,
+				type: "arbitrary",
+				metadata: track.metadata,
+			};
+		} catch (error) {
+			throw new Error(`Failed to get YouTube stream: ${error}`);
+		}
+	}
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+	"compilerOptions": {
+		"target": "ES2020",
+		"module": "commonjs",
+		"lib": ["ES2020"],
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"moduleResolution": "node",
+		"allowSyntheticDefaultImports": true,
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true,
+		"resolveJsonModule": true
+	},
+	"include": ["src/*", "src/types/*"],
+	"exclude": ["node_modules", "dist", "examples"]
+}