@mks2508/bundlp 0.1.12 → 0.1.14

package/dist/index.mjs

@@ -206,7 +206,7 @@ function isRecoverable(code) {
 
 //#endregion
 //#region src/http/client.ts
-const log$7 = logger.scope("HttpClient");
+const log$8 = logger.scope("HttpClient");
 function parseCookies$2(setCookieHeaders) {
 	return setCookieHeaders.map((header) => {
 		const [nameValue, ...attributes] = header.split(";").map((p) => p.trim());
@@ -248,15 +248,15 @@ var HttpClient = class {
 		const baseHeaders = new Headers(fetchOptions.headers);
 		if (cookieHeader) {
 			baseHeaders.set("Cookie", cookieHeader);
-			log$7.info(`Attaching Cookie header (${cookieHeader.length} chars)`);
+			log$8.info(`Attaching Cookie header (${cookieHeader.length} chars)`);
 		}
-		log$7.debug("=== HTTP REQUEST ===");
-		log$7.debug(`URL: ${url}`);
-		log$7.debug(`Method: ${fetchOptions.method || "GET"}`);
-		log$7.debug(`Headers: ${JSON.stringify(Object.fromEntries(baseHeaders.entries()), null, 2)}`);
+		log$8.debug("=== HTTP REQUEST ===");
+		log$8.debug(`URL: ${url}`);
+		log$8.debug(`Method: ${fetchOptions.method || "GET"}`);
+		log$8.debug(`Headers: ${JSON.stringify(Object.fromEntries(baseHeaders.entries()), null, 2)}`);
 		if (fetchOptions.body) {
 			const bodyStr = typeof fetchOptions.body === "string" ? fetchOptions.body : "[binary]";
-			log$7.debug(`Body (first 1000 chars): ${bodyStr.substring(0, 1e3)}`);
+			log$8.debug(`Body (first 1000 chars): ${bodyStr.substring(0, 1e3)}`);
 		}
 		if (!manualRedirects) try {
 			const response = await fetch(url, {
@@ -264,9 +264,9 @@ var HttpClient = class {
 				headers: baseHeaders,
 				signal: timeout ? AbortSignal.timeout(timeout) : void 0
 			});
-			log$7.debug("=== HTTP RESPONSE ===");
-			log$7.debug(`Status: ${response.status} ${response.statusText}`);
-			log$7.debug(`Headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()), null, 2)}`);
+			log$8.debug("=== HTTP RESPONSE ===");
+			log$8.debug(`Status: ${response.status} ${response.statusText}`);
+			log$8.debug(`Headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()), null, 2)}`);
 			return ok(response);
 		} catch (error) {
 			return err(createError("NETWORK_ERROR", `Request to ${url} failed: ${error.message}`, error));
@@ -337,7 +337,7 @@ var HttpClient = class {
 				const domain = c.domain?.toLowerCase() || "";
 				return domain.includes("youtube") || domain.includes("google") || domain.includes("googlevideo") || !c.domain;
 			});
-			log$7.info(`Parsed ${cookies.length} cookies (format: ${format}), ${youtubeCookies.length} YouTube/Google related`);
+			log$8.info(`Parsed ${cookies.length} cookies (format: ${format}), ${youtubeCookies.length} YouTube/Google related`);
 			for (const c of youtubeCookies) this.setCookie({
 				name: c.name,
 				value: c.value,
@@ -347,10 +347,10 @@ var HttpClient = class {
 				httpOnly: c.httpOnly,
 				expires: c.expires
 			});
-			log$7.success(`Loaded ${youtubeCookies.length} YouTube/Google cookies`);
+			log$8.success(`Loaded ${youtubeCookies.length} YouTube/Google cookies`);
 			return ok(youtubeCookies.length);
 		} catch (error) {
-			log$7.error("Failed to parse cookies:", error);
+			log$8.error("Failed to parse cookies:", error);
 			return err(createError("COOKIE_PARSE_ERROR", `Failed to parse cookies: ${error.message}`, error));
 		}
 	}
@@ -529,7 +529,7 @@ function isDrmOnly(formats) {
 
 //#endregion
 //#region src/innertube/client.ts
-const log$6 = logger.scope("InnerTube");
+const log$7 = logger.scope("InnerTube");
 /**
 * Client for interacting with YouTube's InnerTube API.
 */
@@ -593,7 +593,7 @@ var InnerTubeClient = class {
 	*/
 	async fetchPlayer(videoId, options = {}) {
 		const config = INNERTUBE_CLIENTS[this.currentClient];
-		log$6.debug(`Fetching player for ${videoId} with client ${this.currentClient}`);
+		log$7.debug(`Fetching player for ${videoId} with client ${this.currentClient}`);
 		const payload = {
 			context: this.buildContext(),
 			videoId,
@@ -604,57 +604,57 @@ var InnerTubeClient = class {
 		if (options.poToken) {
 			if (!payload.serviceIntegrityDimensions) payload.serviceIntegrityDimensions = {};
 			payload.serviceIntegrityDimensions.poToken = options.poToken;
-			log$6.debug(`Using po_token (length: ${options.poToken.length})`);
+			log$7.debug(`Using po_token (length: ${options.poToken.length})`);
 		}
 		const url = `${INNER_TUBE_API_URL}/player?key=${config.API_KEY || ""}`;
-		log$6.debug("=== INNERTUBE REQUEST ===");
-		log$6.debug(`Client: ${this.currentClient}`);
-		log$6.debug(`API Key: ${config.API_KEY || "none"}`);
-		log$6.debug(`URL: ${url}`);
-		log$6.debug(`Payload: ${JSON.stringify(payload, null, 2)}`);
-		log$6.debug(`Headers: ${JSON.stringify(this.getHeaders(), null, 2)}`);
+		log$7.debug("=== INNERTUBE REQUEST ===");
+		log$7.debug(`Client: ${this.currentClient}`);
+		log$7.debug(`API Key: ${config.API_KEY || "none"}`);
+		log$7.debug(`URL: ${url}`);
+		log$7.debug(`Payload: ${JSON.stringify(payload, null, 2)}`);
+		log$7.debug(`Headers: ${JSON.stringify(this.getHeaders(), null, 2)}`);
 		const responseResult = await httpClient.post(url, payload, { headers: this.getHeaders() });
 		if (isErr(responseResult)) {
-			log$6.error(`HTTP request failed for client ${this.currentClient}:`, responseResult.error.message);
+			log$7.error(`HTTP request failed for client ${this.currentClient}:`, responseResult.error.message);
 			return responseResult;
 		}
 		const response = responseResult.value;
 		if (!response.ok) {
-			log$6.error(`Player request failed for ${this.currentClient}: HTTP ${response.status}`);
+			log$7.error(`Player request failed for ${this.currentClient}: HTTP ${response.status}`);
 			return err(createError("INNERTUBE_ERROR", `Player request failed with status ${response.status}`));
 		}
 		try {
 			const data = await response.json();
-			log$6.debug("=== INNERTUBE RESPONSE ===");
-			log$6.debug(`playabilityStatus: ${JSON.stringify(data.playabilityStatus, null, 2)}`);
-			log$6.debug(`streamingData formats: ${data.streamingData?.formats?.length || 0}`);
-			log$6.debug(`streamingData adaptiveFormats: ${data.streamingData?.adaptiveFormats?.length || 0}`);
-			if (data.streamingData?.adaptiveFormats?.[0]) log$6.debug(`Sample format: ${JSON.stringify(data.streamingData.adaptiveFormats[0], null, 2)}`);
+			log$7.debug("=== INNERTUBE RESPONSE ===");
+			log$7.debug(`playabilityStatus: ${JSON.stringify(data.playabilityStatus, null, 2)}`);
+			log$7.debug(`streamingData formats: ${data.streamingData?.formats?.length || 0}`);
+			log$7.debug(`streamingData adaptiveFormats: ${data.streamingData?.adaptiveFormats?.length || 0}`);
+			if (data.streamingData?.adaptiveFormats?.[0]) log$7.debug(`Sample format: ${JSON.stringify(data.streamingData.adaptiveFormats[0], null, 2)}`);
 			const validated = PlayerResponseSchema(data);
 			if (validated instanceof type.errors) {
-				log$6.error(`Parse error for ${this.currentClient}:`, validated.summary);
+				log$7.error(`Parse error for ${this.currentClient}:`, validated.summary);
 				return err(createError("PARSE_ERROR", `Invalid player response: ${validated.summary}`));
 			}
 			const status = validated.playabilityStatus.status;
 			const reason = validated.playabilityStatus.reason || "No reason";
-			log$6.debug(`Client ${this.currentClient} response: status=${status}, reason=${reason}`);
+			log$7.debug(`Client ${this.currentClient} response: status=${status}, reason=${reason}`);
 			if (status === "ERROR") {
-				log$6.warn(`Client ${this.currentClient} returned ERROR: ${reason}`);
+				log$7.warn(`Client ${this.currentClient} returned ERROR: ${reason}`);
 				return err(createError("VIDEO_UNAVAILABLE", reason));
 			}
 			if (status === "LOGIN_REQUIRED") {
-				log$6.warn(`Client ${this.currentClient} requires login: ${reason}`);
+				log$7.warn(`Client ${this.currentClient} requires login: ${reason}`);
 				return err(createError("VIDEO_UNAVAILABLE", `Login required: ${reason}`));
 			}
 			if (status === "UNPLAYABLE") {
-				log$6.warn(`Client ${this.currentClient} unplayable: ${reason}`);
+				log$7.warn(`Client ${this.currentClient} unplayable: ${reason}`);
 				return err(createError("VIDEO_UNAVAILABLE", `Unplayable: ${reason}`));
 			}
 			const formatsCount = (validated.streamingData?.formats?.length || 0) + (validated.streamingData?.adaptiveFormats?.length || 0);
-			log$6.info(`Client ${this.currentClient} success: ${formatsCount} formats`);
+			log$7.info(`Client ${this.currentClient} success: ${formatsCount} formats`);
 			return ok(validated);
 		} catch (error) {
-			log$6.error(`Parse exception for ${this.currentClient}:`, error);
+			log$7.error(`Parse exception for ${this.currentClient}:`, error);
 			return err(createError("PARSE_ERROR", "Failed to parse InnerTube response", error));
 		}
 	}
@@ -667,35 +667,35 @@ var InnerTubeClient = class {
 	*/
 	async fetchPlayerWithFallback(videoId, options = {}) {
 		const errors = [];
-		log$6.info(`Starting fallback extraction for ${videoId}`);
-		log$6.info(`Fallback order: ${this.FALLBACK_ORDER.join(" → ")}`);
+		log$7.info(`Starting fallback extraction for ${videoId}`);
+		log$7.info(`Fallback order: ${this.FALLBACK_ORDER.join(" → ")}`);
 		for (const clientName of this.FALLBACK_ORDER) {
-			log$6.info(`Trying client: ${clientName}`);
+			log$7.info(`Trying client: ${clientName}`);
 			if (isErr(this.setClient(clientName))) {
-				log$6.warn(`Failed to set client ${clientName}`);
+				log$7.warn(`Failed to set client ${clientName}`);
 				continue;
 			}
 			const result = await this.fetchPlayer(videoId, options);
 			if (isOk(result)) {
 				const validationResult = this.isValidResponse(result.value);
 				if (validationResult.valid) {
-					log$6.success(`Client ${clientName} returned valid response`);
+					log$7.success(`Client ${clientName} returned valid response`);
 					return result;
 				}
-				log$6.warn(`Client ${clientName} response invalid: ${validationResult.reason}`);
+				log$7.warn(`Client ${clientName} response invalid: ${validationResult.reason}`);
 				errors.push({
 					client: clientName,
 					error: createError("VIDEO_UNAVAILABLE", validationResult.reason)
 				});
 			} else {
-				log$6.warn(`Client ${clientName} failed: ${result.error.message}`);
+				log$7.warn(`Client ${clientName} failed: ${result.error.message}`);
 				errors.push({
 					client: clientName,
 					error: result.error
 				});
 			}
 		}
-		log$6.error(`All clients failed for ${videoId}. Errors:`, errors.map((e) => ({
+		log$7.error(`All clients failed for ${videoId}. Errors:`, errors.map((e) => ({
 			client: e.client,
 			error: e.error.message
 		})));
@@ -1412,6 +1412,7 @@ var PlayerCache = class {
 
 //#endregion
 //#region src/player/player.ts
+const log$6 = logger.scope("Player");
 /**
 * Handles YouTube player.js downloading, parsing, and cipher function extraction.
 * Uses AST-based extraction for robustness against YouTube's obfuscation changes.
@@ -1432,20 +1433,36 @@ var Player = class {
 	* Downloads and parses the YouTube player.js to extract cipher functions.
 	* Uses cache-first strategy to minimize network requests.
 	* @param playerUrl - Optional direct URL to player.js, auto-detected if not provided
+	* @param videoId - Optional video ID to fetch player URL from watch page (more reliable)
 	* @returns Result indicating success or failure
 	*/
-	async initialize(playerUrl) {
+	async initialize(playerUrl, videoId) {
 		if (this.initialized) return ok(void 0);
 		if (this.cache && !playerUrl) {
 			const latestResult = this.cache.getLatest();
 			if (isOk(latestResult) && latestResult.value) return this.restoreFromCache(latestResult.value);
 		}
 		if (!playerUrl) {
-			const htmlResult = await httpClient.get(YOUTUBE_BASE_URL);
-			if (!isOk(htmlResult)) return err(htmlResult.error);
-			const match$1 = (await htmlResult.value.text()).match(/\/s\/player\/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+\/base\.js/);
-			if (!match$1) return err(createError("PLAYER_FETCH_FAILED", "Could not determine player URL"));
+			const fetchUrl = videoId ? `${YOUTUBE_BASE_URL}/watch?v=${videoId}` : YOUTUBE_BASE_URL;
+			log$6.info(`Fetching player URL from: ${fetchUrl}`);
+			const htmlResult = await httpClient.get(fetchUrl);
+			if (!isOk(htmlResult)) {
+				log$6.error("Failed to fetch page:", htmlResult.error.message);
+				return err(htmlResult.error);
+			}
+			const html = await htmlResult.value.text();
+			log$6.info(`Response: ${html.length} chars`);
+			const title = html.match(/<title>([^<]*)<\/title>/)?.[1] || "";
+			if (html.includes("Sign in to confirm") || title.toLowerCase().includes("sign in")) log$6.error(`BOT DETECTION: YouTube returned login page (title: ${title})`);
+			if (html.includes("robot") || html.includes("captcha")) log$6.error("BOT DETECTION: YouTube returned robot/captcha page");
+			const match$1 = html.match(/\/s\/player\/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+\/base\.js/);
+			if (!match$1) {
+				log$6.error("Player URL pattern not found in HTML");
+				log$6.error(`HTML title: ${title}`);
+				return err(createError("PLAYER_FETCH_FAILED", `Could not determine player URL from ${fetchUrl}`));
+			}
 			playerUrl = YOUTUBE_BASE_URL + match$1[0];
+			log$6.success(`Found player URL: ${playerUrl}`);
 		}
 		const playerId = this.extractPlayerId(playerUrl);
 		if (this.cache && playerId) {
@@ -2346,7 +2363,7 @@ var YouTubeExtractor = class {
 		return err(createError("INVALID_URL", `Could not extract video ID from: ${url}`));
 	}
 	async realExtract(videoId) {
-		const playerResult = await this.player.initialize();
+		const playerResult = await this.player.initialize(void 0, videoId);
 		if (isErr(playerResult)) return err(playerResult.error);
 		const responseResult = await this.client.fetchPlayerWithFallback(videoId, {
 			signatureTimestamp: this.player.getSignatureTimestamp(),