npmytd 1.0.0

package/README.md

@@ -0,0 +1,86 @@
+███╗   ██╗██████╗ ███╗   ███╗██╗   ██╗████████╗██████╗ 
+████╗  ██║██╔══██╗████╗ ████║╚██╗ ██╔╝╚══██╔══╝██╔══██╗
+██╔██╗ ██║██████╔╝██╔████╔██║ ╚████╔╝    ██║   ██║  ██║
+██║╚██╗██║██╔═══╝ ██║╚██╔╝██║  ╚██╔╝     ██║   ██║  ██║
+██║ ╚████║██║     ██║ ╚═╝ ██║   ██║      ██║   ██████╔╝
+╚═╝  ╚═══╝╚═╝     ╚═╝     ╚═╝   ╚═╝      ╚═╝   ╚═════╝ 
+                                                       
+
+A simple and interactive command-line interface (CLI) tool for downloading YouTube videos and audio (MP3 or MP4) in various qualities.
+
+## Features
+
+*   **Interactive Prompts**: Guides you through the download process.
+*   **MP4 Video Download**: Download videos in your desired quality.
+*   **MP3 Audio Download**: Extract and convert audio to MP3 format.
+*   **Quality Selection**: Choose between highest, medium, or lowest quality.
+*   **Progress Indicator**: See the download progress in real-time.
+*   **Output Path Customization**: Specify where to save your downloads.
+
+## Prerequisites
+
+Before installing and using `npmytd`, ensure you have the following installed on your system:
+
+*   **Node.js**: Version 18 or higher. You can download it from [nodejs.org](https://nodejs.org/).
+*   **ffmpeg**: Required for **MP3 audio conversion**. If you only plan to download MP4 videos, `ffmpeg` is not strictly necessary.
+    *   You can download `ffmpeg` from [ffmpeg.org/download.html](https://ffmpeg.org/download.html).
+    *   After downloading, make sure `ffmpeg` is added to your system's `PATH` environment variable so that `npmytd` can find it.
+
+## Installation
+
+To install `npmytd` globally, open your terminal or command prompt and run:
+
+```bash
+npm install -g npmytd
+```
+
+This will make the `npmytd` command available system-wide.
+
+## Usage
+
+To start a download, simply run the `npmytd` command in your terminal:
+
+```bash
+npmytd
+```
+
+The CLI will then guide you through a series of prompts:
+
+1.  **YouTube video URL or ID**: Enter the full URL of the YouTube video or just its video ID (e.g., `dQw4w9WgXcQ`).
+2.  **Output format**: Choose between `MP4 (Video)` or `MP3 (Audio)`.
+3.  **Desired quality**: Select `Highest`, `Medium`, or `Lowest` quality for your chosen format.
+4.  **Output directory**: Specify the path where you want to save the downloaded file. A default path (current working directory) with a sanitized video title will be suggested.
+
+### Example Walkthrough
+
+```
+$ npmytd
+
+Welcome to NPMYTD - YouTube Downloader CLI!
+
+? Enter YouTube video URL or ID: https://www.youtube.com/watch?v=dQw4w9WgXcQ
+? Select output format: MP4 (Video)
+? Select desired quality for MP4: Highest (Best available video quality)
+? Enter output directory (absolute or relative path): C:\Users\GraphStats\Desktop\MyDownloads\Never-Gonna-Give-You-Up-Official-Music-Video.mp4
+
+Downloading "Rick Astley - Never Gonna Give You Up (Official Music Video)" as MP4...
+[========================================] 100% | ETA: 0s | total: 4.8MB
+
+Download completed: C:\Users\GraphStats\Desktop\MyDownloads\Never-Gonna-Give-You-Up-Official-Music-Video.mp4
+
+Process completed successfully!
+```
+
+## Troubleshooting
+
+*   **`ffmpeg` not found for MP3 conversion**: If you selected MP3 format and encounter an error about `ffmpeg` not being found, please ensure `ffmpeg` is installed and properly added to your system's `PATH`.
+*   **Video Unavailable**: Some YouTube videos may be age-restricted, private, or have been removed. `npmytd` might not be able to download these.
+*   **`fluent-ffmpeg` deprecation warning**: You might see a warning during installation about `fluent-ffmpeg` being deprecated. While it currently functions, this might indicate future compatibility issues. We will monitor for stable alternatives if this becomes problematic.
+
+## License
+
+This project is licensed under the MIT License.
+
+## Author
+
+GraphStats

package/bin/npmytd.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import("../src/cli.js");

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "npmytd",
+  "version": "1.0.0",
+  "description": "A CLI tool to download YouTube videos or audio.",
+  "main": "src/cli.js",
+  "type": "module",
+  "bin": {
+    "npmytd": "bin/npmytd.js"
+  },
+  "scripts": {
+    "start": "node bin/npmytd.js"
+  },
+  "keywords": [
+    "youtube",
+    "downloader",
+    "cli",
+    "mp3",
+    "mp4"
+  ],
+  "author": "GraphStats",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "cli-progress": "^3.12.0",
+    "fluent-ffmpeg": "^2.1.3",
+    "inquirer": "^13.2.2",
+    "ytdl-core": "^4.11.5"
+  }
+}

package/src/cli.js

@@ -0,0 +1,40 @@
+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';
+
+async function main() {
+    console.log(chalk.bold.hex('#FF0000')('
+Welcome to NPMYTD - YouTube Downloader CLI!'));
+
+    try {
+        const url = await getYouTubeUrl();
+        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) {
+            console.error(chalk.red('Error fetching video information:', error.message));
+            process.exit(1);
+        }
+        const suggestedFilename = sanitizeFilename(videoInfo.videoDetails.title);
+
+        const outputPath = await getOutputPath(suggestedFilename);
+
+        await downloadYouTubeMedia(url, format, quality, outputPath);
+
+        console.log(chalk.bold.green('
+Process completed successfully!'));
+    } catch (error) {
+        console.error(chalk.red('
+An error occurred:'), error.message);
+        process.exit(1);
+    }
+}
+
+main();

package/src/downloader.js

@@ -0,0 +1,185 @@
+import ytdl from 'ytdl-core';
+import cliProgress from 'cli-progress';
+import path from 'path';
+import fs from 'fs';
+import ffmpeg from 'fluent-ffmpeg';
+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);
+
+        // Ensure the output directory exists
+        const dirExists = await ensureDirectoryExists(targetDirectory);
+        if (!dirExists) {
+            console.error(chalk.red('Failed to create output directory.'));
+            return;
+        }
+
+        let ytdlOptions = {
+            quality: 'highest', // Default to highest, then adjust based on user input
+        };
+
+        let outputExtension = '';
+
+        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';
+                    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
+                    }
+                    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
+                    }
+                    break;
+            }
+        } else if (format === 'mp3') {
+            outputExtension = '.mp3';
+            ytdlOptions.filter = 'audioonly';
+            switch (quality) {
+                case 'highest':
+                    ytdlOptions.quality = 'highestaudio';
+                    break;
+                case 'medium':
+                    ytdlOptions.quality = 'lowestaudio'; // ytdl-core often only has highest and lowest for audio, 'lowestaudio' is typically still good quality.
+                    break;
+                case 'lowest':
+                    ytdlOptions.quality = 'lowestaudio';
+                    break;
+            }
+        }
+
+        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}`));
+                    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);
+            });
+
+            audioStream.on('data', (chunk) => {
+                receivedBytes += chunk.length;
+                bar.update(receivedBytes);
+            });
+
+            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')) {
+            console.error(chalk.red('This video is unavailable. It may have been removed or is private.'));
+        } else {
+            console.error(chalk.red('An unexpected error occurred during the download process:'), error.message);
+        }
+        process.exit(1);
+    }
+}

package/src/prompts.js

@@ -0,0 +1,94 @@
+import inquirer from 'inquirer';
+import path from 'path';
+import { isValidYoutubeUrl, sanitizeFilename } from './utils.js';
+
+export async function getYouTubeUrl() {
+    const questions = [
+        {
+            type: 'input',
+            name: 'url',
+            message: 'Enter YouTube video URL or ID:',
+            validate: (input) => {
+                if (!input) {
+                    return 'YouTube URL or ID cannot be empty.';
+                }
+                // Basic validation, more robust validation can be added if needed
+                // For now, check if it contains "youtube.com" or "youtu.be" or is a potential ID
+                if (isValidYoutubeUrl(input) || input.length >= 5 && input.length <= 15) { // Assuming video IDs are usually 11 characters
+                    return true;
+                }
+                return 'Please enter a valid YouTube URL or video ID.';
+            },
+        },
+    ];
+    const answers = await inquirer.prompt(questions);
+    return answers.url;
+}
+
+export async function getOutputFormat() {
+    const questions = [
+        {
+            type: 'list',
+            name: 'format',
+            message: 'Select output format:',
+            choices: [
+                { name: 'MP4 (Video)', value: 'mp4' },
+                { name: 'MP3 (Audio)', value: 'mp3' },
+            ],
+            default: 'mp4',
+        },
+    ];
+    const answers = await inquirer.prompt(questions);
+    return answers.format;
+}
+
+export async function getQuality(format) {
+    let choices = [];
+    if (format === 'mp4') {
+        choices = [
+            { name: 'Highest (Best available video quality)', value: 'highest' },
+            { name: 'Medium (720p if available, fallback to 480p)', value: 'medium' },
+            { name: 'Lowest (Smallest video quality)', value: 'lowest' },
+        ];
+    } else { // mp3
+        choices = [
+            { name: 'Highest (Best available audio quality)', value: 'highest' },
+            { name: 'Medium (Standard audio quality)', value: 'medium' },
+            { name: 'Lowest (Smallest audio quality)', value: 'lowest' },
+        ];
+    }
+
+    const questions = [
+        {
+            type: 'list',
+            name: 'quality',
+            message: `Select desired quality for ${format.toUpperCase()}:`,
+            choices: choices,
+            default: 'highest',
+        },
+    ];
+    const answers = await inquirer.prompt(questions);
+    return answers.quality;
+}
+
+export async function getOutputPath(defaultFilename = 'download') {
+    const defaultPath = path.join(process.cwd(), sanitizeFilename(defaultFilename));
+
+    const questions = [
+        {
+            type: 'input',
+            name: 'outputPath',
+            message: 'Enter output directory (absolute or relative path):',
+            default: defaultPath,
+            validate: (input) => {
+                // Basic path validation, more robust checks (e.g., write permissions) will be done in utils
+                if (!input) {
+                    return 'Output path cannot be empty.';
+                }
+                return true;
+            },
+        },
+    ];
+    const answers = await inquirer.prompt(questions);
+    return answers.outputPath;
+}

package/src/utils.js

@@ -0,0 +1,39 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export function isValidYoutubeUrl(url) {
+    // Regex for YouTube URLs and IDs
+    // Matches youtube.com/watch?v=VIDEO_ID, youtu.be/VIDEO_ID, and plain VIDEO_ID
+    const youtubeRegex = /^(?:https?:\/\/)?(?:www\.)?(?:m\.)?(?:youtube\.com|youtu\.be)\/(?:watch\?v=|embed\/|v\/|)([\w-]{11})(?:\S+)?$/;
+    const match = url.match(youtubeRegex);
+    if (match) {
+        return match[1]; // Return the video ID
+    }
+    // If it's not a full URL, check if it's a valid YouTube video ID (11 characters, alphanumeric, hyphen, underscore)
+    const videoIdRegex = /^[\w-]{11}$/;
+    if (url.match(videoIdRegex)) {
+        return url; // It's a video ID
+    }
+    return null; // Not a valid URL or ID
+}
+
+export function sanitizeFilename(filename) {
+    // Remove invalid characters for filenames and replace spaces with hyphens
+    // Windows invalid characters: < > : " / \ | ? *
+    // Unix invalid characters: /
+    return filename
+        .replace(/[<>:"/\|?*\x00-\x1f]/g, '_') // Replace invalid characters with underscore
+        .replace(/\s/g, '-') // Replace spaces with hyphens
+        .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
+        .substring(0, 250); // Truncate to a reasonable length
+}
+
+export async function ensureDirectoryExists(dirPath) {
+    try {
+        await fs.mkdir(dirPath, { recursive: true });
+        return true;
+    } catch (error) {
+        console.error(`Error creating directory ${dirPath}:`, error.message);
+        return false;
+    }
+}