npmytd 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npmytd",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "A CLI tool to download YouTube videos or audio.",
   "main": "src/cli.js",
   "type": "module",
@@ -22,8 +22,6 @@
   "dependencies": {
     "chalk": "^5.6.2",
     "cli-progress": "^3.12.0",
-    "fluent-ffmpeg": "^2.1.3",
-    "inquirer": "^13.2.2",
-    "ytdl-core": "^4.11.5"
+    "inquirer": "^13.2.2"
   }
 }

package/src/cli.js

@@ -1,6 +1,5 @@
 import { getYouTubeUrl, getOutputFormat, getQuality, getOutputPath } from './prompts.js';
 import { downloadYouTubeMedia } from './downloader.js';
-import ytdl from 'ytdl-core';
 import chalk from 'chalk';
 import path from 'path';
 import { sanitizeFilename } from './utils.js';
@@ -33,25 +32,10 @@ async function main() {
         const format = await getOutputFormat();
         const quality = await getQuality(format);
 
-        // Get video info to suggest a default filename
-        let videoInfo;
-        try {
-            videoInfo = await ytdl.getInfo(url);
-        } catch (error) {
-            if (error.message.includes('Could not extract functions')) {
-                console.error(chalk.red(`Error fetching video information: ${error.message}`));
-                console.error(chalk.yellow(`This often happens when YouTube updates its website, temporarily breaking the downloader.
-Please try again later, or check the 'ytdl-core' GitHub page for updates.`));
-            } else {
-                console.error(chalk.red('Error fetching video information:', error.message));
-            }
-            process.exit(1);
-        }
-        const suggestedFilename = sanitizeFilename(videoInfo.videoDetails.title);
+        // outputPath will now be the directory
+        const outputDirectory = await getOutputPath();
 
-        const outputPath = await getOutputPath(suggestedFilename);
-
-        await downloadYouTubeMedia(url, format, quality, outputPath);
+        await downloadYouTubeMedia(url, format, quality, outputDirectory);
 
         console.log(chalk.bold.green(`
 Process completed successfully!`));

package/src/downloader.js

@@ -1,26 +1,17 @@
-import ytdl from 'ytdl-core';
+import { spawn } from 'child_process';
 import cliProgress from 'cli-progress';
 import path from 'path';
-import fs from 'fs';
-import ffmpeg from 'fluent-ffmpeg';
+import { promises as fs } from 'fs'; // Use promises API for fs
 import { sanitizeFilename, ensureDirectoryExists } from './utils.js';
 import chalk from 'chalk';
 
-// Ensure ffmpeg path is set if it's not in the system's PATH
-// This might be necessary on some systems. For broader compatibility,
-// it's good practice to ensure ffmpeg is discoverable.
-// ffmpeg.setFfmpegPath('/path/to/your/ffmpeg'); // Uncomment and set if needed
-
 export async function downloadYouTubeMedia(url, format, quality, outputPath) {
-    try {
-        const videoId = ytdl.getVideoID(url);
-        const info = await ytdl.getInfo(videoId);
-        const videoTitle = sanitizeFilename(info.videoDetails.title);
-
-        const targetDirectory = path.dirname(outputPath);
-        const targetFilename = path.basename(outputPath);
-        const finalPath = path.join(targetDirectory, targetFilename);
+    let videoTitle = 'unknown_video'; // Default title
+    const targetDirectory = path.dirname(outputPath);
+    let finalFileName = path.basename(outputPath); // Will be updated after getting info
+    let fullOutputPath;
 
+    try {
         // Ensure the output directory exists
         const dirExists = await ensureDirectoryExists(targetDirectory);
         if (!dirExists) {
@@ -28,158 +19,140 @@ export async function downloadYouTubeMedia(url, format, quality, outputPath) {
             return;
         }
 
-        let ytdlOptions = {
-            quality: 'highest', // Default to highest, then adjust based on user input
-        };
+        // --- Step 1: Get video information using yt-dlp --print-json ---
+        console.log(chalk.blue('Fetching video information...'));
+        const infoProcess = spawn('yt-dlp', ['--print-json', url]);
+        let rawInfo = '';
+        infoProcess.stdout.on('data', (data) => {
+            rawInfo += data.toString();
+        });
+
+        await new Promise((resolve, reject) => {
+            infoProcess.on('close', (code) => {
+                if (code === 0) {
+                    try {
+                        const videoInfo = JSON.parse(rawInfo);
+                        videoTitle = sanitizeFilename(videoInfo.title);
+                        resolve();
+                    } catch (e) {
+                        reject(new Error('Failed to parse video info from yt-dlp.'));
+                    }
+                } else {
+                    reject(new Error(`yt-dlp info command failed with code ${code}`));
+                }
+            });
+            infoProcess.on('error', (err) => {
+                reject(new Error(`Failed to run yt-dlp. Is yt-dlp installed and in your PATH? (${err.message})`));
+            });
+        });
+
+        // Update finalFileName with sanitized video title and desired extension
+        const outputExtension = format === 'mp4' ? '.mp4' : '.mp3';
+        finalFileName = `${videoTitle}${outputExtension}`;
+        fullOutputPath = path.join(targetDirectory, finalFileName);
 
-        let outputExtension = '';
+        console.log(chalk.blue(`\nDownloading "${videoTitle}" as ${format.toUpperCase()}...`));
+
+        // --- Step 2: Construct yt-dlp arguments for download ---
+        const ytDlpArgs = [url, '-o', fullOutputPath]; // -o for output path
 
         if (format === 'mp4') {
-            outputExtension = '.mp4';
             switch (quality) {
                 case 'highest':
-                    ytdlOptions.filter = 'videoandaudio'; // ytdl-core typically combines them by default for highest quality
-                    ytdlOptions.quality = 'highestvideo';
+                    ytDlpArgs.push('-f', 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]');
+                    ytDlpArgs.push('--merge-output-format', 'mp4');
                     break;
                 case 'medium':
-                    // Find a 720p or 480p format with audio
-                    ytdlOptions.filter = (format) => format.qualityLabel === '720p' && format.hasAudio && format.hasVideo;
-                    // Fallback if 720p with audio is not found
-                    if (!info.formats.find(f => f.qualityLabel === '720p' && f.hasAudio && f.hasVideo)) {
-                        ytdlOptions.filter = (format) => format.qualityLabel === '480p' && format.hasAudio && format.hasVideo;
-                    }
-                    if (!info.formats.find(f => f.qualityLabel === '480p' && f.hasAudio && f.hasVideo)) {
-                         ytdlOptions.quality = 'lowestvideo'; // Fallback to lowest if medium not found
-                    }
+                    ytDlpArgs.push('-f', 'bestvideo[height<=720][ext=mp4]+bestaudio[ext=m4a]/best[height<=720][ext=mp4]');
+                    ytDlpArgs.push('--merge-output-format', 'mp4');
                     break;
                 case 'lowest':
-                    ytdlOptions.filter = (format) => format.qualityLabel === '360p' && format.hasAudio && format.hasVideo;
-                    if (!info.formats.find(f => f.qualityLabel === '360p' && f.hasAudio && f.hasVideo)) {
-                        ytdlOptions.quality = 'lowestvideo'; // Fallback to lowest available video with audio
-                    }
+                    ytDlpArgs.push('-f', 'bestvideo[height<=360][ext=mp4]+bestaudio[ext=m4a]/best[height<=360][ext=mp4]');
+                    ytDlpArgs.push('--merge-output-format', 'mp4');
                     break;
             }
         } else if (format === 'mp3') {
-            outputExtension = '.mp3';
-            ytdlOptions.filter = 'audioonly';
+            ytDlpArgs.push('--extract-audio', '--audio-format', 'mp3');
             switch (quality) {
                 case 'highest':
-                    ytdlOptions.quality = 'highestaudio';
+                    ytDlpArgs.push('--audio-quality', '0'); // best quality
                     break;
                 case 'medium':
-                    ytdlOptions.quality = 'lowestaudio'; // ytdl-core often only has highest and lowest for audio, 'lowestaudio' is typically still good quality.
+                    ytDlpArgs.push('--audio-quality', '5'); // VBR ~130-160 kbps
                     break;
                 case 'lowest':
-                    ytdlOptions.quality = 'lowestaudio';
+                    ytDlpArgs.push('--audio-quality', '9'); // VBR ~45-85 kbps
                     break;
             }
         }
 
+        // --- Step 3: Execute yt-dlp for download and show progress ---
+        const downloadProcess = spawn('yt-dlp', ytDlpArgs);
         const bar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
-        let receivedBytes = 0;
-        let totalBytes = 0;
-
-        console.log(chalk.blue(`
-Downloading "${videoTitle}" as ${format.toUpperCase()}...`));
-
-        if (format === 'mp4') {
-            const video = ytdl(url, ytdlOptions);
-
-            video.on('response', (res) => {
-                totalBytes = parseInt(res.headers['content-length'], 10);
-                bar.start(totalBytes, 0);
-            });
-
-            video.on('data', (chunk) => {
-                receivedBytes += chunk.length;
-                bar.update(receivedBytes);
-            });
-
-            video.pipe(fs.createWriteStream(finalPath + outputExtension));
-
-            await new Promise((resolve, reject) => {
-                video.on('end', () => {
-                    bar.stop();
-                    console.log(chalk.green(`
-Download completed: ${finalPath}${outputExtension}`));
+        let totalDownloadSize = 0; // in bytes
+        let currentProgress = 0; // in percentage or bytes
+
+        downloadProcess.stderr.on('data', (data) => {
+            const output = data.toString();
+            // yt-dlp progress format example: [download]  10.0% of 100.00MiB at  1.23MiB/s ETA 00:05
+            const progressMatch = output.match(/\[download\]\s+(\d+\.\d+)% of (~?\d+\.\d+\w+)/);
+            const sizeMatch = output.match(/\[download\] Destination: (.+)/); // Match the final output file to determine size if no % progress
+
+            if (progressMatch) {
+                const percentage = parseFloat(progressMatch[1]);
+                const totalSizeStr = progressMatch[2];
+
+                // yt-dlp might report 'of ~SIZE' when total size is not known yet.
+                // For simplicity, we'll start the bar when we have a good estimate.
+                if (totalDownloadSize === 0 && !totalSizeStr.startsWith('~')) {
+                     // Convert string size (e.g., 100.00MiB) to bytes. Simple approximation.
+                    const sizeValue = parseFloat(totalSizeStr.match(/(\d+\.\d+)/)[1]);
+                    const sizeUnit = totalSizeStr.match(/(\w+)$/)[1];
+                    let multiplier = 1;
+                    if (sizeUnit === 'KiB') multiplier = 1024;
+                    else if (sizeUnit === 'MiB') multiplier = 1024 * 1024;
+                    else if (sizeUnit === 'GiB') multiplier = 1024 * 1024 * 1024;
+                    totalDownloadSize = sizeValue * multiplier;
+                    bar.start(100, percentage); // Start with 100 as total and update with percentage
+                }
+                bar.update(percentage);
+            } else if (output.includes('[download] 100%')) {
+                // Ensure bar reaches 100% at the end
+                bar.update(100);
+            }
+             // For debugging yt-dlp output
+            // console.error(output.trim());
+        });
+
+        await new Promise((resolve, reject) => {
+            downloadProcess.on('close', (code) => {
+                bar.stop();
+                if (code === 0) {
+                    console.log(chalk.green(`\nDownload completed: ${fullOutputPath}`));
                     resolve();
-                });
-                video.on('error', (err) => {
-                    bar.stop();
-                    console.error(chalk.red(`
-Error during download:`, err.message));
-                    reject(err);
-                });
-            });
-
-        } else if (format === 'mp3') {
-            const audioStream = ytdl(url, ytdlOptions);
-            const tempFilePath = finalPath + '.tmp'; // Use a temporary file for download
-
-            audioStream.on('response', (res) => {
-                totalBytes = parseInt(res.headers['content-length'], 10);
-                bar.start(totalBytes, 0);
+                } else {
+                    reject(new Error(`yt-dlp download failed with code ${code}`));
+                }
             });
-
-            audioStream.on('data', (chunk) => {
-                receivedBytes += chunk.length;
-                bar.update(receivedBytes);
+            downloadProcess.on('error', (err) => {
+                bar.stop();
+                reject(new Error(`Failed to run yt-dlp. Is yt-dlp installed and in your PATH? (${err.message})`));
             });
+        });
 
-            await new Promise((resolve, reject) => {
-                audioStream.pipe(fs.createWriteStream(tempFilePath))
-                    .on('finish', () => {
-                        bar.stop();
-                        console.log(chalk.blue(`
-Download of audio stream completed. Starting conversion to MP3...`));
-
-                        // Check if ffmpeg is available
-                        ffmpeg.getFfmpegVersion((err) => {
-                            if (err) {
-                                console.error(chalk.red(`ffmpeg is not installed or not found in your system's PATH.`));
-                                console.error(chalk.red('Please install ffmpeg to convert to MP3.'));
-                                console.error(chalk.red(`You can download it from https://ffmpeg.org/download.html and ensure it's accessible in your PATH.`));
-                                reject(new Error('ffmpeg not found.'));
-                                return;
-                            }
-
-                            ffmpeg(tempFilePath)
-                                .audioBitrate(quality === 'highest' ? 320 : (quality === 'medium' ? 192 : 128)) // Set bitrate based on quality
-                                .save(finalPath + outputExtension)
-                                .on('end', () => {
-                                    fs.unlink(tempFilePath, (err) => { // Clean up temporary file
-                                        if (err) console.error(chalk.yellow('Warning: Could not remove temporary file:', err.message));
-                                    });
-                                    console.log(chalk.green(`
-Conversion and download completed: ${finalPath}${outputExtension}`));
-                                    resolve();
-                                })
-                                .on('error', (err) => {
-                                    fs.unlink(tempFilePath, (err) => { // Clean up temporary file on error
-                                        if (err) console.error(chalk.yellow('Warning: Could not remove temporary file:', err.message));
-                                    });
-                                    console.error(chalk.red(`
-Error during MP3 conversion:`, err.message));
-                                    reject(err);
-                                });
-                        });
-                    })
-                    .on('error', (err) => {
-                        bar.stop();
-                        console.error(chalk.red(`
-Error during audio stream download:`, err.message));
-                        reject(err);
-                    });
-            });
-        }
     } catch (error) {
-        if (error.message.includes('No video id found')) {
-            console.error(chalk.red('Invalid YouTube URL or video ID. Please check and try again.'));
-        } else if (error.message.includes('Code: 410')) {
+        if (error.message.includes('Failed to run yt-dlp')) {
+            console.error(chalk.red(error.message));
+            console.error(chalk.yellow('Please ensure yt-dlp is installed and available in your system\'s PATH.'));
+            console.error(chalk.yellow('You can install it with `pip install yt-dlp` or from https://github.com/yt-dlp/yt-dlp/releases.'));
+        } else if (error.message.includes('Failed to parse video info')) {
+            console.error(chalk.red(error.message));
+        } else if (error.message.includes('This video is unavailable')) {
             console.error(chalk.red('This video is unavailable. It may have been removed or is private.'));
-        } else {
+        }
+         else {
             console.error(chalk.red('An unexpected error occurred during the download process:'), error.message);
         }
         process.exit(1);
     }
-}
+}

package/src/prompts.js

@@ -71,8 +71,8 @@ export async function getQuality(format) {
     return answers.quality;
 }
 
-export async function getOutputPath(defaultFilename = 'download') {
-    const defaultPath = path.join(process.cwd(), sanitizeFilename(defaultFilename));
+export async function getOutputPath() { // Removed defaultFilename parameter
+    const defaultPath = process.cwd(); // Default to current working directory
 
     const questions = [
         {
@@ -90,5 +90,5 @@ export async function getOutputPath(defaultFilename = 'download') {
         },
     ];
     const answers = await inquirer.prompt(questions);
-    return answers.outputPath;
+    return answers.outputPath; // Returns just the directory path
 }