@lunarity/nebula-fetch-cli 0.0.2 → 0.0.4

package/README.md

@@ -1 +1,56 @@
-# nebula-fetch-cli
+# Nebula Fetch CLI
+
+A command-line interface tool for downloading media from different platforms.
+
+## 🚀 Installation
+
+```bash
+npm install -g @lunarity/nebula-fetch-cli
+```
+
+## 📖 Usage
+
+### 📺 YouTube Downloads
+
+Download videos or audio from YouTube using the following commands:
+
+```bash
+# Download video (default)
+nebula-fetch youtube <url>
+# or using alias
+nebula-fetch yt <url>
+
+# Download audio only
+nebula-fetch youtube <url> --audio
+# or
+nebula-fetch yt <url> -a
+
+# Specify output path
+nebula-fetch youtube <url> --output path/to/file
+# or
+nebula-fetch yt <url> -o path/to/file
+
+# Show verbose output
+nebula-fetch youtube <url> --verbose
+# or
+nebula-fetch yt <url> -v
+```
+
+### ⚙️ Options
+
+- `-o, --output <path>` - Specify the output path for the downloaded file
+- `-a, --audio` - Download audio only (saves as .mp3)
+- `-v, --verbose` - Show detailed information during download
+- `--version` - Show version number
+- `--help` - Show help information
+
+## ✨ Features
+
+- YouTube video downloads
+- Audio-only extraction option
+- Custom output path
+- Verbose mode for detailed information
+
+## 📄 License
+
+MIT

package/commands/youtube.ts

@@ -1,39 +1,156 @@
 import fs from "fs";
 import path from "path";
-
-import { YtdlCore, toPipeableStream } from "@ybd-project/ytdl-core";
+import { YtdlCore } from "@ybd-project/ytdl-core";
 import chalk from "chalk";
+import { Readable } from "stream";
+
+interface DownloadOptions {
+  url: string;
+  audioOnly?: boolean;
+  verbose?: boolean;
+  outputPath?: string;
+}
+
+export async function downloadYoutube(options: DownloadOptions): Promise<void> {
+  const { url, audioOnly = false, verbose = false, outputPath } = options;
 
-export async function downloadYoutubeAudio(
-  url: string,
-  outputPath?: string
-): Promise<void> {
   try {
-    if (!url) {
-      throw new Error("Please provide a YouTube URL");
+    console.log(chalk.cyan("🔍 Fetching video information..."));
+    // Use all clients to maximize chances of finding a working one
+    const ytdl = new YtdlCore({
+      clients: ["web", "android", "ios", "tv", "mweb"],
+    });
+    
+    const info = await ytdl.getFullInfo(url);
+    
+    console.log(chalk.cyan(`🎬 Video title: ${info.videoDetails.title}`));
+    console.log(
+      chalk.cyan(
+        `🎬 Video author: ${info.videoDetails.author?.name || "Unknown"}`
+      )
+    );
+
+    if (verbose) {
+      console.log(JSON.stringify(info.videoDetails, null, 2));
     }
+    
+    const videoTitle = info.videoDetails.title.replace(/[^\w\s]/gi, "_");
 
-    console.log(chalk.cyan("🔍 Fetching video information..."));
-    const ytdl = new YtdlCore({});
-    let videoTitle = "";
+    // Filter to only valid (deciphered) formats
+    let validFormats = info.formats.filter(f => f.url);
+
+    if (validFormats.length === 0) {
+       throw new Error("No downloadable formats found (signatures could not be deciphered).");
+    }
 
-    await ytdl.getBasicInfo(url).then((info) => {
-      videoTitle = info.videoDetails.title.replace(/[^\w\s]/gi, "_");
+    if (verbose) {
+        console.log(`Found ${info.formats.length} total formats, ${validFormats.length} valid (deciphered).`);
+    }
+
+    // Sort based on preference to try best ones first
+    validFormats.sort((a, b) => {
+        if (audioOnly) {
+            const aAudio = a.hasAudio && !a.hasVideo;
+            const bAudio = b.hasAudio && !b.hasVideo;
+            if (aAudio && !bAudio) return -1;
+            if (!aAudio && bAudio) return 1;
+            return (b.audioBitrate || 0) - (a.audioBitrate || 0);
+        } else {
+             const aMuxed = a.hasAudio && a.hasVideo;
+             const bMuxed = b.hasAudio && b.hasVideo;
+             if (aMuxed && !bMuxed) return -1;
+             if (!aMuxed && bMuxed) return 1;
+             return (b.bitrate || 0) - (a.bitrate || 0);
+        }
     });
 
-    const stream = await ytdl.download(url, {
-      filter: "audioonly",
+    let workingFormat = null;
+    let workingUrl = "";
+    let finalUserAgent = "";
+
+    console.log(chalk.yellow("🔄 Testing formats to find a valid one..."));
+
+    for (const format of validFormats) {
+        let downloadUrl = format.url;
+        if (info.poToken && !downloadUrl.includes('pot=')) {
+            downloadUrl += `&pot=${encodeURIComponent(info.poToken)}`;
+        }
+
+        // Determine User-Agent
+        let userAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36';
+        if (format.sourceClientName === 'ios') {
+            userAgent = 'com.google.ios.youtube/19.29.1 (iPhone16,2; U; CPU iOS 17_5_1 like Mac OS X; en_US)';
+        } else if (format.sourceClientName === 'android') {
+            userAgent = 'com.google.android.youtube/19.29.35 (Linux; U; Android 14; en_US) gzip';
+        } else if (format.sourceClientName === 'tv') {
+            userAgent = 'Mozilla/5.0 (ChromiumNet/53.0.2785.124) Cobalt/53.0.2785.124-devel-000000-000 Star/1.0';
+        }
+
+        try {
+            const response = await fetch(downloadUrl, {
+                method: 'HEAD',
+                headers: {
+                    'User-Agent': userAgent,
+                    'Referer': 'https://www.youtube.com/',
+                }
+            });
+
+            if (response.ok) {
+                workingFormat = format;
+                workingUrl = downloadUrl;
+                finalUserAgent = userAgent;
+                if (verbose) console.log(chalk.green(`  ✅ Found working format: ${format.itag} (${format.sourceClientName})`));
+                break;
+            } else {
+                if (verbose) console.log(chalk.red(`  ❌ Format ${format.itag} (${format.sourceClientName}) failed: ${response.status}`));
+            }
+        } catch (e) {
+            if (verbose) console.log(chalk.red(`  ❌ Format ${format.itag} error: ${e}`));
+        }
+    }
+
+    if (!workingFormat || !workingUrl) {
+        throw new Error("Could not find any valid downloadable format (all returned 403/Error).");
+    }
+
+    console.log(chalk.blue(`⬇️ Downloading format: ${workingFormat.container} | ${workingFormat.qualityLabel || 'Audio'} | ${workingFormat.audioBitrate || '?'}kbps | Client: ${workingFormat.sourceClientName}`));
+
+    // Direct download bypass
+    const response = await fetch(workingUrl, {
+        headers: {
+            'User-Agent': finalUserAgent,
+            'Referer': 'https://www.youtube.com/',
+        }
     });
 
+    if (!response.ok || !response.body) {
+        throw new Error(`Failed to download video stream: ${response.status} ${response.statusText}`);
+    }
+
     const outputFilePath =
-      outputPath || path.join(process.cwd(), `${videoTitle}.mp3`);
-    toPipeableStream(stream).pipe(fs.createWriteStream(outputFilePath));
+      outputPath ||
+      path.join(process.cwd(), `${videoTitle}.${audioOnly ? "mp3" : "mp4"}`);
+    
+    const fileStream = fs.createWriteStream(outputFilePath);
+    
+    // Convert Web ReadableStream to Node Readable Stream
+    // @ts-ignore
+    const nodeStream = Readable.fromWeb(response.body);
+    
+    await new Promise<void>((resolve, reject) => {
+        nodeStream.pipe(fileStream);
+        nodeStream.on('error', reject);
+        fileStream.on('finish', resolve);
+        fileStream.on('error', reject);
+    });
 
-    console.log(chalk.green(`✅ Download finished: ${outputFilePath}`));
+    console.log(chalk.green.bold(`✅ Download finished: ${outputFilePath}`));
   } catch (error) {
     if (error instanceof Error) {
-      console.error(chalk.red("Error:", error.message));
+      console.error(chalk.red.bold("❌ Error:", error.message));
+      if (verbose && error.stack) {
+        console.error(error.stack);
+      }
     }
-    throw error;
   }
-}
+}