getraw 0.2.0 → 0.2.2

package/.github/workflows/release.yml

@@ -41,3 +41,4 @@ jobs:
             --generate-notes
         env:
           GH_TOKEN: ${{ github.token }}
+

package/bun.lock

@@ -7,6 +7,7 @@
       "dependencies": {
         "hls-parser": "^0.13.6",
         "mpd-parser": "^1.3.0",
+        "youtubei.js": "^17.0.1",
       },
       "devDependencies": {
         "@types/bun": "latest",
@@ -19,6 +20,8 @@
   "packages": {
     "@babel/runtime": ["@babel/runtime@7.29.7", "", {}, "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw=="],
 
+    "@bufbuild/protobuf": ["@bufbuild/protobuf@2.12.0", "", {}, "sha512-B/XlCaFIP8LOwzo+bz5uFzATYokcwCKQcghqnlfwSmM5eX/qTkvDBnDPs+gXtX/RyjxJ4DRikECcPJbyALA8FA=="],
+
     "@types/bun": ["@types/bun@1.3.14", "", { "dependencies": { "bun-types": "1.3.14" } }, "sha512-h1hFqFVcvAvD9j9K7ZW7vd82aSA+rTdznZa+5bwvCwqSB1jmmfLcbIWhOLx1/+boy/xmjgCs/OMUL8hRJSmnPw=="],
 
     "@types/node": ["@types/node@25.9.3", "", { "dependencies": { "undici-types": ">=7.24.0 <7.24.7" } }, "sha512-603BddQMv3pUcr4U2dhujk83N2tTDVr/34wII2B6bJy6g+8WD6yUb11jszNs0gdi4PesVWl7ABt8nYMVpnLUcg=="],
@@ -35,6 +38,8 @@
 
     "hls-parser": ["hls-parser@0.13.6", "", {}, "sha512-I40sl22E2muqeSTpG8kMN2dAegAhubkXPXtnsUXFwdKwZK47d1Q+XwuX32VMZ++AZU5oeQIZqAnGNHxSG1sWaw=="],
 
+    "meriyah": ["meriyah@6.1.4", "", {}, "sha512-Sz8FzjzI0kN13GK/6MVEsVzMZEPvOhnmmI1lU5+/1cGOiK3QUahntrNNtdVeihrO7t9JpoH75iMNXg6R6uWflQ=="],
+
     "min-document": ["min-document@2.19.2", "", { "dependencies": { "dom-walk": "^0.1.0" } }, "sha512-8S5I8db/uZN8r9HSLFVWPdJCvYOejMcEC82VIzNUc6Zkklf/d1gg2psfE79/vyhWOj4+J8MtwmoOz3TmvaGu5A=="],
 
     "mpd-parser": ["mpd-parser@1.3.1", "", { "dependencies": { "@babel/runtime": "^7.12.5", "@videojs/vhs-utils": "^4.0.0", "@xmldom/xmldom": "^0.8.3", "global": "^4.4.0" }, "bin": { "mpd-to-m3u8-json": "bin/parse.js" } }, "sha512-1FuyEWI5k2HcmhS1HkKnUAQV7yFPfXPht2DnRRGtoiiAAW+ESTbtEXIDpRkwdU+XyrQuwrIym7UkoPKsZ0SyFw=="],
@@ -46,5 +51,7 @@
     "undici-types": ["undici-types@7.24.6", "", {}, "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg=="],
 
     "url-toolkit": ["url-toolkit@2.2.5", "", {}, "sha512-mtN6xk+Nac+oyJ/PrI7tzfmomRVNFIWKUbG8jdYFt52hxbiReFAXIjYskvu64/dvuW71IcB7lV8l0HvZMac6Jg=="],
+
+    "youtubei.js": ["youtubei.js@17.0.1", "", { "dependencies": { "@bufbuild/protobuf": "^2.0.0", "meriyah": "^6.1.4" } }, "sha512-1lO4b8UqMDzE0oh2qEGzbBOd4UYRdxn/4PdpRM7BGTHxM6ddsEsKZTu90jp8V9FHVgC2h1UirQyqoqLiKwl+Zg=="],
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getraw",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Fast media downloader CLI built natively in Bun/TypeScript",
   "type": "module",
   "bin": {
@@ -10,11 +10,13 @@
     "dev": "bun run src/cli/index.ts",
     "test": "bun test",
     "build": "bun build src/cli/index.ts --compile --outfile=getraw",
-    "dashboard": "bun run tools/dashboard.ts"
+    "dashboard": "bun run tools/dashboard.ts",
+    "postinstall": "bun run scripts/patch-youtubei.js"
   },
   "dependencies": {
     "hls-parser": "^0.13.6",
-    "mpd-parser": "^1.3.0"
+    "mpd-parser": "^1.3.0",
+    "youtubei.js": "^17.0.1"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/scripts/patch-youtubei.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// Patches youtubei.js to use Bun-native JS evaluation instead of the default stub
+import { writeFileSync } from "fs";
+import { resolve } from "path";
+
+const evalPath = resolve("node_modules/youtubei.js/dist/src/platform/jsruntime/default.js");
+const evalCode = `export default async function evaluate(data) {
+  const fn = new Function(data.output);
+  return fn();
+}
+`;
+
+writeFileSync(evalPath, evalCode);
+console.log("Patched youtubei.js jsruntime for Bun-native evaluation");

package/src/cli/index.ts

@@ -3,7 +3,8 @@ import { parseArgs, printHelp } from "./options";
 import { Orchestrator } from "../core/orchestrator";
 import { logger } from "../core/logger";
 
-const VERSION = "0.0.0";
+import pkg from "../../package.json";
+const VERSION = pkg.version;
 
 async function main(): Promise<void> {
   const args = process.argv.slice(2);

package/src/cli/options.ts

@@ -20,7 +20,7 @@ export const FLAG_DEFS: FlagDef[] = [
   { long: "--list-formats", short: "-F", description: "List available formats", type: "boolean", key: "listFormats" },
   { long: "--dump-json", short: "-j", description: "Dump info JSON to stdout", type: "boolean", key: "dumpJson" },
   { long: "--quiet", short: "-q", description: "Suppress output", type: "boolean", key: "quiet" },
-  { long: "--verbose", short: "-v", description: "Verbose output", type: "boolean", key: "verbose" },
+  { long: "--verbose", description: "Verbose output", type: "boolean", key: "verbose" },
   { long: "--no-progress", description: "Disable progress bar", type: "boolean", key: "noProgress" },
   { long: "--retries", short: "-R", description: "Number of retries", type: "number", key: "retries" },
   { long: "--rate-limit", short: "-r", description: "Rate limit in bytes/sec", type: "number", key: "rateLimit" },
@@ -32,7 +32,7 @@ export const FLAG_DEFS: FlagDef[] = [
   { long: "--embed-subs", description: "Embed subtitles in output", type: "boolean", key: "embedSubs" },
   { long: "--merge-output-format", description: "Output container for merging", type: "string", key: "mergeOutputFormat" },
   { long: "--ffmpeg-location", description: "Path to ffmpeg binary", type: "string", key: "ffmpegLocation" },
-  { long: "--version", short: "-V", description: "Print version", type: "boolean", key: "version" },
+  { long: "--version", short: "-v", description: "Print version", type: "boolean", key: "version" },
   { long: "--help", short: "-h", description: "Show help", type: "boolean", key: "help" },
 ];
 

package/src/core/orchestrator.ts

@@ -102,7 +102,7 @@ export class Orchestrator {
           ? `${filepath}.f${format.format_id}.${format.ext}`
           : filepath;
 
-      await downloader.download(targetPath, format.url, {
+      await downloader.download(format.url, targetPath, {
         headers: { ...info.http_headers, ...format.http_headers },
         rateLimit: options.rateLimit,
         retries: options.retries,

package/src/extractors/base.ts

@@ -1,9 +1,78 @@
 import { BaseExtractor } from "../core/types";
 import { GenericExtractor } from "./generic";
+import { YouTubeExtractor } from "./youtube/index";
+import { TwitterExtractor } from "./twitter/index";
+import { TwitterSpacesExtractor } from "./twitter/spaces";
+import { TikTokExtractor } from "./tiktok/index";
+import { TikTokUserExtractor } from "./tiktok/user";
+import { InstagramExtractor } from "./instagram/index";
+import { InstagramReelsExtractor } from "./instagram/reels";
+import { RedditExtractor } from "./reddit/index";
+import { RedditGalleryExtractor } from "./reddit/gallery";
+import { TwitchVODExtractor } from "./twitch/index";
+import { TwitchClipExtractor } from "./twitch/clips";
+import { TwitchLiveExtractor } from "./twitch/live";
+import { VimeoExtractor } from "./vimeo/index";
+import { SoundCloudExtractor } from "./soundcloud/index";
+import { SoundCloudPlaylistExtractor } from "./soundcloud/playlist";
+import { BilibiliExtractor } from "./bilibili/index";
+import { BilibiliBangumiExtractor } from "./bilibili/bangumi";
+import { KickExtractor } from "./kick/index";
+import { KickClipsExtractor } from "./kick/clips";
+import { KickLiveExtractor } from "./kick/live";
+import { NiconicoExtractor } from "./niconico/index";
+import { DailymotionExtractor } from "./dailymotion";
+import { RumbleExtractor } from "./rumble";
+import { BandcampExtractor } from "./bandcamp";
+import { SpotifyExtractor } from "./spotify";
+import { PeerTubeExtractor } from "./peertube";
+import { OdyseeExtractor } from "./odysee";
+import { StreamableExtractor } from "./streamable";
+import { ImgurExtractor } from "./imgur";
+import { CoubExtractor } from "./coub";
+import { TEDExtractor } from "./ted";
+import { ArchiveOrgExtractor } from "./archive-org";
+import { DropboxExtractor } from "./dropbox";
+import { GoogleDriveExtractor } from "./google-drive";
 
 export { BaseExtractor };
 
-const extractors: BaseExtractor[] = [];
+const extractors: BaseExtractor[] = [
+  new YouTubeExtractor(),
+  new TwitterExtractor(),
+  new TwitterSpacesExtractor(),
+  new TikTokExtractor(),
+  new TikTokUserExtractor(),
+  new InstagramExtractor(),
+  new InstagramReelsExtractor(),
+  new RedditExtractor(),
+  new RedditGalleryExtractor(),
+  new TwitchVODExtractor(),
+  new TwitchClipExtractor(),
+  new TwitchLiveExtractor(),
+  new VimeoExtractor(),
+  new SoundCloudExtractor(),
+  new SoundCloudPlaylistExtractor(),
+  new BilibiliExtractor(),
+  new BilibiliBangumiExtractor(),
+  new KickExtractor(),
+  new KickClipsExtractor(),
+  new KickLiveExtractor(),
+  new NiconicoExtractor(),
+  new DailymotionExtractor(),
+  new RumbleExtractor(),
+  new BandcampExtractor(),
+  new SpotifyExtractor(),
+  new PeerTubeExtractor(),
+  new OdyseeExtractor(),
+  new StreamableExtractor(),
+  new ImgurExtractor(),
+  new CoubExtractor(),
+  new TEDExtractor(),
+  new ArchiveOrgExtractor(),
+  new DropboxExtractor(),
+  new GoogleDriveExtractor(),
+];
 const genericExtractor = new GenericExtractor();
 
 export function registerExtractor(extractor: BaseExtractor): void {

package/src/extractors/youtube/index.ts

@@ -1,17 +1,29 @@
 import { BaseExtractor, ExtractorError } from "../../core/types";
 import type { InfoDict, Format, Thumbnail } from "../../core/types";
-import { InnerTubeClient } from "./innertube";
-import type { PlayerResponse, VideoDetails, StreamingData } from "./innertube";
-import { fetchPlayerJs, decipherSignatureUrl, clearCache as clearSigCache } from "./signature";
-import { transformNsig, clearNsigCache } from "./nsig";
 import { parseCaptionTracks } from "./captions";
-import { PlaylistExtractor } from "./playlist";
 
 const VALID_URL = /^https?:\/\/(?:(?:www|m|music)\.)?(?:youtube\.com\/(?:watch\?.*v=|shorts\/|live\/|embed\/|v\/)|youtu\.be\/)([a-zA-Z0-9_-]{11})/;
 const PLAYLIST_URL = /^https?:\/\/(?:(?:www|m|music)\.)?youtube\.com\/playlist\?.*list=([a-zA-Z0-9_-]+)/;
 const CHANNEL_URL = /^https?:\/\/(?:(?:www|m|music)\.)?youtube\.com\/(?:channel\/|@)([a-zA-Z0-9_-]+)/;
 
-const PLAYER_URL_RE = /"jsUrl"\s*:\s*"(\/s\/player\/[^"]+\/base\.js)"/;
+function generateCpn(): string {
+  const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+  return Array.from({ length: 16 }, () => chars[Math.floor(Math.random() * 64)]).join("");
+}
+
+let _innertube: Awaited<ReturnType<typeof createInnertube>> | null = null;
+
+async function createInnertube() {
+  const { Innertube } = await import("youtubei.js");
+  return Innertube.create({ generate_session_locally: true });
+}
+
+async function getInnertube() {
+  if (!_innertube) {
+    _innertube = await createInnertube();
+  }
+  return _innertube;
+}
 
 export class YouTubeExtractor extends BaseExtractor {
   readonly _VALID_URL = new RegExp(
@@ -19,234 +31,131 @@ export class YouTubeExtractor extends BaseExtractor {
   );
   readonly _NAME = "youtube";
 
-  private playlistExtractor = new PlaylistExtractor();
-
   protected async _real_extract(url: string): Promise<InfoDict> {
-    const playlistMatch = url.match(PLAYLIST_URL);
-    if (playlistMatch) {
-      return this.playlistExtractor.extractPlaylist(playlistMatch[1]);
-    }
-
-    const channelMatch = url.match(CHANNEL_URL);
-    if (channelMatch && !url.match(VALID_URL)) {
-      return this.playlistExtractor.extractChannelVideos(channelMatch[1]);
-    }
-
     const videoMatch = url.match(VALID_URL);
     if (!videoMatch) {
-      throw new ExtractorError(`Could not extract video ID from URL: ${url}`);
+      throw new ExtractorError(`Unsupported YouTube URL: ${url}`);
     }
 
     return this.extractVideo(videoMatch[1]);
   }
 
   private async extractVideo(videoId: string): Promise<InfoDict> {
-    const webClient = InnerTubeClient.withClient("WEB");
-    let playerResponse = await webClient.getPlayerResponse(videoId);
+    const yt = await getInnertube();
+    const info = await yt.getInfo(videoId);
 
-    const status = playerResponse.playabilityStatus?.status;
-    if (status === "LOGIN_REQUIRED" || status === "CONTENT_CHECK_REQUIRED") {
-      playerResponse = await this.tryAgeGateBypass(videoId, playerResponse);
+    if (!info.basic_info.title) {
+      throw new ExtractorError("Could not extract video info");
     }
 
-    if (playerResponse.playabilityStatus?.status === "ERROR") {
-      throw new ExtractorError(
-        playerResponse.playabilityStatus.reason ?? "Video unavailable"
-      );
-    }
+    const formats = await this.extractFormats(info, yt);
 
-    const videoDetails = playerResponse.videoDetails;
-    if (!videoDetails) {
-      throw new ExtractorError("No video details in player response");
-    }
+    const thumbnails: Thumbnail[] = (info.basic_info.thumbnail ?? []).map((t: { url: string; width: number; height: number }) => ({
+      url: t.url,
+      width: t.width,
+      height: t.height,
+    }));
 
-    let formats = await this.extractFormats(playerResponse, webClient, videoId);
+    const result: InfoDict = {
+      id: videoId,
+      title: info.basic_info.title,
+      formats,
+      thumbnails,
+      description: info.basic_info.short_description,
+      channel: info.basic_info.author,
+      channel_id: info.basic_info.channel_id,
+      duration: info.basic_info.duration,
+      view_count: info.basic_info.view_count,
+      webpage_url: `https://www.youtube.com/watch?v=${videoId}`,
+      live_status: info.basic_info.is_live ? "is_live" : "not_live",
+    };
 
-    if (formats.length === 0) {
-      const androidClient = InnerTubeClient.withClient("ANDROID");
-      const androidResponse = await androidClient.getPlayerResponse(videoId);
-      if (androidResponse.streamingData) {
-        formats = androidClient.parseFormats(androidResponse.streamingData);
+    // Extract captions from page response
+    const pageResponse = await this.fetchPagePlayerResponse(videoId);
+    if (pageResponse) {
+      const captionTracks = pageResponse.captions?.playerCaptionsTracklistRenderer?.captionTracks;
+      if (captionTracks?.length) {
+        const { subtitles, automatic_captions } = parseCaptionTracks(captionTracks);
+        result.subtitles = subtitles;
+        result.automatic_captions = automatic_captions;
       }
     }
 
-    const info = this.buildInfoDict(videoId, videoDetails, playerResponse, formats);
-    return info;
-  }
-
-  private async tryAgeGateBypass(
-    videoId: string,
-    originalResponse: PlayerResponse,
-  ): Promise<PlayerResponse> {
-    const tvClient = InnerTubeClient.withClient("TVHTML5_EMBED");
-    const embedUrl = `https://www.youtube.com/embed/${videoId}`;
-    const tvResponse = await tvClient.getPlayerResponse(videoId, embedUrl);
-
-    if (tvResponse.playabilityStatus?.status === "OK" && tvResponse.streamingData) {
-      return {
-        ...tvResponse,
-        videoDetails: originalResponse.videoDetails ?? tvResponse.videoDetails,
-        captions: originalResponse.captions ?? tvResponse.captions,
-        microformat: originalResponse.microformat ?? tvResponse.microformat,
-      };
-    }
-
-    return originalResponse;
+    return result;
   }
 
-  private async extractFormats(
-    playerResponse: PlayerResponse,
-    client: InnerTubeClient,
-    videoId: string,
-  ): Promise<Format[]> {
-    const streamingData = playerResponse.streamingData;
-    if (!streamingData) return [];
-
-    let formats = client.parseFormats(streamingData);
-
-    const needsDecipher = this.formatsNeedDecipher(streamingData);
-    if (needsDecipher) {
-      formats = await this.decipherFormats(formats, streamingData, videoId);
-    }
-
-    return formats;
-  }
+  private async extractFormats(info: { streaming_data?: { formats?: unknown[]; adaptive_formats?: unknown[] }; chooseFormat: (opts: { type: string; quality: string }) => unknown }, yt: { session: { player: unknown } }): Promise<Format[]> {
+    const formats: Format[] = [];
+    const player = yt.session.player;
+    const cpn = generateCpn();
 
-  private formatsNeedDecipher(streamingData: StreamingData): boolean {
     const allFormats = [
-      ...(streamingData.formats ?? []),
-      ...(streamingData.adaptiveFormats ?? []),
+      ...(info.streaming_data?.formats ?? []),
+      ...(info.streaming_data?.adaptive_formats ?? []),
     ];
-    return allFormats.some((f) => f.signatureCipher && !f.url);
-  }
-
-  private async decipherFormats(
-    formats: Format[],
-    streamingData: StreamingData,
-    videoId: string,
-  ): Promise<Format[]> {
-    const playerJsUrl = await this.getPlayerJsUrl(videoId);
-    if (!playerJsUrl) return formats;
-
-    const playerJs = await fetchPlayerJs(playerJsUrl);
-
-    const allRaw = [
-      ...(streamingData.formats ?? []),
-      ...(streamingData.adaptiveFormats ?? []),
-    ];
-
-    for (let i = 0; i < formats.length; i++) {
-      const raw = allRaw[i];
-      if (!raw) continue;
 
-      if (raw.signatureCipher && !raw.url) {
-        try {
-          formats[i].url = decipherSignatureUrl(raw.signatureCipher, playerJs);
-        } catch {
-          continue;
+    for (const raw of allFormats) {
+      const f = raw as Record<string, unknown>;
+      try {
+        let url: string | undefined;
+
+        if (typeof (f as { decipher?: unknown }).decipher === "function") {
+          const deciphered = await (f as { decipher: (p: unknown) => Promise<unknown> }).decipher(player);
+          if (typeof deciphered === "string") {
+            const parsed = new URL(deciphered);
+            parsed.searchParams.set("cpn", cpn);
+            url = parsed.toString();
+          }
         }
-      }
 
-      if (formats[i].url) {
-        try {
-          formats[i].url = transformNsig(formats[i].url, playerJs);
-        } catch {
-          continue;
-        }
+        if (!url) continue;
+
+        const mime = String(f.mime_type ?? "");
+        const mimeMatch = mime.match(/^(video|audio)\/(\w+);\s*codecs="([^"]+)"/);
+        const ext = mimeMatch?.[2] ?? "mp4";
+        const codecs = mimeMatch?.[3] ?? "";
+        const isVideo = mime.startsWith("video");
+        const isAudio = mime.startsWith("audio");
+
+        formats.push({
+          format_id: String(f.itag ?? ""),
+          url,
+          ext,
+          vcodec: isVideo ? codecs.split(",")[0]?.trim() : "none",
+          acodec: isAudio ? codecs : (isVideo && codecs.includes(",") ? codecs.split(",")[1]?.trim() : undefined),
+          width: (f.width as number) ?? undefined,
+          height: (f.height as number) ?? undefined,
+          fps: (f.fps as number) ?? undefined,
+          tbr: f.bitrate ? Math.round((f.bitrate as number) / 1000) : undefined,
+          filesize: f.content_length ? parseInt(String(f.content_length), 10) : undefined,
+          format_note: String(f.quality_label ?? f.quality ?? ""),
+          audio_channels: (f.audio_channels as number) ?? undefined,
+          http_headers: {
+            "Origin": "https://www.youtube.com",
+            "Referer": "https://www.youtube.com/",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+          },
+        });
+      } catch {
+        continue;
       }
     }
 
     return formats;
   }
 
-  private async getPlayerJsUrl(videoId: string): Promise<string | null> {
-    const watchUrl = `https://www.youtube.com/watch?v=${videoId}`;
+  private async fetchPagePlayerResponse(videoId: string): Promise<Record<string, unknown> | null> {
     try {
-      const response = await fetch(watchUrl, {
+      const resp = await fetch(`https://www.youtube.com/watch?v=${videoId}`, {
         headers: {
-          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
         },
       });
-      const html = await response.text();
-      const match = html.match(PLAYER_URL_RE);
-      return match ? `https://www.youtube.com${match[1]}` : null;
+      const html = await resp.text();
+      const match = html.match(/var\s+ytInitialPlayerResponse\s*=\s*(\{.+?\});/s);
+      return match ? JSON.parse(match[1]) : null;
     } catch {
       return null;
     }
   }
-
-  private buildInfoDict(
-    videoId: string,
-    details: VideoDetails,
-    response: PlayerResponse,
-    formats: Format[],
-  ): InfoDict {
-    const microformat = response.microformat?.playerMicroformatRenderer;
-
-    const thumbnails: Thumbnail[] = (details.thumbnail?.thumbnails ?? []).map((t) => ({
-      url: t.url,
-      width: t.width,
-      height: t.height,
-    }));
-
-    const liveStatus = this.getLiveStatus(details, response);
-
-    const info: InfoDict = {
-      id: videoId,
-      title: details.title,
-      formats,
-      thumbnails,
-      description: details.shortDescription ?? microformat?.description?.simpleText,
-      channel: details.author,
-      channel_id: details.channelId,
-      channel_url: `https://www.youtube.com/channel/${details.channelId}`,
-      uploader: details.author,
-      uploader_id: details.channelId,
-      uploader_url: microformat?.ownerProfileUrl,
-      duration: parseInt(details.lengthSeconds, 10) || undefined,
-      view_count: parseInt(details.viewCount, 10) || undefined,
-      upload_date: microformat?.uploadDate?.replace(/-/g, ""),
-      live_status: liveStatus,
-      webpage_url: `https://www.youtube.com/watch?v=${videoId}`,
-      age_limit: 0,
-      categories: microformat?.category ? [microformat.category] : undefined,
-    };
-
-    if (microformat?.liveBroadcastDetails?.startTimestamp) {
-      info.release_timestamp = Math.floor(
-        new Date(microformat.liveBroadcastDetails.startTimestamp).getTime() / 1000
-      );
-    }
-
-    const captionTracks = response.captions?.playerCaptionsTracklistRenderer?.captionTracks;
-    if (captionTracks?.length) {
-      const { subtitles, automatic_captions } = parseCaptionTracks(captionTracks);
-      info.subtitles = subtitles;
-      info.automatic_captions = automatic_captions;
-    }
-
-    return info;
-  }
-
-  private getLiveStatus(
-    details: VideoDetails,
-    response: PlayerResponse,
-  ): InfoDict["live_status"] {
-    if (details.isLive) return "is_live";
-    if (details.isUpcoming) return "is_upcoming";
-    if (details.isLiveContent) return "was_live";
-    if (response.playabilityStatus?.liveStreamability) return "is_live";
-    return "not_live";
-  }
-
-  static clearCaches(): void {
-    clearSigCache();
-    clearNsigCache();
-  }
 }
-
-export { InnerTubeClient } from "./innertube";
-export { PlaylistExtractor } from "./playlist";
-export { parseCaptionTracks, convertToSrt, convertToVtt } from "./captions";
-export { decipherSignatureUrl, fetchPlayerJs } from "./signature";
-export { transformNsig } from "./nsig";

package/src/extractors/youtube/innertube.ts

@@ -104,14 +104,14 @@ export interface BrowseResponse {
 const CLIENTS: Record<string, ClientContext> = {
   WEB: {
     clientName: "WEB",
-    clientVersion: "2.20240530.02.00",
-    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+    clientVersion: "2.20250615.01.00",
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
     apiKey: "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8",
   },
   ANDROID: {
     clientName: "ANDROID",
-    clientVersion: "19.29.37",
-    userAgent: "com.google.android.youtube/19.29.37 (Linux; U; Android 14) gzip",
+    clientVersion: "19.44.38",
+    userAgent: "com.google.android.youtube/19.44.38 (Linux; U; Android 14) gzip",
     apiKey: "AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w",
     clientId: 3,
   },