flux-dl 1.1.3 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flux-dl",
-  "version": "1.1.3",
+  "version": "1.1.6",
   "description": "Leistungsstarke Video-Downloader Library für YouTube, Vimeo und Dailymotion - komplett in JavaScript, keine externen Binaries",
   "main": "src/index.js",
   "scripts": {

package/src/VideoDownloader.js

@@ -5,6 +5,7 @@ const platforms = require('./platforms');
 const VideoEncryption = require('./utils/encryption');
 const RequestSpoofing = require('./utils/requestSpoofing');
 const BrowserEmulation = require('./utils/browserEmulation');
+const QualityManager = require('./utils/qualityManager');
 
 class VideoDownloader {
   constructor(options = {}) {
@@ -13,17 +14,24 @@ class VideoDownloader {
       timeout: 30000,
       encryptionKey: options.encryptionKey || 'default-key',
       cookiesFile: options.cookiesFile,
+      quality: options.quality || 192, // Standard: Medium (192 kbps)
       ...options
     };
     
     this.encryption = new VideoEncryption(this.options.encryptionKey);
     this.spoofing = new RequestSpoofing();
     this.browser = new BrowserEmulation();
+    this.qualityManager = new QualityManager();
     
     // Load cookies if provided
     if (this.options.cookiesFile) {
       this.browser.cookieManager.loadFromFile(this.options.cookiesFile);
     }
+
+    // Set default quality if provided
+    if (options.quality) {
+      this.qualityManager.setDefaultQuality(options.quality);
+    }
   }
 
   async getVideoInfo(url) {
@@ -158,8 +166,17 @@ class VideoDownloader {
     // Nutze Browser Emulation mit Cookies
     const referer = `https://www.youtube.com/watch?v=${info.videoId}`;
     
+    // Wrap onProgress to catch errors
+    const safeOnProgress = onProgress ? (percent, downloaded, total) => {
+      try {
+        onProgress(percent, downloaded, total);
+      } catch (error) {
+        // Silently ignore progress callback errors
+      }
+    } : null;
+    
     try {
-      const rawStream = await this.browser.downloadStream(info.videoUrl, referer, onProgress);
+      const rawStream = await this.browser.downloadStream(info.videoUrl, referer, safeOnProgress);
       
       // Create ULTRA-RESILIENT wrapper stream
       const { PassThrough } = require('stream');
@@ -347,6 +364,169 @@ class VideoDownloader {
   signUrl(url, expiresIn = 3600) {
     return this.encryption.signUrl(url, expiresIn);
   }
+
+  // ========== QUALITY MANAGEMENT API ==========
+
+  /**
+   * Setzt die Qualität für einen bestimmten User
+   * @param {string} userId - User ID
+   * @param {number} quality - Bitrate (120-360 kbps)
+   * @returns {number} Gesetzte Qualität
+   */
+  setUserQuality(userId, quality) {
+    return this.qualityManager.setUserQuality(userId, quality);
+  }
+
+  /**
+   * Gibt die erlaubte Qualität für einen User zurück
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {number} Erlaubte Bitrate
+   */
+  getUserQuality(userId, isPremium = false) {
+    return this.qualityManager.getUserQuality(userId, isPremium);
+  }
+
+  /**
+   * Setzt globale Standard-Qualität
+   * @param {number} quality - Bitrate (120-360 kbps)
+   */
+  setDefaultQuality(quality) {
+    this.qualityManager.setDefaultQuality(quality);
+    this.options.quality = quality;
+  }
+
+  /**
+   * Setzt maximale Qualität für Free Users
+   * @param {number} quality - Bitrate (120-360 kbps)
+   */
+  setMaxQualityForFreeUsers(quality) {
+    this.qualityManager.setMaxQualityForFreeUsers(quality);
+  }
+
+  /**
+   * Setzt maximale Qualität für Premium Users
+   * @param {number} quality - Bitrate (120-360 kbps)
+   */
+  setMaxQualityForPremiumUsers(quality) {
+    this.qualityManager.setMaxQualityForPremiumUsers(quality);
+  }
+
+  /**
+   * Gibt verfügbare Qualitätsstufen für User zurück
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {Array} Verfügbare Stufen
+   */
+  getAvailableQualities(userId, isPremium = false) {
+    return this.qualityManager.getAvailableQualities(userId, isPremium);
+  }
+
+  /**
+   * Prüft ob User bestimmte Qualität nutzen darf
+   * @param {string} userId - User ID
+   * @param {number} requestedQuality - Gewünschte Qualität
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {boolean} Erlaubt?
+   */
+  canUserUseQuality(userId, requestedQuality, isPremium = false) {
+    return this.qualityManager.canUserUseQuality(userId, requestedQuality, isPremium);
+  }
+
+  /**
+   * Download mit User-spezifischer Qualität
+   * @param {string} url - Video URL
+   * @param {string} outputPath - Output Pfad
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @param {function} onProgress - Progress Callback
+   * @returns {Promise<Object>} Download Result
+   */
+  async downloadAudioWithQuality(url, outputPath, userId, isPremium = false, onProgress = null) {
+    const userQuality = this.getUserQuality(userId, isPremium);
+    
+    console.log(`🎵 Downloading for user ${userId}`);
+    console.log(`📊 Quality: ${this.qualityManager.getQualityLabel(userQuality)}`);
+    
+    // Temporär Qualität setzen
+    const originalQuality = this.options.quality;
+    this.options.quality = userQuality;
+    
+    try {
+      const result = await this.downloadAudio(url, outputPath, onProgress);
+      return {
+        ...result,
+        quality: userQuality,
+        qualityLabel: this.qualityManager.getQualityLabel(userQuality)
+      };
+    } finally {
+      // Qualität zurücksetzen
+      this.options.quality = originalQuality;
+    }
+  }
+
+  /**
+   * Stream mit User-spezifischer Qualität
+   * @param {string} url - Video URL
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @param {function} onProgress - Progress Callback
+   * @returns {Promise<Object>} Stream Result
+   */
+  async getAudioStreamWithQuality(url, userId, isPremium = false, onProgress = null) {
+    const userQuality = this.getUserQuality(userId, isPremium);
+    
+    console.log(`🎵 Streaming for user ${userId}`);
+    console.log(`📊 Quality: ${this.qualityManager.getQualityLabel(userQuality)}`);
+    
+    // Temporär Qualität setzen
+    const originalQuality = this.options.quality;
+    this.options.quality = userQuality;
+    
+    try {
+      const result = await this.getAudioStream(url, onProgress);
+      return {
+        ...result,
+        quality: userQuality,
+        qualityLabel: this.qualityManager.getQualityLabel(userQuality)
+      };
+    } finally {
+      // Qualität zurücksetzen
+      this.options.quality = originalQuality;
+    }
+  }
+
+  /**
+   * Entfernt User-Permission
+   * @param {string} userId - User ID
+   */
+  removeUserQuality(userId) {
+    this.qualityManager.removeUserQuality(userId);
+  }
+
+  /**
+   * Gibt alle User-Permissions zurück
+   * @returns {Object} User-Permissions
+   */
+  getAllUserPermissions() {
+    return this.qualityManager.getAllUserPermissions();
+  }
+
+  /**
+   * Exportiert Quality-Konfiguration
+   * @returns {Object} Konfiguration
+   */
+  exportQualityConfig() {
+    return this.qualityManager.exportConfig();
+  }
+
+  /**
+   * Importiert Quality-Konfiguration
+   * @param {Object} config - Konfiguration
+   */
+  importQualityConfig(config) {
+    this.qualityManager.importConfig(config);
+  }
 }
 
 module.exports = VideoDownloader;

package/src/index.js

@@ -1,11 +1,13 @@
 const VideoDownloader = require('./VideoDownloader');
 const VideoEncryption = require('./utils/encryption');
 const YouTubeSearch = require('./utils/youtubeSearch');
+const QualityManager = require('./utils/qualityManager');
 const { supportedPlatforms } = require('./platforms');
 
 module.exports = {
   VideoDownloader,
   VideoEncryption,
   YouTubeSearch,
+  QualityManager,
   supportedPlatforms
 };

package/src/platforms/youtube.js

@@ -18,7 +18,7 @@ module.exports = {
         throw new Error('Invalid YouTube URL');
       }
 
-      console.log(`\n=== Extracting YouTube Video: ${videoId} ===`);
+      // console.log(`\n=== Extracting YouTube Video: ${videoId} ===`);
 
       // Starte Browser-Session (wie echter User)
       await this.browser.startSession();
@@ -26,9 +26,12 @@ module.exports = {
       // Methode 1: InnerTube API mit verschiedenen Clients
       const clientPriority = ['android', 'ios', 'tvEmbedded', 'web'];
       
+      // Get target quality from options
+      const targetQuality = options?.quality || null;
+      
       for (const clientType of clientPriority) {
         try {
-          console.log(`[InnerTube] Trying ${clientType} client...`);
+          // console.log(`[InnerTube] Trying ${clientType} client...`);
           const data = await this.innerTube.getVideoInfo(videoId, clientType);
 
           if (data.videoDetails && data.streamingData) {
@@ -41,7 +44,12 @@ module.exports = {
             if (formatsWithUrl.length > 0) {
               console.log(`✓ ${clientType} client success! ${formatsWithUrl.length} formats available`);
               
-              const bestFormat = this.selectBestFormat(formatsWithUrl);
+              // Select format with target quality
+              const bestFormat = this.selectBestFormat(formatsWithUrl, targetQuality);
+              
+              // Get actual bitrate for quality label
+              const actualBitrate = this.getBitrate(bestFormat);
+              const qualityLabel = `${actualBitrate}kbps`;
               
               // Get highest quality thumbnail (last one in array)
               const thumbnails = data.videoDetails.thumbnail.thumbnails;
@@ -58,7 +66,8 @@ module.exports = {
                 likeCount: parseInt(data.videoDetails.likeCount || 0),
                 uploadDate: data.videoDetails.uploadDate || data.videoDetails.publishDate || null,
                 videoUrl: bestFormat.url,
-                quality: bestFormat.qualityLabel || bestFormat.quality || 'unknown',
+                quality: qualityLabel,
+                bitrate: actualBitrate,
                 format: bestFormat,
                 allFormats: formatsWithUrl,
                 platform: this.name,
@@ -128,8 +137,14 @@ module.exports = {
         throw new Error('No valid formats found');
       }
 
-      const bestFormat = this.selectBestFormat(validFormats);
-      console.log(`Selected: ${bestFormat.qualityLabel || 'unknown'} quality\n`);
+      // Select format with target quality (already declared above)
+      const bestFormat = this.selectBestFormat(validFormats, targetQuality);
+      
+      // Get actual bitrate for quality label
+      const actualBitrate = this.getBitrate(bestFormat);
+      const qualityLabel = `${actualBitrate}kbps`;
+      
+      console.log(`Selected: ${qualityLabel} quality\n`);
 
       // Get highest quality thumbnail (last one in array)
       const thumbnails = videoDetails.thumbnail.thumbnails;
@@ -146,7 +161,8 @@ module.exports = {
         likeCount: parseInt(videoDetails.likeCount || 0),
         uploadDate: videoDetails.uploadDate || videoDetails.publishDate || null,
         videoUrl: bestFormat.url,
-        quality: bestFormat.qualityLabel || 'unknown',
+        quality: qualityLabel,
+        bitrate: actualBitrate,
         format: bestFormat,
         allFormats: validFormats,
         platform: this.name,
@@ -429,8 +445,35 @@ module.exports = {
     return res.data;
   },
 
-  selectBestFormat(formats) {
-    // Mit Audio + Video
+  selectBestFormat(formats, targetQuality = null) {
+    // Wenn targetQuality angegeben, nutze Audio-only Format mit passender Bitrate
+    if (targetQuality) {
+      const audioFormats = formats.filter(f => 
+        f.url && f.mimeType && f.mimeType.includes('audio')
+      );
+      
+      if (audioFormats.length > 0) {
+        // Sortiere nach Bitrate-Nähe zur Ziel-Qualität
+        audioFormats.sort((a, b) => {
+          const bitrateA = this.getBitrate(a);
+          const bitrateB = this.getBitrate(b);
+          return Math.abs(bitrateA - targetQuality) - Math.abs(bitrateB - targetQuality);
+        });
+        
+        // Finde Format das unter oder gleich der Ziel-Qualität ist
+        for (const format of audioFormats) {
+          const bitrate = this.getBitrate(format);
+          if (bitrate <= targetQuality) {
+            return format;
+          }
+        }
+        
+        // Fallback: Nehme das kleinste Format
+        return audioFormats[audioFormats.length - 1];
+      }
+    }
+
+    // Standard: Mit Audio + Video
     const withBoth = formats.filter(f => 
       f.url && f.mimeType && f.mimeType.includes('video') && f.audioQuality
     );
@@ -451,6 +494,31 @@ module.exports = {
     return formats[0];
   },
 
+  getBitrate(format) {
+    if (format.bitrate) {
+      return Math.round(format.bitrate / 1000); // Bits zu kbps
+    }
+    
+    if (format.audioBitrate) {
+      return format.audioBitrate;
+    }
+
+    if (format.averageBitrate) {
+      return Math.round(format.averageBitrate / 1000);
+    }
+
+    // Fallback: Schätze aus Quality-Label
+    if (format.qualityLabel) {
+      const match = format.qualityLabel.match(/(\d+)kbps/i);
+      if (match) {
+        return parseInt(match[1]);
+      }
+    }
+
+    // Default: Mittel
+    return 192;
+  },
+
   extractVideoId(url) {
     let m = url.match(/[?&]v=([^&]+)/);
     if (m) return m[1];

package/src/utils/browserEmulation.js

@@ -280,8 +280,7 @@ class BrowserEmulation {
                 onProgress(percent, downloadedLength, totalLength);
               }
             } catch (err) {
-              // Even progress callback errors won't crash us
-              console.warn('⚠️ Progress callback error (handled)');
+              // Silently ignore progress callback errors
             }
           });
         }

package/src/utils/qualityManager.js

@@ -0,0 +1,270 @@
+/**
+ * QUALITY MANAGER - Audio Bitrate Control System
+ * Verwaltet Audio-Qualität mit User-Permissions (120-360 kbps)
+ */
+
+class QualityManager {
+  constructor() {
+    // Qualitätsstufen (in kbps für Audio)
+    this.QUALITY_LEVELS = {
+      MINIMUM: 120,    // Niedrigste Qualität
+      LOW: 128,        // Niedrig
+      MEDIUM: 192,     // Mittel (Standard)
+      HIGH: 256,       // Hoch
+      MAXIMUM: 360     // Höchste Qualität
+    };
+
+    // User-Permissions (wer darf welche Qualität nutzen)
+    this.userPermissions = new Map();
+    
+    // Globale Einstellungen
+    this.defaultQuality = this.QUALITY_LEVELS.MEDIUM;
+    this.maxQualityForFreeUsers = this.QUALITY_LEVELS.MEDIUM;
+    this.maxQualityForPremiumUsers = this.QUALITY_LEVELS.MAXIMUM;
+  }
+
+  /**
+   * Setzt die erlaubte Qualität für einen User
+   * @param {string} userId - User ID
+   * @param {number} maxQuality - Maximale Bitrate (120-360)
+   */
+  setUserQuality(userId, maxQuality) {
+    const quality = this.validateQuality(maxQuality);
+    this.userPermissions.set(userId, quality);
+    return quality;
+  }
+
+  /**
+   * Gibt die erlaubte Qualität für einen User zurück
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist der User Premium?
+   * @returns {number} Erlaubte Bitrate
+   */
+  getUserQuality(userId, isPremium = false) {
+    // Wenn User spezifische Permission hat
+    if (this.userPermissions.has(userId)) {
+      return this.userPermissions.get(userId);
+    }
+
+    // Sonst nach Premium-Status
+    return isPremium ? this.maxQualityForPremiumUsers : this.maxQualityForFreeUsers;
+  }
+
+  /**
+   * Validiert und begrenzt Qualitätswert
+   * @param {number} quality - Gewünschte Bitrate
+   * @returns {number} Validierte Bitrate (120-360)
+   */
+  validateQuality(quality) {
+    const q = parseInt(quality);
+    
+    if (isNaN(q)) {
+      return this.defaultQuality;
+    }
+
+    // Begrenze auf Min/Max
+    if (q < this.QUALITY_LEVELS.MINIMUM) {
+      return this.QUALITY_LEVELS.MINIMUM;
+    }
+    
+    if (q > this.QUALITY_LEVELS.MAXIMUM) {
+      return this.QUALITY_LEVELS.MAXIMUM;
+    }
+
+    return q;
+  }
+
+  /**
+   * Wählt das beste Audio-Format basierend auf Qualitätseinstellung
+   * @param {Array} formats - Verfügbare Formate
+   * @param {number} targetQuality - Ziel-Bitrate
+   * @returns {Object} Bestes Format
+   */
+  selectBestAudioFormat(formats, targetQuality) {
+    // 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
+    audioFormats.sort((a, b) => {
+      const bitrateA = this.getBitrate(a);
+      const bitrateB = this.getBitrate(b);
+      return Math.abs(bitrateA - targetQuality) - Math.abs(bitrateB - targetQuality);
+    });
+
+    // Finde Format das am nächsten zur Ziel-Qualität ist
+    let bestFormat = audioFormats[0];
+    
+    for (const format of audioFormats) {
+      const bitrate = this.getBitrate(format);
+      
+      // Wenn Format unter Ziel-Qualität liegt, nehme es
+      if (bitrate <= targetQuality && bitrate > this.getBitrate(bestFormat)) {
+        bestFormat = format;
+      }
+    }
+
+    return bestFormat;
+  }
+
+  /**
+   * Extrahiert Bitrate aus Format
+   * @param {Object} format - Format-Objekt
+   * @returns {number} Bitrate in kbps
+   */
+  getBitrate(format) {
+    if (format.bitrate) {
+      return Math.round(format.bitrate / 1000); // Bits zu kbps
+    }
+    
+    if (format.audioBitrate) {
+      return format.audioBitrate;
+    }
+
+    // Fallback: Schätze aus Quality-Label
+    if (format.qualityLabel) {
+      const match = format.qualityLabel.match(/(\d+)kbps/i);
+      if (match) {
+        return parseInt(match[1]);
+      }
+    }
+
+    // Default: Mittel
+    return this.QUALITY_LEVELS.MEDIUM;
+  }
+
+  /**
+   * Gibt Qualitäts-Label zurück
+   * @param {number} bitrate - Bitrate in kbps
+   * @returns {string} Label
+   */
+  getQualityLabel(bitrate) {
+    if (bitrate >= this.QUALITY_LEVELS.MAXIMUM) return '🔥 Maximum (360 kbps)';
+    if (bitrate >= this.QUALITY_LEVELS.HIGH) return '⭐ High (256 kbps)';
+    if (bitrate >= this.QUALITY_LEVELS.MEDIUM) return '✅ Medium (192 kbps)';
+    if (bitrate >= this.QUALITY_LEVELS.LOW) return '📊 Low (128 kbps)';
+    return '💾 Minimum (120 kbps)';
+  }
+
+  /**
+   * Setzt globale Standard-Qualität
+   * @param {number} quality - Bitrate (120-360)
+   */
+  setDefaultQuality(quality) {
+    this.defaultQuality = this.validateQuality(quality);
+  }
+
+  /**
+   * Setzt maximale Qualität für Free Users
+   * @param {number} quality - Bitrate (120-360)
+   */
+  setMaxQualityForFreeUsers(quality) {
+    this.maxQualityForFreeUsers = this.validateQuality(quality);
+  }
+
+  /**
+   * Setzt maximale Qualität für Premium Users
+   * @param {number} quality - Bitrate (120-360)
+   */
+  setMaxQualityForPremiumUsers(quality) {
+    this.maxQualityForPremiumUsers = this.validateQuality(quality);
+  }
+
+  /**
+   * Entfernt User-Permission
+   * @param {string} userId - User ID
+   */
+  removeUserQuality(userId) {
+    this.userPermissions.delete(userId);
+  }
+
+  /**
+   * Gibt alle User-Permissions zurück
+   * @returns {Object} User-Permissions
+   */
+  getAllUserPermissions() {
+    const permissions = {};
+    for (const [userId, quality] of this.userPermissions.entries()) {
+      permissions[userId] = {
+        quality,
+        label: this.getQualityLabel(quality)
+      };
+    }
+    return permissions;
+  }
+
+  /**
+   * Prüft ob User bestimmte Qualität nutzen darf
+   * @param {string} userId - User ID
+   * @param {number} requestedQuality - Gewünschte Qualität
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {boolean} Erlaubt?
+   */
+  canUserUseQuality(userId, requestedQuality, isPremium = false) {
+    const maxAllowed = this.getUserQuality(userId, isPremium);
+    return requestedQuality <= maxAllowed;
+  }
+
+  /**
+   * Gibt verfügbare Qualitätsstufen für User zurück
+   * @param {string} userId - User ID
+   * @param {boolean} isPremium - Ist Premium User?
+   * @returns {Array} Verfügbare Stufen
+   */
+  getAvailableQualities(userId, isPremium = false) {
+    const maxQuality = this.getUserQuality(userId, isPremium);
+    const available = [];
+
+    for (const [name, value] of Object.entries(this.QUALITY_LEVELS)) {
+      if (value <= maxQuality) {
+        available.push({
+          name,
+          value,
+          label: this.getQualityLabel(value)
+        });
+      }
+    }
+
+    return available;
+  }
+
+  /**
+   * Exportiert Konfiguration
+   * @returns {Object} Konfiguration
+   */
+  exportConfig() {
+    return {
+      defaultQuality: this.defaultQuality,
+      maxQualityForFreeUsers: this.maxQualityForFreeUsers,
+      maxQualityForPremiumUsers: this.maxQualityForPremiumUsers,
+      userPermissions: Object.fromEntries(this.userPermissions)
+    };
+  }
+
+  /**
+   * Importiert Konfiguration
+   * @param {Object} config - Konfiguration
+   */
+  importConfig(config) {
+    if (config.defaultQuality) {
+      this.defaultQuality = this.validateQuality(config.defaultQuality);
+    }
+    
+    if (config.maxQualityForFreeUsers) {
+      this.maxQualityForFreeUsers = this.validateQuality(config.maxQualityForFreeUsers);
+    }
+    
+    if (config.maxQualityForPremiumUsers) {
+      this.maxQualityForPremiumUsers = this.validateQuality(config.maxQualityForPremiumUsers);
+    }
+    
+    if (config.userPermissions) {
+      this.userPermissions = new Map(Object.entries(config.userPermissions));
+    }
+  }
+}
+
+module.exports = QualityManager;