flux-dl 1.0.0

package/src/utils/youtubeInnerTube.js

@@ -0,0 +1,201 @@
+const axios = require('axios');
+
+class YouTubeInnerTube {
+  constructor() {
+    // Verschiedene Client-Konfigurationen zum Testen
+    this.clients = {
+      // Android Client - BESTE Option, keine N-Parameter!
+      android: {
+        clientName: 'ANDROID',
+        clientVersion: '19.09.37',
+        androidSdkVersion: 34,
+        apiKey: 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w'
+      },
+      // iOS Client
+      ios: {
+        clientName: 'IOS',
+        clientVersion: '19.09.3',
+        deviceModel: 'iPhone16,2',
+        apiKey: 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc'
+      },
+      // Web Client
+      web: {
+        clientName: 'WEB',
+        clientVersion: '2.20240304.00.00',
+        apiKey: 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+      },
+      // TV Embedded - oft weniger geschützt
+      tvEmbedded: {
+        clientName: 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
+        clientVersion: '2.0',
+        apiKey: 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8'
+      }
+    };
+    
+    this.currentClient = 'android'; // Android als Standard
+  }
+
+  getContext(clientType = this.currentClient) {
+    const client = this.clients[clientType];
+    
+    const context = {
+      client: {
+        clientName: client.clientName,
+        clientVersion: client.clientVersion,
+        hl: 'en',
+        gl: 'US'
+      }
+    };
+
+    if (client.androidSdkVersion) {
+      context.client.androidSdkVersion = client.androidSdkVersion;
+      context.client.osName = 'Android';
+      context.client.osVersion = '14';
+      context.client.platform = 'MOBILE';
+    }
+
+    if (client.deviceModel) {
+      context.client.deviceModel = client.deviceModel;
+      context.client.platform = 'MOBILE';
+    }
+
+    // Für TV/Embedded Clients
+    if (clientType === 'tvEmbedded') {
+      context.thirdParty = {
+        embedUrl: 'https://www.youtube.com/'
+      };
+    }
+
+    return context;
+  }
+
+  async getVideoInfo(videoId, clientType = this.currentClient) {
+    const client = this.clients[clientType];
+    const url = `https://www.youtube.com/youtubei/v1/player?key=${client.apiKey}&prettyPrint=false`;
+    
+    const payload = {
+      videoId: videoId,
+      context: this.getContext(clientType),
+      playbackContext: {
+        contentPlaybackContext: {
+          html5Preference: 'HTML5_PREF_WANTS',
+          signatureTimestamp: Math.floor(Date.now() / 1000)
+        }
+      },
+      contentCheckOk: true,
+      racyCheckOk: true
+    };
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'User-Agent': this.getUserAgent(clientType),
+      'Accept': '*/*',
+      'Accept-Language': 'en-US,en;q=0.9',
+      'Origin': 'https://www.youtube.com',
+      'Referer': 'https://www.youtube.com/'
+    };
+
+    if (clientType === 'android' || clientType === 'androidTv') {
+      headers['X-YouTube-Client-Name'] = '3';
+      headers['X-YouTube-Client-Version'] = client.clientVersion;
+    }
+
+    try {
+      const response = await axios.post(url, payload, {
+        headers: headers,
+        httpsAgent: new (require('https').Agent)({
+          rejectUnauthorized: false
+        })
+      });
+
+      return response.data;
+    } catch (error) {
+      // Versuche andere Clients in dieser Reihenfolge
+      if (clientType === this.currentClient) {
+        const alternatives = ['tv', 'webEmbedded', 'androidTv', 'ios', 'android', 'web'];
+        
+        for (const alt of alternatives) {
+          if (alt === clientType) continue;
+          
+          try {
+            console.log(`Trying ${alt} client...`);
+            return await this.getVideoInfo(videoId, alt);
+          } catch (e) {
+            continue;
+          }
+        }
+      }
+      
+      throw new Error(`All InnerTube clients failed: ${error.message}`);
+    }
+  }
+
+  getUserAgent(clientType) {
+    const agents = {
+      web: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+      android: 'com.google.android.youtube/19.09.37 (Linux; U; Android 14; en_US) gzip',
+      ios: 'com.google.ios.youtube/19.09.3 (iPhone16,2; U; CPU iOS 17_4 like Mac OS X; en_US)',
+      tvEmbedded: 'Mozilla/5.0 (ChromiumStylePlatform) Cobalt/Version'
+    };
+    
+    return agents[clientType] || agents.android;
+  }
+
+  selectBestFormat(formats) {
+    if (!formats || formats.length === 0) {
+      return null;
+    }
+
+    // Bevorzuge Formate mit Audio + Video
+    const withBoth = formats.filter(f => 
+      f.mimeType && 
+      f.mimeType.includes('video') && 
+      f.audioQuality &&
+      f.url
+    );
+
+    if (withBoth.length > 0) {
+      withBoth.sort((a, b) => {
+        const heightA = a.height || 0;
+        const heightB = b.height || 0;
+        return heightB - heightA;
+      });
+      return withBoth[0];
+    }
+
+    // Fallback: Nur Video
+    const videoOnly = formats.filter(f => 
+      f.mimeType && 
+      f.mimeType.includes('video') &&
+      f.url
+    );
+
+    if (videoOnly.length > 0) {
+      videoOnly.sort((a, b) => (b.height || 0) - (a.height || 0));
+      return videoOnly[0];
+    }
+
+    return formats.find(f => f.url);
+  }
+
+  selectBestAudio(formats) {
+    if (!formats || formats.length === 0) {
+      return null;
+    }
+
+    const audioFormats = formats.filter(f => 
+      f.mimeType && 
+      f.mimeType.includes('audio') &&
+      f.url
+    );
+
+    if (audioFormats.length === 0) {
+      return null;
+    }
+
+    audioFormats.sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0));
+    return audioFormats[0];
+  }
+}
+
+module.exports = YouTubeInnerTube;

package/src/utils/youtubeParser.js

@@ -0,0 +1,283 @@
+const axios = require('axios');
+const vm = require('vm');
+
+class YouTubeParser {
+  constructor() {
+    this.cache = {
+      playerCode: null,
+      playerUrl: null,
+      timestamp: null
+    };
+  }
+
+  async getVideoInfo(videoId, userAgent) {
+    // Methode 1: Embedded Player API (oft ohne Signatur)
+    try {
+      const embedUrl = `https://www.youtube.com/embed/${videoId}`;
+      const embedResponse = await axios.get(embedUrl, {
+        headers: {
+          'User-Agent': userAgent,
+          'Accept-Language': 'en-US,en;q=0.9'
+        },
+        httpsAgent: new (require('https').Agent)({
+          rejectUnauthorized: false
+        })
+      });
+
+      const embedHtml = embedResponse.data;
+      
+      // Extrahiere Player Response aus Embed
+      let playerResponse = this.extractPlayerResponse(embedHtml);
+      
+      if (playerResponse) {
+        return playerResponse;
+      }
+    } catch (error) {
+      console.log('Embed method failed, trying watch page...');
+    }
+
+    // Methode 2: Watch Page
+    const watchUrl = `https://www.youtube.com/watch?v=${videoId}`;
+    const response = await axios.get(watchUrl, {
+      headers: {
+        'User-Agent': userAgent,
+        'Accept-Language': 'en-US,en;q=0.9',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
+      },
+      httpsAgent: new (require('https').Agent)({
+        rejectUnauthorized: false
+      })
+    });
+
+    const html = response.data;
+    return this.extractPlayerResponse(html);
+  }
+
+  extractPlayerResponse(html) {
+    // Mehrere Patterns versuchen
+    const patterns = [
+      /var ytInitialPlayerResponse = ({.+?});/,
+      /ytInitialPlayerResponse\s*=\s*({.+?});/,
+      /"playerResponse":"({.+?})"/,
+      /ytInitialPlayerResponse\s*=\s*({.+?});<\/script>/
+    ];
+
+    for (const pattern of patterns) {
+      const match = html.match(pattern);
+      if (match) {
+        try {
+          let jsonStr = match[1];
+          
+          // Wenn escaped JSON
+          if (jsonStr.startsWith('"')) {
+            jsonStr = JSON.parse(jsonStr);
+          }
+          
+          return JSON.parse(jsonStr);
+        } catch (e) {
+          continue;
+        }
+      }
+    }
+
+    throw new Error('Could not extract player response');
+  }
+
+  async getPlayerCode(videoId, userAgent) {
+    // Cache prüfen (5 Minuten gültig)
+    if (this.cache.playerCode && this.cache.timestamp) {
+      const age = Date.now() - this.cache.timestamp;
+      if (age < 5 * 60 * 1000) {
+        return { code: this.cache.playerCode, url: this.cache.playerUrl };
+      }
+    }
+
+    const watchUrl = `https://www.youtube.com/watch?v=${videoId}`;
+    const response = await axios.get(watchUrl, {
+      headers: {
+        'User-Agent': userAgent
+      },
+      httpsAgent: new (require('https').Agent)({
+        rejectUnauthorized: false
+      })
+    });
+
+    const html = response.data;
+    
+    // Player URL finden
+    const patterns = [
+      /"jsUrl":"([^"]+)"/,
+      /"PLAYER_JS_URL":"([^"]+)"/,
+      /jsUrl":"([^"]+)"/
+    ];
+
+    let playerUrl = null;
+    for (const pattern of patterns) {
+      const match = html.match(pattern);
+      if (match) {
+        playerUrl = match[1].replace(/\\\//g, '/');
+        break;
+      }
+    }
+
+    if (!playerUrl) {
+      throw new Error('Could not find player URL');
+    }
+
+    if (playerUrl.startsWith('//')) {
+      playerUrl = 'https:' + playerUrl;
+    } else if (playerUrl.startsWith('/')) {
+      playerUrl = 'https://www.youtube.com' + playerUrl;
+    }
+
+    // Player Code laden
+    const playerResponse = await axios.get(playerUrl, {
+      headers: {
+        'User-Agent': userAgent
+      },
+      httpsAgent: new (require('https').Agent)({
+        rejectUnauthorized: false
+      })
+    });
+
+    const playerCode = playerResponse.data;
+
+    // Cache speichern
+    this.cache = {
+      playerCode: playerCode,
+      playerUrl: playerUrl,
+      timestamp: Date.now()
+    };
+
+    return { code: playerCode, url: playerUrl };
+  }
+
+  decipherSignature(signature, playerCode) {
+    try {
+      // N-Parameter Transform finden (wichtig für 403 Vermeidung)
+      const nTransform = this.extractNTransform(playerCode);
+      
+      // Signature Decipher finden
+      const decipherFunc = this.extractDecipherFunc(playerCode);
+      
+      return {
+        signature: decipherFunc ? decipherFunc(signature) : signature,
+        nTransform: nTransform
+      };
+    } catch (error) {
+      console.warn('Decipher failed:', error.message);
+      return { signature: signature, nTransform: null };
+    }
+  }
+
+  extractNTransform(playerCode) {
+    // N-Parameter ist kritisch für 403-Vermeidung
+    try {
+      const patterns = [
+        /&&\(b=([a-zA-Z0-9$]+)\(decodeURIComponent\(b\)\)/,
+        /\(b=([a-zA-Z0-9$]+)\(decodeURIComponent\(b\)\)\)/,
+        /\.get\("n"\)\)&&\(b=([a-zA-Z0-9$]+)(?:\[(\d+)\])?\([a-zA-Z]\)/
+      ];
+
+      for (const pattern of patterns) {
+        const match = playerCode.match(pattern);
+        if (match) {
+          const funcName = match[1];
+          
+          // Funktion extrahieren
+          const funcPattern = new RegExp(`${funcName.replace(/\$/g, '\\$')}=function\\([^)]+\\)\\{[^}]+\\}`, 'g');
+          const funcMatch = playerCode.match(funcPattern);
+          
+          if (funcMatch) {
+            const code = funcMatch[0];
+            const context = {};
+            vm.createContext(context);
+            vm.runInContext(code, context);
+            return context[funcName];
+          }
+        }
+      }
+    } catch (error) {
+      console.warn('N-transform extraction failed:', error.message);
+    }
+    
+    return null;
+  }
+
+  extractDecipherFunc(playerCode) {
+    // Vereinfachter Ansatz: Suche nach bekannten Patterns
+    try {
+      // Pattern 1: Standard decipher
+      const patterns = [
+        /([a-zA-Z0-9$]+)=function\([a-zA-Z]\)\{[a-zA-Z]=\1\.split\(""\)/,
+        /\b([a-zA-Z0-9$]{2,})\s*=\s*function\(\s*a\s*\)\s*\{\s*a\s*=\s*a\.split\(\s*""\s*\)/
+      ];
+
+      for (const pattern of patterns) {
+        const match = playerCode.match(pattern);
+        if (match) {
+          const funcName = match[1];
+          
+          // Extrahiere Funktion und Helper
+          const funcPattern = new RegExp(`${funcName.replace(/\$/g, '\\$')}=function\\([a-zA-Z]\\)\\{[^}]+\\}`, 'g');
+          const funcMatch = playerCode.match(funcPattern);
+          
+          if (!funcMatch) continue;
+          
+          const funcBody = funcMatch[0];
+          const helperMatch = funcBody.match(/;([a-zA-Z0-9$]+)\./);
+          
+          if (!helperMatch) continue;
+          
+          const helperName = helperMatch[1];
+          const helperPattern = new RegExp(`var ${helperName.replace(/\$/g, '\\$')}=\\{[\\s\\S]+?\\}\\};`);
+          const helperMatch2 = playerCode.match(helperPattern);
+          
+          if (!helperMatch2) continue;
+          
+          const code = `${helperMatch2[0]}\n${funcBody}\n${funcName};`;
+          
+          const context = {};
+          vm.createContext(context);
+          return vm.runInContext(code, context);
+        }
+      }
+    } catch (error) {
+      console.warn('Decipher extraction failed:', error.message);
+    }
+    
+    return null;
+  }
+
+  parseSignatureCipher(cipher) {
+    const params = new URLSearchParams(cipher);
+    return {
+      url: params.get('url'),
+      s: params.get('s'),
+      sp: params.get('sp') || 'signature'
+    };
+  }
+
+  buildUrl(baseUrl, signature, sp, nParam, nTransform) {
+    let url = baseUrl;
+    
+    // Signatur hinzufügen
+    if (signature && sp) {
+      url += `&${sp}=${encodeURIComponent(signature)}`;
+    }
+    
+    // N-Parameter transformieren (wichtig!)
+    if (nParam && nTransform) {
+      try {
+        const transformedN = nTransform(nParam);
+        url = url.replace(`&n=${nParam}`, `&n=${transformedN}`);
+      } catch (error) {
+        console.warn('N-transform failed:', error.message);
+      }
+    }
+    
+    return url;
+  }
+}
+
+module.exports = YouTubeParser;

package/src/utils/youtubeSearch.js

@@ -0,0 +1,94 @@
+const axios = require('axios');
+
+class YouTubeSearch {
+  constructor() {
+    this.baseUrl = 'https://www.youtube.com/results';
+  }
+
+  async search(query, maxResults = 5) {
+    try {
+      const response = await axios.get(this.baseUrl, {
+        params: { search_query: query },
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+        }
+      });
+
+      const html = response.data;
+      
+      // Extrahiere ytInitialData
+      const match = html.match(/var ytInitialData = ({.+?});/);
+      if (!match) {
+        throw new Error('Could not extract search results');
+      }
+
+      const data = JSON.parse(match[1]);
+      
+      // Navigiere durch die Datenstruktur
+      const contents = data?.contents?.twoColumnSearchResultsRenderer?.primaryContents?.sectionListRenderer?.contents;
+      
+      if (!contents) {
+        return [];
+      }
+
+      const results = [];
+      
+      for (const section of contents) {
+        const items = section?.itemSectionRenderer?.contents || [];
+        
+        for (const item of items) {
+          if (item.videoRenderer && results.length < maxResults) {
+            const video = item.videoRenderer;
+            
+            results.push({
+              videoId: video.videoId,
+              title: video.title?.runs?.[0]?.text || 'Unknown',
+              url: `https://www.youtube.com/watch?v=${video.videoId}`,
+              thumbnail: video.thumbnail?.thumbnails?.[0]?.url || '',
+              duration: this.parseDuration(video.lengthText?.simpleText),
+              author: video.ownerText?.runs?.[0]?.text || 'Unknown',
+              views: video.viewCountText?.simpleText || '0 views',
+              publishedTime: video.publishedTimeText?.simpleText || 'Unknown'
+            });
+          }
+        }
+      }
+
+      return results;
+    } catch (error) {
+      throw new Error(`YouTube search failed: ${error.message}`);
+    }
+  }
+
+  parseDuration(durationText) {
+    if (!durationText) return 0;
+    
+    const parts = durationText.split(':').reverse();
+    let seconds = 0;
+    
+    if (parts[0]) seconds += parseInt(parts[0]);
+    if (parts[1]) seconds += parseInt(parts[1]) * 60;
+    if (parts[2]) seconds += parseInt(parts[2]) * 3600;
+    
+    return seconds;
+  }
+
+  async searchAndDownload(query, downloader, options = {}) {
+    const results = await this.search(query, 1);
+    
+    if (results.length === 0) {
+      throw new Error('No results found');
+    }
+
+    const video = results[0];
+    console.log(`Found: ${video.title} by ${video.author}`);
+    
+    if (options.audioOnly) {
+      return await downloader.downloadAudio(video.url, options.outputPath);
+    } else {
+      return await downloader.download(video.url, options.outputPath);
+    }
+  }
+}
+
+module.exports = YouTubeSearch;