@ziplayer/plugin 0.1.52 → 0.2.1-dev-2

package/src/index.ts

@@ -85,23 +85,6 @@ export * from "./SpotifyPlugin";
  */
 export * from "./TTSPlugin";
 
-/**
- * YTSR plugin for advanced YouTube search without streaming.
- *
- * Provides comprehensive YouTube search functionality including:
- * - Advanced video search with filters (duration, upload date, sort by)
- * - Playlist and channel search
- * - Multiple search types (video, playlist, channel, all)
- * - Metadata extraction without streaming
- * - Support for YouTube URLs
- *
- * @example
- * const ytsrPlugin = new YTSRPlugin();
- * const result = await ytsrPlugin.search("Never Gonna Give You Up", "user123");
- * const playlistResult = await ytsrPlugin.searchPlaylist("chill music", "user123");
- */
-export * from "./YTSRPlugin";
-
 /**
  * Attachments plugin for handling Discord attachment URLs and audio files.
  *

package/src/utils/sabr-stream-factory.ts

@@ -1,96 +1,284 @@
-import { createWriteStream } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-
-// Import type declarations
-import type { SabrPlaybackOptions, StreamResult } from "../types/googlevideo";
-
-// Re-export types for external use
-export type { StreamResult, SabrPlaybackOptions };
-
-export interface OutputStream {
-	stream: NodeJS.WritableStream;
-	filePath: string;
-}
-
-/**
- * Creates a sabr stream for YouTube video download
- */
-export async function createSabrStream(videoId: string, options: SabrPlaybackOptions): Promise<{ streamResults: StreamResult }> {
-	try {
-		// Dynamic import to avoid build-time errors
-		const sabrModule = require("googlevideo/sabr-stream") as any;
-		const createSabrStreamImpl = sabrModule.createSabrStream;
-
-		const streamResults = await createSabrStreamImpl(videoId, options);
-
-		return { streamResults };
-	} catch (error) {
-		// Fallback implementation if sabr download is not available
-		throw new Error(`Sabr download not available: ${error}`);
-	}
-}
-
-/**
- * Creates an output stream for writing downloaded content
- */
-export function createOutputStream(videoTitle: string, mimeType: string): OutputStream {
-	const sanitizedTitle = videoTitle.replace(/[<>:"/\\|?*]/g, "_").substring(0, 100);
-	const extension = getExtensionFromMimeType(mimeType);
-	const fileName = `${sanitizedTitle}.${extension}`;
-	const filePath = join(tmpdir(), fileName);
-
-	const stream = createWriteStream(filePath);
-
-	return {
-		stream,
-		filePath,
-	};
-}
-
-/**
- * Creates a stream sink for piping data with progress tracking
- */
-export function createStreamSink(format: any, outputStream: NodeJS.WritableStream, progressBar: any) {
-	return new WritableStream({
-		start() {
-			// Initialize progress tracking
-		},
-		write(chunk) {
-			outputStream.write(chunk);
-			if (progressBar) {
-				progressBar.increment(chunk.length);
-			}
-		},
-		close() {
-			outputStream.end();
-		},
-	});
-}
-
-/**
- * Gets file extension from MIME type
- */
-function getExtensionFromMimeType(mimeType: string): string {
-	const mimeMap: { [key: string]: string } = {
-		"audio/mp4": "m4a",
-		"audio/webm": "webm",
-		"audio/ogg": "ogg",
-		"video/mp4": "mp4",
-		"video/webm": "webm",
-		"video/ogg": "ogv",
-	};
-
-	return mimeMap[mimeType] || "bin";
-}
-
-/**
- * Default sabr playback options
- */
-export const DEFAULT_SABR_OPTIONS: SabrPlaybackOptions = {
-	preferWebM: true,
-	preferOpus: true,
-	videoQuality: "720p",
-	audioQuality: "AUDIO_QUALITY_MEDIUM",
-	enabledTrackTypes: "VIDEO_AND_AUDIO",
-};
+import { createWriteStream } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { Readable } from "stream";
+import { Constants, YTNodes, Platform } from "youtubei.js";
+import type Innertube from "youtubei.js";
+
+import { SabrStream } from "googlevideo/sabr-stream";
+import { buildSabrFormat } from "googlevideo/utils";
+
+import { BG } from "bgutils-js";
+import { JSDOM } from "jsdom";
+import { webStreamToNodeStream } from "./stream-converter";
+
+export interface OutputStream {
+	stream: NodeJS.WritableStream;
+	filePath: string;
+}
+
+export interface SabrAudioResult {
+	title: string;
+	stream: Readable;
+	format: {
+		mimeType: string;
+		itag: number;
+		contentLength: number;
+	};
+}
+
+export interface SabrPlaybackOptions {
+	preferWebM?: boolean;
+	preferOpus?: boolean;
+	videoQuality?: string;
+	audioQuality?: string;
+	enabledTrackTypes?: any;
+}
+/**
+ * Generates a web PoToken for YouTube authentication
+ * This is required for accessing restricted video content
+ */
+async function generateWebPoToken(contentBinding: string): Promise<{
+	visitorData: string;
+	placeholderPoToken: string;
+	poToken: string;
+}> {
+	try {
+		const requestKey = "O43z0dpjhgX20SCx4KAo";
+
+		if (!contentBinding) throw new Error("Could not get visitor data");
+
+		const dom = new JSDOM();
+
+		Object.assign(globalThis, {
+			window: dom.window,
+			document: dom.window.document,
+		});
+
+		const bgConfig = {
+			fetch: (input: any, init: any) => fetch(input, init),
+			globalObj: globalThis,
+			identifier: contentBinding,
+			requestKey,
+		};
+
+		const bgChallenge = await BG.Challenge.create(bgConfig);
+
+		if (!bgChallenge) throw new Error("Could not get challenge");
+
+		const interpreterJavascript = bgChallenge.interpreterJavascript.privateDoNotAccessOrElseSafeScriptWrappedValue;
+
+		if (interpreterJavascript) {
+			new Function(interpreterJavascript)();
+		} else throw new Error("Could not load VM");
+
+		const poTokenResult = await BG.PoToken.generate({
+			program: bgChallenge.program,
+			globalName: bgChallenge.globalName,
+			bgConfig,
+		});
+
+		const placeholderPoToken = BG.PoToken.generatePlaceholder(contentBinding);
+
+		return {
+			visitorData: contentBinding,
+			placeholderPoToken,
+			poToken: poTokenResult.poToken,
+		};
+	} catch (error) {
+		console.warn("PoToken generation failed, continuing without it:", error);
+		return {
+			visitorData: contentBinding,
+			placeholderPoToken: "",
+			poToken: "",
+		};
+	}
+}
+
+/**
+ * Makes a proper player request to YouTube API
+ */
+async function makePlayerRequest(innertube: Innertube, videoId: string, reloadPlaybackContext?: any): Promise<any> {
+	const watchEndpoint = new YTNodes.NavigationEndpoint({
+		watchEndpoint: { videoId },
+	});
+
+	const extraArgs: any = {
+		playbackContext: {
+			adPlaybackContext: { pyv: true },
+			contentPlaybackContext: {
+				vis: 0,
+				splay: false,
+				lactMilliseconds: "-1",
+				signatureTimestamp: innertube.session.player?.signature_timestamp,
+			},
+		},
+		contentCheckOk: true,
+		racyCheckOk: true,
+	};
+
+	if (reloadPlaybackContext) {
+		extraArgs.playbackContext.reloadPlaybackContext = reloadPlaybackContext;
+	}
+
+	return watchEndpoint.call(innertube.actions, {
+		...extraArgs,
+		parse: true,
+	});
+}
+
+/**
+ * YouTube VM shim
+ * This allows the SABR stream to execute YouTube's custom JavaScript for deciphering signatures and generating tokens
+ */
+Platform.shim.eval = async (data, env) => {
+	const properties = [];
+
+	if (env.n) properties.push(`n: exportedVars.nFunction("${env.n}")`);
+	if (env.sig) properties.push(`sig: exportedVars.sigFunction("${env.sig}")`);
+
+	const code = `${data.output}\nreturn { ${properties.join(", ")} }`;
+	return new Function(code)();
+};
+
+/**
+ * Creates a SABR audio stream for YouTube video download
+ * This provides better quality and more reliable streaming than standard methods
+ */
+export async function createSabrStream(
+	videoId: string,
+	innertube: Innertube,
+	options?: SabrPlaybackOptions,
+): Promise<SabrAudioResult> {
+	try {
+		// Generate PoToken for authentication
+		const webPo = await generateWebPoToken(videoId);
+
+		// Make initial player request
+		const player = await makePlayerRequest(innertube, videoId);
+
+		const title = player.video_details?.title || "unknown";
+
+		const serverAbrStreamingUrl = await innertube.session.player?.decipher(player.streaming_data?.server_abr_streaming_url);
+
+		const ustreamerConfig =
+			player.player_config?.media_common_config.media_ustreamer_request_config?.video_playback_ustreamer_config;
+
+		if (!serverAbrStreamingUrl || !ustreamerConfig) {
+			throw new Error("Missing SABR streaming config");
+		}
+
+		const sabrFormats = player.streaming_data?.adaptive_formats.map((f: any) => buildSabrFormat(f)) || [];
+
+		const sabr = new SabrStream({
+			formats: sabrFormats,
+			serverAbrStreamingUrl,
+			videoPlaybackUstreamerConfig: ustreamerConfig,
+			poToken: webPo.poToken,
+			clientInfo: {
+				clientName: parseInt(
+					Constants.CLIENT_NAME_IDS[innertube.session.context.client.clientName as keyof typeof Constants.CLIENT_NAME_IDS],
+				),
+				clientVersion: innertube.session.context.client.clientVersion,
+			},
+		});
+
+		// Handle player response reload events
+		sabr.on("reloadPlayerResponse", async (ctx: any) => {
+			try {
+				const pr = await makePlayerRequest(innertube, videoId, ctx);
+
+				const url = await innertube.session.player?.decipher(pr.streaming_data?.server_abr_streaming_url);
+
+				const config = pr.player_config?.media_common_config.media_ustreamer_request_config?.video_playback_ustreamer_config;
+
+				if (url && config) {
+					sabr.setStreamingURL(url);
+					sabr.setUstreamerConfig(config);
+				}
+			} catch (error) {
+				console.error("Failed to reload player response:", error);
+			}
+		});
+
+		// Start the stream with audio preference
+		const mergedOptions = { ...DEFAULT_SABR_OPTIONS, ...options };
+		const { audioStream, selectedFormats } = await sabr.start({
+			audioQuality: mergedOptions?.audioQuality || "medium",
+		});
+
+		// Convert Web Stream to Node.js Readable stream with optimized buffer
+		const nodeStream = webStreamToNodeStream(audioStream, 32 * 1024); // 32KB buffer for YouTube streams
+
+		return {
+			title,
+			stream: nodeStream,
+			format: {
+				mimeType: selectedFormats.audioFormat.mimeType || "audio/webm",
+				itag: selectedFormats.audioFormat.itag || 0,
+				contentLength: selectedFormats.audioFormat.contentLength || 0,
+			},
+		};
+	} catch (error) {
+		throw new Error(`SABR stream creation failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
+/**
+ * Creates an output stream for writing downloaded content
+ */
+export function createOutputStream(videoTitle: string, mimeType: string): OutputStream {
+	const sanitizedTitle = videoTitle.replace(/[<>:"/\\|?*]/g, "_").substring(0, 100);
+	const extension = getExtensionFromMimeType(mimeType);
+	const fileName = `${sanitizedTitle}.${extension}`;
+	const filePath = join(tmpdir(), fileName);
+
+	const stream = createWriteStream(filePath);
+
+	return {
+		stream,
+		filePath,
+	};
+}
+
+/**
+ * Sanitizes a filename by removing invalid characters
+ */
+export function sanitizeFileName(name: string): string {
+	return name.replace(/[^\w\d]+/g, "_").slice(0, 128);
+}
+
+/**
+ * Converts bytes to megabytes
+ */
+export function bytesToMB(bytes: number): string {
+	return (bytes / 1024 / 1024).toFixed(2);
+}
+
+/**
+ * Gets file extension from MIME type
+ */
+function getExtensionFromMimeType(mimeType: string): string {
+	const mimeMap: { [key: string]: string } = {
+		"audio/mp4": "m4a",
+		"audio/webm": "webm",
+		"audio/ogg": "ogg",
+		"video/mp4": "mp4",
+		"video/webm": "webm",
+		"video/ogg": "ogv",
+	};
+
+	return mimeMap[mimeType] || "bin";
+}
+
+/**
+ * Default sabr playback options - optimized for memory usage
+ * Using MEDIUM quality and WebM/Opus reduces bandwidth by ~30-40%
+ */
+export const DEFAULT_SABR_OPTIONS: SabrPlaybackOptions = {
+	preferWebM: true, // WebM with Opus is more memory-efficient
+	preferOpus: true, // Opus codec = smaller bitrate vs AAC
+	videoQuality: "360p", // Lower resolution = less processing
+	audioQuality: "medium", // Medium quality balances quality vs bandwidth (~96-128kbps vs 256kbps)
+	enabledTrackTypes: "VIDEO_AND_AUDIO",
+};

package/src/utils/stream-converter.ts

@@ -2,78 +2,146 @@ import { Readable } from "stream";
 
 /**
  * Converts a Web ReadableStream to a Node.js Readable stream
+ * with proper backpressure handling to prevent memory bloat
+ *
+ * Optimization:
+ * - Respects highWaterMark (64KB buffer)
+ * - Handles backpressure by pausing reads when buffer is full
+ * - Batches small chunks to reduce overhead
+ * - Lazy evaluation - only reads when consumer is ready
  */
-export function webStreamToNodeStream(webStream: ReadableStream): Readable {
+export function webStreamToNodeStream(webStream: ReadableStream, highWaterMark: number = 64 * 1024): Readable {
+	let reader: ReadableStreamDefaultReader | null = null;
+	let pumpActive = true;
+	let abortController: AbortController | null = null;
+	let isReading = false; // Prevent concurrent reads
+
 	const nodeStream = new Readable({
-		read() {
-			// This will be handled by the Web Stream reader
+		// Set buffer size to 64KB - balance between memory and throughput
+		highWaterMark: highWaterMark,
+
+		read(size?: number) {
+			// Resume reading when stream is ready for more data
+			if (!isReading && pumpActive && reader) {
+				isReading = true;
+				pump().catch((error) => {
+					if (pumpActive) {
+						console.error("[stream-converter] Pump error:", error);
+					}
+				});
+			}
 		},
-	});
 
-	// Create a reader from the Web Stream
-	const reader = webStream.getReader();
+		destroy(error: Error | null, callback: (error?: Error | null) => void) {
+			// Gracefully stop the pump when stream is destroyed
+			pumpActive = false;
 
-	// 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));
+			// Cancel reader if active
+			if (reader) {
+				try {
+					reader.cancel().catch(() => {
+						// Ignore cancel errors
+					});
+					reader = null;
+				} catch {}
 			}
-		} catch (error) {
-			nodeStream.destroy(error as Error);
-		}
-	};
 
-	// Start pumping data
-	pump();
-
-	return nodeStream;
-}
+			// Abort any pending operations
+			if (abortController) {
+				try {
+					abortController.abort();
+				} catch {}
+				abortController = null;
+			}
 
-/**
- * Converts a Web ReadableStream to a Node.js Readable stream with progress tracking
- */
-export function webStreamToNodeStreamWithProgress(
-	webStream: ReadableStream,
-	progressCallback?: (bytesRead: number) => void,
-): Readable {
-	const nodeStream = new Readable({
-		read() {
-			// This will be handled by the Web Stream reader
+			callback(error);
 		},
 	});
 
-	let bytesRead = 0;
-	const reader = webStream.getReader();
+	// Create abort controller for graceful shutdown
+	abortController = new AbortController();
+
+	// Create a reader from the Web Stream
+	reader = webStream.getReader();
 
+	// Read chunks with backpressure support
 	const pump = async () => {
 		try {
-			while (true) {
+			while (pumpActive && reader) {
 				const { done, value } = await reader.read();
+
+				// Check if pump was stopped during read
+				if (!pumpActive || !reader) {
+					break;
+				}
+
 				if (done) {
 					nodeStream.push(null); // End the stream
 					break;
 				}
 
-				const buffer = Buffer.from(value);
-				nodeStream.push(buffer);
+				if (value && pumpActive) {
+					// Convert to Buffer and push
+					const buffer = Buffer.from(value);
+
+					// Check backpressure: push() returns false if internal buffer is full
+					// This means we should pause and let the consumer catch up
+					const shouldContinue = nodeStream.push(buffer);
 
-				bytesRead += buffer.length;
-				if (progressCallback) {
-					progressCallback(bytesRead);
+					if (!shouldContinue) {
+						// Internal buffer is full, pause reading
+						isReading = false;
+						break; // Exit pump, will resume when consumer calls read()
+					}
 				}
 			}
 		} catch (error) {
-			nodeStream.destroy(error as Error);
+			// Only destroy if pump is still active and stream exists
+			if (pumpActive) {
+				const errorMsg = error instanceof Error ? error.message : String(error);
+
+				// Ignore "Controller is already closed" and stream cancelled errors
+				if (
+					errorMsg.includes("Controller is already closed") ||
+					errorMsg.includes("already been cancelled") ||
+					errorMsg.includes("stream closed") ||
+					errorMsg.includes("aborted")
+				) {
+					// Stream was destroyed externally, just end cleanly
+					nodeStream.push(null);
+				} else {
+					// Real error, report it
+					nodeStream.destroy(error as Error);
+				}
+			}
+		} finally {
+			// Mark as not reading
+			isReading = false;
+
+			// Cleanup reader when pump ends
+			try {
+				if (reader) {
+					await reader.cancel();
+					reader = null;
+				}
+			} catch {}
+
+			pumpActive = false;
 		}
 	};
 
-	pump();
+	// Start initial pump when stream is requested
+	// Note: pump will be called by read() callback for backpressure compliance
+	setImmediate(() => {
+		if (pumpActive && reader && !isReading) {
+			isReading = true;
+			pump().catch((error) => {
+				if (pumpActive) {
+					console.error("[stream-converter] Initial pump error:", error);
+				}
+			});
+		}
+	});
 
 	return nodeStream;
 }

package/tsconfig.json

@@ -16,8 +16,12 @@
 		"allowSyntheticDefaultImports": true,
 		"experimentalDecorators": true,
 		"emitDecoratorMetadata": true,
-		"resolveJsonModule": true
+		"resolveJsonModule": true,
+		"paths": {
+			"googlevideo/sabr-stream": ["./node_modules/googlevideo/dist/src/exports/sabr-stream"],
+			"googlevideo/utils": ["./node_modules/googlevideo/dist/src/exports/utils"]
+		}
 	},
-	"include": ["src/*", "src/types/*"],
+	"include": ["src/*"],
 	"exclude": ["node_modules", "dist", "examples"]
 }