flux-dl 1.0.0

package/src/index.js

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

package/src/platforms/dailymotion.js

@@ -0,0 +1,71 @@
+const axios = require('axios');
+
+module.exports = {
+  name: 'Dailymotion',
+  
+  canHandle(url) {
+    return url.includes('dailymotion.com') || url.includes('dai.ly');
+  },
+
+  async extractInfo(url, options) {
+    try {
+      const videoId = this.extractVideoId(url);
+      if (!videoId) {
+        throw new Error('Invalid Dailymotion URL');
+      }
+
+      // Dailymotion API
+      const apiUrl = `https://api.dailymotion.com/video/${videoId}?fields=title,duration,thumbnail_url,owner.screenname,views_total`;
+      
+      const response = await axios.get(apiUrl, {
+        headers: {
+          'User-Agent': options.userAgent
+        },
+        timeout: options.timeout,
+        httpsAgent: new (require('https').Agent)({
+          rejectUnauthorized: false
+        })
+      });
+
+      const data = response.data;
+
+      // Video-Seite für Stream-URL laden
+      const pageResponse = await axios.get(`https://www.dailymotion.com/video/${videoId}`, {
+        headers: {
+          'User-Agent': options.userAgent
+        },
+        httpsAgent: new (require('https').Agent)({
+          rejectUnauthorized: false
+        })
+      });
+
+      // M3U8 URL extrahieren
+      const m3u8Match = pageResponse.data.match(/"(https:\/\/[^"]+\.m3u8[^"]*)"/);
+      const videoUrl = m3u8Match ? m3u8Match[1] : null;
+
+      return {
+        title: data.title,
+        videoId: videoId,
+        duration: data.duration,
+        thumbnail: data.thumbnail_url,
+        author: data['owner.screenname'],
+        viewCount: data.views_total,
+        videoUrl: videoUrl,
+        quality: 'auto',
+        allFormats: [],
+        platform: this.name
+      };
+
+    } catch (error) {
+      throw new Error(`Failed to extract Dailymotion info: ${error.message}`);
+    }
+  },
+
+  extractVideoId(url) {
+    let match = url.match(/dailymotion\.com\/video\/([a-zA-Z0-9]+)/);
+    if (match) return match[1];
+
+    match = url.match(/dai\.ly\/([a-zA-Z0-9]+)/);
+    return match ? match[1] : null;
+  }
+};

package/src/platforms/examplePlatform.js

@@ -0,0 +1,45 @@
+const axios = require('axios');
+const cheerio = require('cheerio');
+
+module.exports = {
+  name: 'Example Platform',
+  
+  canHandle(url) {
+    // Prüfe ob URL zu dieser Plattform gehört
+    return url.includes('example.com');
+  },
+
+  async extractInfo(url, options) {
+    try {
+      const response = await axios.get(url, {
+        headers: {
+          'User-Agent': options.userAgent
+        },
+        timeout: options.timeout,
+        httpsAgent: new (require('https').Agent)({
+          rejectUnauthorized: false
+        })
+      });
+
+      const $ = cheerio.load(response.data);
+      
+      // Beispiel: Video-Infos extrahieren
+      const title = $('title').text();
+      const videoUrl = $('video source').attr('src');
+      
+      if (!videoUrl) {
+        throw new Error('Video URL not found');
+      }
+
+      return {
+        title,
+        videoUrl,
+        thumbnail: $('meta[property="og:image"]').attr('content'),
+        duration: null,
+        platform: this.name
+      };
+    } catch (error) {
+      throw new Error(`Failed to extract info: ${error.message}`);
+    }
+  }
+};

package/src/platforms/index.js

@@ -0,0 +1,13 @@
+const examplePlatform = require('./examplePlatform');
+const youtube = require('./youtube');
+const vimeo = require('./vimeo');
+const dailymotion = require('./dailymotion');
+
+const supportedPlatforms = {
+  example: examplePlatform,
+  youtube: youtube, // Eigene Implementation (deno deaktiviert)
+  vimeo: vimeo,
+  dailymotion: dailymotion
+};
+
+module.exports = supportedPlatforms;

package/src/platforms/vimeo.js

@@ -0,0 +1,66 @@
+const axios = require('axios');
+
+module.exports = {
+  name: 'Vimeo',
+  
+  canHandle(url) {
+    return url.includes('vimeo.com');
+  },
+
+  async extractInfo(url, options) {
+    try {
+      const videoId = this.extractVideoId(url);
+      if (!videoId) {
+        throw new Error('Invalid Vimeo URL');
+      }
+
+      // Vimeo API nutzen (öffentliche Videos)
+      const apiUrl = `https://player.vimeo.com/video/${videoId}/config`;
+      
+      const response = await axios.get(apiUrl, {
+        headers: {
+          'User-Agent': options.userAgent
+        },
+        timeout: options.timeout,
+        httpsAgent: new (require('https').Agent)({
+          rejectUnauthorized: false
+        })
+      });
+
+      const data = response.data;
+      const video = data.video;
+      const files = data.request.files;
+
+      // Beste Qualität finden
+      let videoUrl = null;
+      let quality = 'unknown';
+
+      if (files.progressive && files.progressive.length > 0) {
+        const sorted = files.progressive.sort((a, b) => b.height - a.height);
+        videoUrl = sorted[0].url;
+        quality = sorted[0].quality;
+      }
+
+      return {
+        title: video.title,
+        videoId: videoId,
+        duration: video.duration,
+        thumbnail: video.thumbs['640'],
+        author: video.owner.name,
+        viewCount: null,
+        videoUrl: videoUrl,
+        quality: quality,
+        allFormats: files.progressive || [],
+        platform: this.name
+      };
+
+    } catch (error) {
+      throw new Error(`Failed to extract Vimeo info: ${error.message}`);
+    }
+  },
+
+  extractVideoId(url) {
+    const match = url.match(/vimeo\.com\/(\d+)/);
+    return match ? match[1] : null;
+  }
+};

package/src/platforms/youtube-deno.js

@@ -0,0 +1,209 @@
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  name: 'YouTube (deno)',
+
+  canHandle(url) {
+    return url.includes('youtube.com') || url.includes('youtu.be');
+  },
+
+  async extractInfo(url, options) {
+    return new Promise((resolve, reject) => {
+      // Prüfe ob cookies.txt existiert
+      const cookiesArg = fs.existsSync('cookies.txt') ? '--cookies cookies.txt' : '';
+      
+      const cmd = `deno run --allow-net --allow-read --allow-write https://deno.land/x/youtube_dl/mod.ts --dump-json ${cookiesArg} "${url}"`;
+      
+      console.log('Using deno for YouTube extraction...');
+      
+      exec(cmd, { maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+        if (error) {
+          // Fallback: Versuche mit yt-dlp
+          const ytdlpCmd = `yt-dlp --dump-json ${cookiesArg} "${url}"`;
+          
+          exec(ytdlpCmd, { maxBuffer: 10 * 1024 * 1024 }, (error2, stdout2, stderr2) => {
+            if (error2) {
+              reject(new Error(`Neither deno nor yt-dlp found. Install one of them:\n- deno: https://deno.land/\n- yt-dlp: https://github.com/yt-dlp/yt-dlp`));
+              return;
+            }
+
+            try {
+              const data = JSON.parse(stdout2);
+              resolve(this.parseVideoData(data, url));
+            } catch (parseError) {
+              reject(new Error(`Failed to parse output: ${parseError.message}`));
+            }
+          });
+          return;
+        }
+
+        try {
+          const data = JSON.parse(stdout);
+          resolve(this.parseVideoData(data, url));
+        } catch (parseError) {
+          reject(new Error(`Failed to parse deno output: ${parseError.message}`));
+        }
+      });
+    });
+  },
+
+  parseVideoData(data, url) {
+    return {
+      title: data.title,
+      videoId: data.id,
+      duration: data.duration,
+      thumbnail: data.thumbnail,
+      author: data.uploader || data.channel,
+      viewCount: data.view_count,
+      videoUrl: url,
+      quality: data.format_note || 'best',
+      format: data,
+      allFormats: data.formats || [],
+      platform: this.name,
+      _useCli: true
+    };
+  },
+
+  async download(url, outputPath, onProgress) {
+    return new Promise((resolve, reject) => {
+      if (!fs.existsSync(outputPath)) {
+        fs.mkdirSync(outputPath, { recursive: true });
+      }
+
+      const cookiesArg = fs.existsSync('cookies.txt') ? '--cookies cookies.txt' : '';
+      const outputTemplate = path.join(outputPath, '%(title)s.%(ext)s');
+      
+      // Versuche zuerst deno
+      let cmd = `deno run --allow-net --allow-read --allow-write https://deno.land/x/youtube_dl/mod.ts -f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best" ${cookiesArg} -o "${outputTemplate}" "${url}"`;
+      
+      console.log('Downloading with deno...');
+      
+      let process = exec(cmd, { maxBuffer: 50 * 1024 * 1024 });
+      
+      let usedDeno = true;
+      
+      process.on('error', (err) => {
+        // Fallback zu yt-dlp
+        console.log('deno failed, trying yt-dlp...');
+        usedDeno = false;
+        
+        cmd = `yt-dlp -f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best" ${cookiesArg} -o "${outputTemplate}" "${url}"`;
+        process = exec(cmd, { maxBuffer: 50 * 1024 * 1024 });
+        
+        process.stdout.on('data', (data) => {
+          const output = data.toString();
+          console.log(output);
+          
+          const match = output.match(/(\d+\.\d+)%/);
+          if (match && onProgress) {
+            onProgress(parseFloat(match[1]));
+          }
+        });
+
+        process.stderr.on('data', (data) => {
+          console.error(data.toString());
+        });
+
+        process.on('close', (code) => {
+          if (code === 0) {
+            resolve({ success: true, outputPath, tool: 'yt-dlp' });
+          } else {
+            reject(new Error(`yt-dlp exited with code ${code}`));
+          }
+        });
+      });
+      
+      if (usedDeno) {
+        process.stdout.on('data', (data) => {
+          const output = data.toString();
+          console.log(output);
+          
+          const match = output.match(/(\d+\.\d+)%/);
+          if (match && onProgress) {
+            onProgress(parseFloat(match[1]));
+          }
+        });
+
+        process.stderr.on('data', (data) => {
+          console.error(data.toString());
+        });
+
+        process.on('close', (code) => {
+          if (code === 0) {
+            resolve({ success: true, outputPath, tool: 'deno' });
+          } else {
+            // Versuche yt-dlp als Fallback
+            console.log('deno failed, trying yt-dlp...');
+            
+            const ytdlpCmd = `yt-dlp -f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best" ${cookiesArg} -o "${outputTemplate}" "${url}"`;
+            const ytdlpProcess = exec(ytdlpCmd, { maxBuffer: 50 * 1024 * 1024 });
+            
+            ytdlpProcess.stdout.on('data', (data) => console.log(data.toString()));
+            ytdlpProcess.stderr.on('data', (data) => console.error(data.toString()));
+            
+            ytdlpProcess.on('close', (ytdlpCode) => {
+              if (ytdlpCode === 0) {
+                resolve({ success: true, outputPath, tool: 'yt-dlp' });
+              } else {
+                reject(new Error(`Both deno and yt-dlp failed`));
+              }
+            });
+          }
+        });
+      }
+    });
+  },
+
+  async downloadAudio(url, outputPath, onProgress) {
+    return new Promise((resolve, reject) => {
+      if (!fs.existsSync(outputPath)) {
+        fs.mkdirSync(outputPath, { recursive: true });
+      }
+
+      const cookiesArg = fs.existsSync('cookies.txt') ? '--cookies cookies.txt' : '';
+      const outputTemplate = path.join(outputPath, '%(title)s.%(ext)s');
+      
+      let cmd = `deno run --allow-net --allow-read --allow-write https://deno.land/x/youtube_dl/mod.ts -f "bestaudio[ext=m4a]/bestaudio" ${cookiesArg} -o "${outputTemplate}" "${url}"`;
+      
+      console.log('Downloading audio with deno...');
+      
+      const process = exec(cmd, { maxBuffer: 50 * 1024 * 1024 });
+      
+      process.on('error', () => {
+        // Fallback zu yt-dlp
+        const ytdlpCmd = `yt-dlp -f "bestaudio[ext=m4a]/bestaudio" ${cookiesArg} -o "${outputTemplate}" "${url}"`;
+        exec(ytdlpCmd, { maxBuffer: 50 * 1024 * 1024 }, (err, stdout, stderr) => {
+          if (err) {
+            reject(new Error('Both deno and yt-dlp failed'));
+          } else {
+            resolve({ success: true, outputPath, tool: 'yt-dlp' });
+          }
+        });
+      });
+      
+      process.stdout.on('data', (data) => {
+        const output = data.toString();
+        console.log(output);
+        
+        const match = output.match(/(\d+\.\d+)%/);
+        if (match && onProgress) {
+          onProgress(parseFloat(match[1]));
+        }
+      });
+
+      process.stderr.on('data', (data) => {
+        console.error(data.toString());
+      });
+
+      process.on('close', (code) => {
+        if (code === 0) {
+          resolve({ success: true, outputPath, tool: 'deno' });
+        } else {
+          reject(new Error(`deno exited with code ${code}`));
+        }
+      });
+    });
+  }
+};