flux-dl 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 flux-dl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,454 @@
+# flux-dl
+
+Eine leistungsstarke Node.js Library zum Downloaden von Videos von YouTube, Vimeo und Dailymotion - komplett in JavaScript, keine externen Binaries!
+
+## Installation
+
+```bash
+npm install flux-dl
+```
+
+## Features
+
+✅ YouTube Videos & Audio downloaden (ohne yt-dlp!)  
+✅ YouTube Suche - Song-Namen eingeben statt URLs!  
+✅ Vimeo Videos downloaden  
+✅ Dailymotion Videos downloaden  
+✅ Automatische Format-Auswahl  
+✅ Progress-Tracking  
+✅ Cookie-Support für authentifizierte Videos  
+✅ Perfekt für Bots (WhatsApp, Discord, Telegram)  
+✅ Komplett in JavaScript - keine externen Binaries  
+
+## API Dokumentation
+
+### YouTubeSearch
+
+Suche nach Videos ohne URL - perfekt für Bots!
+
+#### Constructor
+
+```javascript
+const { YouTubeSearch } = require('flux-dl');
+
+const search = new YouTubeSearch();
+```
+
+#### Methoden
+
+##### `search(query, maxResults)`
+
+Sucht nach Videos auf YouTube.
+
+```javascript
+const results = await search.search('Rick Astley Never Gonna Give You Up', 5);
+
+results.forEach(video => {
+  console.log(video.title);
+  console.log(video.url);
+  console.log(video.author);
+});
+```
+
+**Response:**
+```javascript
+[
+  {
+    videoId: "dQw4w9WgXcQ",
+    title: "Rick Astley - Never Gonna Give You Up",
+    url: "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+    thumbnail: "https://...",
+    duration: 213,
+    author: "Rick Astley",
+    views: "1.7B views",
+    publishedTime: "15 years ago"
+  }
+]
+```
+
+##### `searchAndDownload(query, downloader, options)`
+
+Sucht und lädt direkt das erste Ergebnis herunter.
+
+```javascript
+const { VideoDownloader, YouTubeSearch } = require('flux-dl');
+
+const downloader = new VideoDownloader();
+const search = new YouTubeSearch();
+
+const result = await search.searchAndDownload(
+  'Rick Astley Never Gonna Give You Up',
+  downloader,
+  { 
+    audioOnly: true,
+    outputPath: './downloads'
+  }
+);
+
+console.log(result.filepath);
+```
+
+### VideoDownloader
+
+Die Hauptklasse für Video-Downloads.
+
+#### Constructor
+
+```javascript
+const { VideoDownloader } = require('flux-dl');
+
+const downloader = new VideoDownloader({
+  userAgent: 'Mozilla/5.0 ...', // Optional
+  timeout: 30000,                // Optional
+  encryptionKey: 'your-key'      // Optional
+});
+```
+
+#### Methoden
+
+##### `getVideoInfo(url)`
+
+Extrahiert Video-Informationen ohne Download.
+
+```javascript
+const info = await downloader.getVideoInfo('https://youtube.com/watch?v=...');
+
+console.log(info.title);        // Video-Titel
+console.log(info.author);       // Autor/Kanal
+console.log(info.duration);     // Dauer in Sekunden
+console.log(info.quality);      // Qualität (z.B. "1080p")
+console.log(info.videoUrl);     // Download-URL
+console.log(info.allFormats);   // Alle verfügbaren Formate
+```
+
+**Response:**
+```javascript
+{
+  title: "Video Titel",
+  videoId: "dQw4w9WgXcQ",
+  duration: 213,
+  thumbnail: "https://...",
+  author: "Kanal Name",
+  viewCount: 1742252685,
+  videoUrl: "https://...",
+  quality: "360p",
+  format: { /* Format-Details */ },
+  allFormats: [ /* Array aller Formate */ ],
+  platform: "YouTube"
+}
+```
+
+##### `download(url, outputPath)`
+
+Lädt ein Video herunter.
+
+```javascript
+const result = await downloader.download(
+  'https://youtube.com/watch?v=...',
+  './downloads'  // Optional, default: './downloads'
+);
+
+console.log(result.filepath);  // Pfad zur heruntergeladenen Datei
+console.log(result.info);      // Video-Informationen
+```
+
+**Response:**
+```javascript
+{
+  filepath: "./downloads/video_titel.mp3",
+  info: { /* Video-Info Objekt */ }
+}
+```
+
+##### `downloadAudio(url, outputPath)`
+
+Lädt nur die Audio-Spur herunter.
+
+```javascript
+const result = await downloader.downloadAudio(
+  'https://youtube.com/watch?v=...',
+  './downloads'
+);
+
+console.log(result.filepath);  // Pfad zur Audio-Datei
+console.log(result.format);    // Audio-Format Details
+```
+
+## Beispiele
+
+### YouTube Suche (NEU!)
+
+```javascript
+const { VideoDownloader, YouTubeSearch } = require('flux-dl');
+
+async function searchAndDownload() {
+  const downloader = new VideoDownloader();
+  const search = new YouTubeSearch();
+  
+  // Suche nach Song-Name
+  const results = await search.search('Rick Astley', 3);
+  
+  console.log('Gefundene Videos:');
+  results.forEach((video, i) => {
+    console.log(`${i + 1}. ${video.title} - ${video.author}`);
+  });
+  
+  // Direkt suchen und downloaden
+  const result = await search.searchAndDownload(
+    'Rick Astley Never Gonna Give You Up',
+    downloader,
+    { audioOnly: true }
+  );
+  
+  console.log('✓ Downloaded:', result.filepath);
+}
+
+searchAndDownload();
+```
+
+### Einfacher Download
+
+```javascript
+const { VideoDownloader } = require('flux-dl');
+
+async function downloadVideo() {
+  const downloader = new VideoDownloader();
+  
+  try {
+    const result = await downloader.download(
+      'https://youtube.com/watch?v=dQw4w9WgXcQ'
+    );
+    console.log('✓ Video gespeichert:', result.filepath);
+  } catch (error) {
+    console.error('Fehler:', error.message);
+  }
+}
+
+downloadVideo();
+```
+
+### Video-Info abrufen
+
+```javascript
+const { VideoDownloader } = require('flux-dl');
+
+async function getInfo() {
+  const downloader = new VideoDownloader();
+  
+  const info = await downloader.getVideoInfo(
+    'https://youtube.com/watch?v=dQw4w9WgXcQ'
+  );
+  
+  console.log(`Titel: ${info.title}`);
+  console.log(`Autor: ${info.author}`);
+  console.log(`Dauer: ${info.duration}s`);
+  console.log(`Qualität: ${info.quality}`);
+  console.log(`Verfügbare Formate: ${info.allFormats.length}`);
+}
+
+getInfo();
+```
+
+### Nur Audio downloaden
+
+```javascript
+const { VideoDownloader } = require('flux-dl');
+
+async function downloadAudio() {
+  const downloader = new VideoDownloader();
+  
+  const result = await downloader.downloadAudio(
+    'https://youtube.com/watch?v=dQw4w9WgXcQ',
+    './music'
+  );
+  
+  console.log('✓ Audio gespeichert:', result.filepath);
+}
+
+downloadAudio();
+```
+
+### Mit Progress-Tracking
+
+```javascript
+const { VideoDownloader } = require('flux-dl');
+
+async function downloadWithProgress() {
+  const downloader = new VideoDownloader();
+  
+  // Info abrufen
+  const info = await downloader.getVideoInfo(
+    'https://youtube.com/watch?v=dQw4w9WgXcQ'
+  );
+  
+  console.log(`Starte Download: ${info.title}`);
+  
+  // Download mit Progress
+  const result = await downloader.download(info.videoUrl);
+  
+  console.log('✓ Fertig!');
+}
+
+downloadWithProgress();
+```
+
+### Mehrere Videos downloaden
+
+```javascript
+const { VideoDownloader } = require('flux-dl');
+
+async function downloadMultiple() {
+  const downloader = new VideoDownloader();
+  
+  const urls = [
+    'https://youtube.com/watch?v=...',
+    'https://vimeo.com/...',
+    'https://dailymotion.com/video/...'
+  ];
+  
+  for (const url of urls) {
+    try {
+      const result = await downloader.download(url);
+      console.log('✓', result.info.title);
+    } catch (error) {
+      console.error('✗', url, error.message);
+    }
+  }
+}
+
+downloadMultiple();
+```
+
+### Für WhatsApp/Discord Bots
+
+```javascript
+const { VideoDownloader, YouTubeSearch } = require('flux-dl');
+
+// WhatsApp Bot Beispiel
+bot.on('message', async (msg) => {
+  if (msg.body.startsWith('!song ')) {
+    const songName = msg.body.replace('!song ', '');
+    
+    const downloader = new VideoDownloader();
+    const search = new YouTubeSearch();
+    
+    try {
+      msg.reply('🔍 Suche...');
+      
+      const result = await search.searchAndDownload(
+        songName,
+        downloader,
+        { audioOnly: true }
+      );
+      
+      msg.reply('✓ Fertig!');
+      await bot.sendFile(msg.from, result.filepath);
+    } catch (error) {
+      msg.reply('❌ Fehler: ' + error.message);
+    }
+  }
+});
+```
+
+### Spezifisches Format wählen
+
+```javascript
+const { VideoDownloader } = require('flux-dl');
+
+async function downloadSpecificFormat() {
+  const downloader = new VideoDownloader();
+  
+  // Alle Formate abrufen
+  const info = await downloader.getVideoInfo(
+    'https://youtube.com/watch?v=dQw4w9WgXcQ'
+  );
+  
+  // Bestes 1080p Format finden
+  const format1080p = info.allFormats.find(f => 
+    f.qualityLabel === '1080p' && f.mimeType.includes('video')
+  );
+  
+  if (format1080p) {
+    // Direkt mit Format-URL downloaden
+    const fs = require('fs');
+    const stream = await downloader.spoofing.downloadStream(
+      format1080p.url,
+      `https://youtube.com/watch?v=${info.videoId}`,
+      (percent) => console.log(`Progress: ${percent}%`)
+    );
+    
+    const writer = fs.createWriteStream('./video_1080p.mp4');
+    stream.pipe(writer);
+    
+    await new Promise((resolve, reject) => {
+      writer.on('finish', resolve);
+      writer.on('error', reject);
+    });
+  }
+}
+
+downloadSpecificFormat();
+```
+
+## Unterstützte Plattformen
+
+```javascript
+const { supportedPlatforms } = require('flux-dl');
+
+console.log(supportedPlatforms);
+// ['YouTube', 'Vimeo', 'Dailymotion']
+```
+
+## Cookie-Support
+
+Für Videos die Authentifizierung benötigen, kannst du eine `cookies.txt` Datei im Netscape-Format verwenden:
+
+1. Exportiere Cookies mit Browser-Extension (z.B. "Get cookies.txt")
+2. Speichere als `cookies.txt` im Projekt-Root
+3. Die Library lädt sie automatisch
+
+## Error Handling
+
+```javascript
+const { VideoDownloader } = require('flux-dl');
+
+async function safeDownload(url) {
+  const downloader = new VideoDownloader();
+  
+  try {
+    const result = await downloader.download(url);
+    return { success: true, filepath: result.filepath };
+  } catch (error) {
+    if (error.message.includes('403')) {
+      return { success: false, error: 'Video nicht verfügbar oder geschützt' };
+    } else if (error.message.includes('Platform not supported')) {
+      return { success: false, error: 'Plattform nicht unterstützt' };
+    } else {
+      return { success: false, error: error.message };
+    }
+  }
+}
+```
+
+## Technische Details
+
+- **Keine externen Binaries**: Komplett in JavaScript implementiert
+- **YouTube InnerTube API**: Nutzt die offizielle (undokumentierte) API
+- **Signatur-Entschlüsselung**: Automatische Entschlüsselung von geschützten URLs
+- **Browser-Emulation**: Simuliert echte Browser-Requests
+- **Multi-Platform**: Unterstützt YouTube, Vimeo und Dailymotion
+
+## Dependencies
+
+- `axios` - HTTP-Requests
+- `cheerio` - HTML-Parsing (für Vimeo/Dailymotion)
+- `m3u8-parser` - HLS-Stream-Parsing
+
+## Lizenz
+
+MIT
+
+## Support
+
+Bei Problemen oder Fragen, erstelle ein Issue auf GitHub.
+

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "flux-dl",
+  "version": "1.0.0",
+  "description": "Leistungsstarke Video-Downloader Library für YouTube, Vimeo und Dailymotion - komplett in JavaScript, keine externen Binaries",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node examples/test.js",
+    "test-encryption": "node examples/encryption-test.js",
+    "test-platforms": "node examples/test-platforms.js"
+  },
+  "keywords": [
+    "video",
+    "download",
+    "youtube",
+    "vimeo",
+    "dailymotion",
+    "streaming",
+    "downloader",
+    "video-downloader",
+    "youtube-downloader",
+    "youtube-dl",
+    "yt-dlp",
+    "no-binary",
+    "flux",
+    "flux-dl"
+  ],
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/flux-dl.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/flux-dl/issues"
+  },
+  "homepage": "https://github.com/yourusername/flux-dl#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "cheerio": "^1.0.0-rc.12",
+    "m3u8-parser": "^7.1.0"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/VideoDownloader.js

@@ -0,0 +1,197 @@
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const platforms = require('./platforms');
+const VideoEncryption = require('./utils/encryption');
+const RequestSpoofing = require('./utils/requestSpoofing');
+
+class VideoDownloader {
+  constructor(options = {}) {
+    this.options = {
+      userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      timeout: 30000,
+      encryptionKey: options.encryptionKey || 'default-key',
+      ...options
+    };
+    
+    this.encryption = new VideoEncryption(this.options.encryptionKey);
+    this.spoofing = new RequestSpoofing();
+  }
+
+  async getVideoInfo(url) {
+    const platform = this.detectPlatform(url);
+    
+    if (!platform) {
+      throw new Error('Platform not supported');
+    }
+
+    return await platform.extractInfo(url, this.options);
+  }
+
+  async download(url, outputPath = './downloads') {
+    const info = await this.getVideoInfo(url);
+    
+    if (!fs.existsSync(outputPath)) {
+      fs.mkdirSync(outputPath, { recursive: true });
+    }
+
+    const filename = this.sanitizeFilename(info.title) + '.mp3'; // Geändert zu .mp3
+    const filepath = path.join(outputPath, filename);
+
+    console.log(`Downloading: ${info.title}`);
+    console.log(`Quality: ${info.quality}`);
+    
+    // Nutze Browser Emulation für Download
+    const platform = this.detectPlatform(url);
+    const referer = info.videoId ? `https://www.youtube.com/watch?v=${info.videoId}` : null;
+    const writer = fs.createWriteStream(filepath);
+    
+    // Für YouTube: Nutze browser statt spoofing
+    const downloader = platform && platform.browser ? platform.browser : this.spoofing;
+    
+    const stream = await downloader.downloadStream(info.videoUrl, referer, (percent, downloaded, total) => {
+      if (total) {
+        process.stdout.write(`\rProgress: ${percent}% (${Math.round(downloaded / 1024 / 1024)}MB / ${Math.round(total / 1024 / 1024)}MB)`);
+      } else {
+        process.stdout.write(`\rProgress: ${percent}%`);
+      }
+    });
+    
+    stream.pipe(writer);
+    
+    await new Promise((resolve, reject) => {
+      writer.on('finish', resolve);
+      writer.on('error', reject);
+    });
+    
+    console.log('\n');
+    
+    return { filepath, info };
+  }
+
+  async downloadAudio(url, outputPath = './downloads') {
+    const info = await this.getVideoInfo(url);
+    
+    // Audio-Format auswählen
+    const audioFormat = this.selectAudioFormat(info.allFormats);
+    
+    if (!audioFormat) {
+      throw new Error('No audio format available');
+    }
+
+    if (!fs.existsSync(outputPath)) {
+      fs.mkdirSync(outputPath, { recursive: true });
+    }
+
+    const ext = audioFormat.mimeType.includes('mp4') ? '.m4a' : '.webm';
+    const filename = this.sanitizeFilename(info.title) + ext;
+    const filepath = path.join(outputPath, filename);
+
+    console.log(`Downloading audio: ${info.title}`);
+    console.log(`Format: ${audioFormat.mimeType}`);
+    
+    // Nutze Request Spoofing
+    const referer = `https://www.youtube.com/watch?v=${info.videoId}`;
+    const writer = fs.createWriteStream(filepath);
+    
+    const stream = await this.spoofing.downloadStream(audioFormat.url, referer, (percent) => {
+      process.stdout.write(`\rProgress: ${percent}%`);
+    });
+    
+    stream.pipe(writer);
+    
+    await new Promise((resolve, reject) => {
+      writer.on('finish', resolve);
+      writer.on('error', reject);
+    });
+    
+    console.log('\n');
+    
+    return { filepath, info, format: audioFormat };
+  }
+
+  selectAudioFormat(formats) {
+    // Nutze InnerTube Helper falls verfügbar
+    if (this.detectPlatform && formats.length > 0) {
+      const platform = this.detectPlatform(formats[0].url || '');
+      if (platform && platform.innerTube) {
+        return platform.innerTube.selectBestAudio(formats);
+      }
+    }
+
+    // Nur Audio-Formate
+    const audioFormats = formats.filter(f => 
+      f.mimeType && f.mimeType.includes('audio') && f.url
+    );
+
+    if (audioFormats.length === 0) return null;
+
+    // Sortiere nach Bitrate (höher = besser)
+    audioFormats.sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0));
+    
+    return audioFormats[0];
+  }
+
+  async downloadStream(url, filepath, onProgress) {
+    // Prüfe ob URL verschlüsselt ist
+    if (url.startsWith('encrypted://')) {
+      url = this.encryption.decryptUrl(url);
+    }
+    
+    const writer = fs.createWriteStream(filepath);
+    
+    const response = await axios({
+      url,
+      method: 'GET',
+      responseType: 'stream',
+      headers: {
+        'User-Agent': this.options.userAgent
+      },
+      httpsAgent: new (require('https').Agent)({
+        rejectUnauthorized: false
+      })
+    });
+
+    const totalLength = response.headers['content-length'];
+    let downloadedLength = 0;
+
+    response.data.on('data', (chunk) => {
+      downloadedLength += chunk.length;
+      if (onProgress && totalLength) {
+        const percent = Math.round((downloadedLength / totalLength) * 100);
+        onProgress(percent);
+      }
+    });
+
+    response.data.pipe(writer);
+
+    return new Promise((resolve, reject) => {
+      writer.on('finish', resolve);
+      writer.on('error', reject);
+    });
+  }
+
+  detectPlatform(url) {
+    for (const [name, platform] of Object.entries(platforms)) {
+      if (platform.canHandle(url)) {
+        return platform;
+      }
+    }
+    return null;
+  }
+
+  sanitizeFilename(filename) {
+    return filename.replace(/[^a-z0-9]/gi, '_').toLowerCase();
+  }
+
+  // Verschlüsselungs-Utilities exportieren
+  encryptUrl(url, expiresIn = 3600) {
+    return this.encryption.encryptUrl(url, expiresIn);
+  }
+
+  signUrl(url, expiresIn = 3600) {
+    return this.encryption.signUrl(url, expiresIn);
+  }
+}
+
+module.exports = VideoDownloader;