frostpv 1.0.1

package/index.js

@@ -0,0 +1,1490 @@
+const axios = require("axios");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const FormData = require("form-data");
+const crypto = require("crypto");
+const { igdl, ttdl, fbdown, mediafire, capcut, gdrive, pinterest } = require("btch-downloader");
+const { TwitterDL } = require("twitter-downloader");
+const btch = require("btch-downloader");
+const btchOld = require("btch-downloader-old");
+
+// Fallback libs
+const Tiktok = require("@tobyg74/tiktok-api-dl");
+const { YtDlp } = require('ytdlp-nodejs');
+const ffmpegPath = require('ffmpeg-ffprobe-static').ffmpegPath;
+const { v4: uuidv4 } = require('uuid');
+
+const pathToFfmpeg = require("ffmpeg-ffprobe-static");
+const ffmpeg = require("fluent-ffmpeg");
+ffmpeg.setFfmpegPath(pathToFfmpeg.ffmpegPath);
+
+// Output directory is the caller's working directory (keeps files next to the running app)
+const OUTPUT_DIR = process.cwd();
+try { fs.mkdirSync(OUTPUT_DIR, { recursive: true }); } catch (_) {}
+// Keep an OS temp directory for any future transient needs
+const TEMP_DIR = path.join(os.tmpdir(), "downloader-dl-bot");
+try { fs.mkdirSync(TEMP_DIR, { recursive: true }); } catch (_) {}
+// TTL (minutes) for files in OUTPUT_DIR (audio/video) before they are pruned
+const OUTPUT_RETENTION_MIN = Number(process.env.OUTPUT_RETENTION_MIN || 5);
+
+const GOFILE_API = "Vs4e2PL8n65ExPz6wgDlqSY8kcEBRrzN";
+const GOFILE_UPLOAD_URL = "https://upload.gofile.io/uploadfile";
+const SIZE_LIMIT_MB = 10;
+const SIZE_LIMIT_BYTES = SIZE_LIMIT_MB * 1024 * 1024;
+
+const videoPlatforms = [
+  "https://www.instagram.com",
+  "https://instagram.com",
+  "https://www.tiktok.com",
+  "https://tiktok.com",
+  "https://www.facebook.com",
+  "https://facebook.com",
+  "https://www.facebook.com/watch/",
+  "https://www.facebook.com/watch?v=",
+  "https://www.facebook.com/watch?",
+  "https://fb.watch",
+  "https://www.fb.watch",
+  "https://fb.com",
+  "https://www.fb.com",
+  "https://www.mediafire.com",
+  "https://mediafire.com",
+  "https://www.capcut.com",
+  "https://capcut.com",
+  "https://drive.google.com",
+  "https://www.google.com/drive",
+  "https://x.com",
+  "https://www.x.com",
+  "https://twitter.com",
+  "https://www.twitter.com",
+  "https://vm.tiktok.com/",
+  "https://vt.tiktok.com/"
+];
+
+// Blacklist links
+const linkCant = [{
+  link: "https://v12331m.tiktok.com",
+  reason: "Use real link like 'https://www.tiktok.com'. (just click on your link and copy the link in the browser)"
+}];
+
+// Function to check if a link corresponds to a video platform
+const isVideoLink = (link) => {
+  return videoPlatforms.some(platform => link.startsWith(platform));
+};
+
+// Function to check if a link is blacklisted
+const blacklistLink = (link) => {
+  return linkCant.find(item => link.includes(item.link));
+};
+
+const defaultConfig = {
+  autocrop: false,
+  limitSizeMB: null, // For compression, not for GoFile limit
+  rotation: null,
+  outputFormat: null,
+};
+
+
+const AUTH_STATE = { tokenHash: null };
+const AUTH_SALT = (process.env.DOWNLOADER_SALT || "");
+const EXPECTED_HASH = (process.env.DOWNLOADER_EXPECTED_HASH || "").trim() || null;
+
+function setAuthKey(token) {
+  try {
+    const material = String(token) + String(AUTH_SALT || "");
+    const hash = crypto.createHash("sha256").update(material).digest("hex");
+    AUTH_STATE.tokenHash = hash;
+  } catch (_) { AUTH_STATE.tokenHash = null; }
+}
+
+function assertAuthorized() {
+  try {
+    if (EXPECTED_HASH && AUTH_STATE.tokenHash && AUTH_STATE.tokenHash === EXPECTED_HASH) return;
+
+    throw new Error("Unauthorized");
+  } catch (e) {
+    throw new Error("Unauthorized");
+  }
+}
+
+
+function safeUnlink(filePath) {
+  try {
+    const resolvedPath = path.resolve(filePath);
+    if (fs.existsSync(resolvedPath)) {
+      fs.rmSync(resolvedPath, { force: true });
+    }
+  } catch (error) {
+    console.error(`Error in safeUnlink for ${filePath}:`, error.message);
+    // Don't throw the error, just log it
+    // This prevents the ENOENT error from crashing the application
+  }
+}
+
+// Function to check if file is in use (Windows specific)
+function isFileInUse(filePath) {
+  try {
+    // Try to open the file in exclusive mode
+    const fd = fs.openSync(filePath, 'r+');
+    fs.closeSync(fd);
+    return false; // File is not in use
+  } catch (error) {
+    if (error.code === 'EBUSY' || error.code === 'EACCES') {
+      return true; // File is in use
+    }
+    return false; // Other error, assume not in use
+  }
+}
+
+// Enhanced safe unlink with retry mechanism
+async function safeUnlinkWithRetry(filePath, maxRetries = 3) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const resolvedPath = path.resolve(filePath);
+      
+      if (fs.existsSync(resolvedPath)) {
+        // Check if file is in use (Windows)
+        if (process.platform === 'win32' && isFileInUse(resolvedPath)) {
+          await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+          continue;
+        }
+        
+        fs.rmSync(resolvedPath, { force: true });
+        return true;
+      } else {
+        return true;
+      }
+    } catch (error) {
+      if (attempt === maxRetries) {
+        return false;
+      }
+      // Wait before retry
+      await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+    }
+  }
+  return false;
+}
+
+// Function to upload to GoFile if needed
+async function uploadToGoFileIfNeeded(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    const fileSizeInBytes = stats.size;
+
+    if (fileSizeInBytes <= SIZE_LIMIT_BYTES) {
+      return { type: "local", value: filePath };
+    }
+
+    const form = new FormData();
+    form.append("file", fs.createReadStream(filePath), path.basename(filePath));
+
+    const response = await axios.post(GOFILE_UPLOAD_URL, form, {
+      headers: {
+        ...form.getHeaders(),
+        "Authorization": `Bearer ${GOFILE_API}`,
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity
+    });
+
+    if (response.data && response.data.status === "ok") {
+      const downloadLink = response.data.data?.downloadPage;
+      if (downloadLink) {
+        return { type: "gofile", value: downloadLink };
+      } else {
+        throw new Error("GoFile API response OK, but download link not found.");
+      }
+    } else {
+      throw new Error(`GoFile API Error: ${response.data?.status || 'Unknown error'}`);
+    }
+  } catch (error) {
+    console.error(`GoFile Upload Error for ${filePath}:`, error.message);
+    return { type: "local", value: filePath, error: `GoFile upload failed: ${error.message}` };
+  }
+}
+
+// Function to validate URL accessibility
+async function validateVideoUrl(url, platform) {
+  try {
+    const response = await axios.head(url, {
+      timeout: 10000,
+      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',
+        'Accept': 'video/webm,video/ogg,video/*;q=0.9,application/ogg;q=0.7,audio/*;q=0.6,*/*;q=0.5',
+        'Accept-Language': 'en-US,en;q=0.5',
+        'Accept-Encoding': 'gzip, deflate',
+        'Connection': 'keep-alive',
+        'Upgrade-Insecure-Requests': '1'
+      },
+      validateStatus: function (status) {
+        return status >= 200 && status < 400; // Accept redirects
+      }
+    });
+    
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+// Function to validate and clean Twitter/X URLs
+function validateTwitterUrl(url) {
+  try {
+    // Remove query parameters that might cause issues
+    const cleanUrl = url.split('?')[0];
+    
+    // Ensure it's a valid Twitter/X URL format
+    if (!cleanUrl.includes('x.com') && !cleanUrl.includes('twitter.com')) {
+      throw new Error("Not a valid Twitter/X URL");
+    }
+    
+    // Check if it has the required structure
+    const urlParts = cleanUrl.split('/');
+    if (urlParts.length < 5) {
+      throw new Error("Invalid Twitter/X URL structure");
+    }
+    
+    return cleanUrl;
+  } catch (error) {
+    throw new Error(`Twitter URL validation failed: ${error.message}`);
+  }
+}
+
+// Função utilitária para obter cookies
+function getYoutubeCookiesPath() {
+  const cookiesPath = path.resolve(process.cwd(), 'cookies.txt');
+  if (fs.existsSync(cookiesPath)) {
+    return cookiesPath;
+  }
+  return null;
+}
+
+// Função utilitária para obter duração do vídeo/áudio em segundos
+async function getYoutubeDurationSeconds(url) {
+  try {
+    const ytdlp = new YtDlp({ ffmpegPath });
+    const info = await ytdlp.getInfoAsync(url);
+    if (info && info.duration) return info.duration;
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+// Função para baixar áudio do YouTube
+async function downloadYoutubeAudio(url, outputPath) {
+  // Verificar duração máxima de 15 minutos
+  const duration = await getYoutubeDurationSeconds(url);
+  if (duration && duration > 900) {
+    throw new Error('The audio is longer than 15 minutes. Test limit: 15 minutes. This feature is still in beta.');
+  }
+  return new Promise(async (resolve, reject) => {
+    try {
+      const ytdlp = new YtDlp({ ffmpegPath });
+      const cookiesPath = getYoutubeCookiesPath();
+      
+      // Garantir que o nome do arquivo tenha a extensão correta
+      const baseName = outputPath.replace(/\.[^/.]+$/, ""); // Remove extensão se existir
+      
+      // Primeiro, tentar com a API de opções
+      try {
+        const options = {
+          format: {
+            filter: 'audioonly',
+            type: 'mp3',
+            quality: 'highestaudio'
+          },
+          output: outputPath
+        };
+        
+        if (cookiesPath) {
+          options.cookies = cookiesPath;
+        }
+        
+        // Remover logs detalhados para download de áudio do YouTube
+        const result = await ytdlp.downloadAsync(url, options);
+        // Verificar se o arquivo foi criado
+        const actualFileName = baseName + '.mp3';
+        if (fs.existsSync(actualFileName)) {
+          resolve(actualFileName);
+          return;
+        }
+        
+        // Tentar encontrar o arquivo com extensão diferente
+        const files = fs.readdirSync('./');
+        const downloadedFile = files.find(file => file.startsWith(baseName.split('/').pop()));
+        if (downloadedFile) {
+          resolve(downloadedFile);
+          return;
+        }
+      } catch (apiError) {
+        console.log('API method failed, trying direct args method:', apiError.message);
+      }
+      
+      // Fallback: usar argumentos diretos para máxima qualidade de áudio
+      const args = [
+        url,
+        '-f', 'bestaudio[ext=mp3]/bestaudio',
+        '-o', outputPath
+      ];
+      
+      if (cookiesPath) {
+        args.push('--cookies', cookiesPath);
+      }
+      
+      // Remover logs detalhados para download de áudio do YouTube
+      const result = await ytdlp.execAsync(args);
+      // Verificar se o arquivo foi criado
+      const actualFileName = baseName + '.mp3';
+      if (fs.existsSync(actualFileName)) {
+        resolve(actualFileName);
+      } else {
+        // Tentar encontrar o arquivo com extensão diferente
+        const files = fs.readdirSync('./');
+        const downloadedFile = files.find(file => file.startsWith(baseName.split('/').pop()));
+        if (downloadedFile) {
+          resolve(downloadedFile);
+        } else {
+          reject(new Error('YouTube audio download completed but file not found'));
+        }
+      }
+    } catch (error) {
+      console.error('YouTube audio download error:', error);
+      reject(new Error('This URL is not from a supported platform. Supported platforms: Instagram, X(Twitter), TikTok and Facebook'));
+    }
+  });
+}
+
+// Enhanced function to get platform type from URL
+function getPlatformType(url) {
+  const lowerUrl = url.toLowerCase();
+  
+  if (lowerUrl.includes("instagram.com") || lowerUrl.includes("instagr.am")) return "instagram";
+  if (lowerUrl.includes("tiktok.com") || lowerUrl.includes("vm.tiktok.com") || lowerUrl.includes("vt.tiktok.com")) return "tiktok";
+  if (lowerUrl.includes("facebook.com") || lowerUrl.includes("fb.watch") || lowerUrl.includes("fb.com")) return "facebook";
+  if (lowerUrl.includes("mediafire.com")) return "mediafire";
+  if (lowerUrl.includes("x.com") || lowerUrl.includes("twitter.com")) return "twitter";
+  if (lowerUrl.includes("youtube.com") || lowerUrl.includes("you112t12u.be") || lowerUrl.includes("m.y11outu314be.com")) return "youtu1354be";
+  
+  return "unknown";
+}
+
+// Enhanced fallback download function with platform-specific methods
+async function tryFallbackDownload(url, maxRetries = 3) {
+  const platform = getPlatformType(url);
+  
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      let videoUrl = null;
+      
+      // Platform-specific fallback methods
+      switch (platform) {
+        case "instagram": {
+          // Try multiple Instagram methods
+          const methods = [
+            async () => {
+              const data = await igdl(url);
+              if (data && Array.isArray(data) && data[0] && data[0].url) {
+                return data[0].url;
+              }
+              throw new Error("No valid URL in igdl response");
+            },
+            async () => {
+              // Try with different headers
+              const data = await igdl(url, {
+                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',
+                  'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+                  'Accept-Language': 'en-US,en;q=0.5',
+                  'Accept-Encoding': 'gzip, deflate',
+                  'Connection': 'keep-alive',
+                  'Upgrade-Insecure-Requests': '1'
+                }
+              });
+              if (data && Array.isArray(data) && data[0] && data[0].url) {
+                return data[0].url;
+              }
+              throw new Error("No valid URL in igdl response with custom headers");
+            },
+            async () => {
+              // Fallback: try using the old version of btch-downloader
+              try {
+                const { igdl: igdlOld } = btchOld;
+                if (typeof igdlOld === 'function') {
+                  const data = await igdlOld(url);
+                  if (data && Array.isArray(data) && data[0] && data[0].url) {
+                    return data[0].url;
+                  }
+                }
+                throw new Error("Old btch-downloader igdl not available or failed");
+              } catch (oldError) {
+                throw new Error(`Old btch-downloader fallback failed: ${oldError.message}`);
+              }
+            }
+          ];
+          
+          for (const method of methods) {
+            try {
+              videoUrl = await method();
+              if (videoUrl) break;
+            } catch (methodError) {
+              continue;
+            }
+          }
+          break;
+        }
+        
+        case "tiktok": {
+          // Try multiple TikTok methods
+          const methods = [
+            async () => {
+              const data = await ttdl(url);
+              if (data && data.video && data.video[0]) {
+                return data.video[0];
+              }
+              throw new Error("No valid video in ttdl response");
+            },
+            async () => {
+              const result = await Tiktok.Downloader(url, { version: "v1" });
+              if (result.status === "success" && result.result) {
+                if (result.result.video && result.result.video.playAddr && result.result.video.playAddr.length > 0) {
+                  return result.result.video.playAddr[0];
+                } else if (result.result.videoHD) {
+                  return result.result.videoHD;
+                }
+              }
+              throw new Error("No valid video in Tiktok.Downloader response");
+            },
+            async () => {
+              // Try with different version
+              const result = await Tiktok.Downloader(url, { version: "v2" });
+              if (result.status === "success" && result.result) {
+                if (result.result.video && result.result.video.playAddr && result.result.video.playAddr.length > 0) {
+                  return result.result.video.playAddr[0];
+                } else if (result.result.videoHD) {
+                  return result.result.videoHD;
+                }
+              }
+              throw new Error("No valid video in Tiktok.Downloader v2 response");
+            }
+          ];
+          
+          for (const method of methods) {
+            try {
+              videoUrl = await method();
+              if (videoUrl) break;
+            } catch (methodError) {
+              continue;
+            }
+          }
+          break;
+        }
+        
+        case "facebook": {
+          // Try multiple Facebook methods
+          const methods = [
+            async () => {
+              const data = await fbdown(url);
+              if (data && (data.Normal_video || data.HD)) {
+                return data.Normal_video || data.HD;
+              }
+              throw new Error("No valid video in fbdown response");
+            },
+            async () => {
+              // Try with different approach
+              const data = await fbdown(url, {
+                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'
+                }
+              });
+              if (data && (data.Normal_video || data.HD)) {
+                return data.Normal_video || data.HD;
+              }
+              throw new Error("No valid video in fbdown response with custom headers");
+            }
+          ];
+          
+          for (const method of methods) {
+            try {
+              videoUrl = await method();
+              if (videoUrl) break;
+            } catch (methodError) {
+              continue;
+            }
+          }
+          break;
+        }
+        
+        case "twitter": {
+          // Try multiple Twitter methods with better response handling
+          const methods = [
+            async () => {
+              const cleanUrl = validateTwitterUrl(url);
+              const data = await TwitterDL(cleanUrl, {});
+              
+              // Check multiple possible response structures
+              if (data && data.result) {
+                // Structure 1: data.result.media[0].videos[0].url
+                if (data.result.media && data.result.media[0] && 
+                    data.result.media[0].videos && data.result.media[0].videos[0] && 
+                    data.result.media[0].videos[0].url) {
+                  return data.result.media[0].videos[0].url;
+                }
+                
+                // Structure 2: data.result.video[0].url
+                if (data.result.video && data.result.video[0] && data.result.video[0].url) {
+                  return data.result.video[0].url;
+                }
+                
+                // Structure 3: data.result.url (direct URL)
+                if (data.result.url) {
+                  return data.result.url;
+                }
+                
+                // Structure 4: data.result.media[0].url
+                if (data.result.media && data.result.media[0] && data.result.media[0].url) {
+                  return data.result.media[0].url;
+                }
+                
+                // Structure 5: Check for any video URL in the entire response
+                const findVideoUrl = (obj) => {
+                  if (typeof obj === 'string' && obj.includes('http') && 
+                      (obj.includes('.mp4') || obj.includes('video') || obj.includes('media'))) {
+                    return obj;
+                  }
+                  if (typeof obj === 'object' && obj !== null) {
+                    for (const key in obj) {
+                      const result = findVideoUrl(obj[key]);
+                      if (result) return result;
+                    }
+                  }
+                  return null;
+                };
+                
+                const foundUrl = findVideoUrl(data.result);
+                if (foundUrl) {
+                  return foundUrl;
+                }
+              }
+              
+              throw new Error("No valid video URL found in TwitterDL response structure");
+            },
+            async () => {
+              // Try with different options and headers
+              const cleanUrl = validateTwitterUrl(url);
+              const data = await TwitterDL(cleanUrl, {
+                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',
+                  'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+                  'Accept-Language': 'en-US,en;q=0.5',
+                  'Accept-Encoding': 'gzip, deflate',
+                  'Connection': 'keep-alive',
+                  'Upgrade-Insecure-Requests': '1'
+                }
+              });
+              
+              // Same structure checking as above
+              if (data && data.result) {
+                if (data.result.media && data.result.media[0] && 
+                    data.result.media[0].videos && data.result.media[0].videos[0] && 
+                    data.result.media[0].videos[0].url) {
+                  return data.result.media[0].videos[0].url;
+                }
+                
+                if (data.result.video && data.result.video[0] && data.result.video[0].url) {
+                  return data.result.video[0].url;
+                }
+                
+                if (data.result.url) {
+                  return data.result.url;
+                }
+                
+                if (data.result.media && data.result.media[0] && data.result.media[0].url) {
+                  return data.result.media[0].url;
+                }
+                
+                const findVideoUrl = (obj) => {
+                  if (typeof obj === 'string' && obj.includes('http') && 
+                      (obj.includes('.mp4') || obj.includes('video') || obj.includes('media'))) {
+                    return obj;
+                  }
+                  if (typeof obj === 'object' && obj !== null) {
+                    for (const key in obj) {
+                      const result = findVideoUrl(obj[key]);
+                      if (result) return result;
+                    }
+                  }
+                  return null;
+                };
+                
+                const foundUrl = findVideoUrl(data.result);
+                if (foundUrl) {
+                  return foundUrl;
+                }
+              }
+              
+              throw new Error("No valid video URL found in TwitterDL response with custom headers");
+            },
+            async () => {
+              // Try with a different approach - use the same method as primary download
+              try {
+                const cleanUrl = validateTwitterUrl(url);
+                const data = await TwitterDL(cleanUrl, {});
+                if (
+                  !data ||
+                  !data.result ||
+                  !data.result.media ||
+                  !data.result.media[0] ||
+                  !data.result.media[0].videos ||
+                  !data.result.media[0].videos[0] ||
+                  !data.result.media[0].videos[0].url
+                ) {
+                  throw new Error("No video URL found in Twitter response");
+                }
+                return data.result.media[0].videos[0].url;
+              } catch (error) {
+                throw new Error(`Twitter fallback method 3 failed: ${error.message}`);
+              }
+            },
+            async () => {
+              // Fallback: try using the old version of btch-downloader for Twitter/X
+              try {
+                const cleanUrl = validateTwitterUrl(url);
+                // Try to find any Twitter-related function in the old version
+                const possibleFunctions = ['twitter', 'twitterdl', 'tw', 'x', 'xdown', 'xdl'];
+                for (const funcName of possibleFunctions) {
+                  if (typeof btchOld[funcName] === 'function') {
+                    try {
+                      const data = await btchOld[funcName](cleanUrl);
+                      // Check multiple possible response structures
+                      if (data && data.result) {
+                        if (data.result.media && data.result.media[0] && 
+                            data.result.media[0].videos && data.result.media[0].videos[0] && 
+                            data.result.media[0].videos[0].url) {
+                          return data.result.media[0].videos[0].url;
+                        }
+                        if (data.result.video && data.result.video[0] && data.result.video[0].url) {
+                          return data.result.video[0].url;
+                        }
+                        if (data.result.url) {
+                          return data.result.url;
+                        }
+                      }
+                      if (data && data.url) {
+                        return data.url;
+                      }
+                      if (Array.isArray(data) && data[0] && data[0].url) {
+                        return data[0].url;
+                      }
+                    } catch (e) {
+                      continue;
+                    }
+                  }
+                }
+                throw new Error("No Twitter functions found in old btch-downloader");
+              } catch (oldError) {
+                throw new Error(`Old btch-downloader Twitter fallback failed: ${oldError.message}`);
+              }
+            }
+          ];
+          
+          for (const method of methods) {
+            try {
+              videoUrl = await method();
+              if (videoUrl) break;
+            } catch (methodError) {
+              continue;
+            }
+          }
+          break;
+        }
+        
+        case "youtube": {
+          // YouTube doesn't need fallback - it has its own specific method
+          throw new Error("YouTube downloads should use the primary method, not fallback");
+        }
+        
+        case "mediafire": {
+          // Try MediaFire method
+          try {
+            const data = await mediafire(url);
+            if (data && data.url) {
+              videoUrl = data.url;
+            } else {
+              throw new Error("No valid URL in mediafire response");
+            }
+          } catch (methodError) {
+            // Continue to next attempt
+          }
+          break;
+        }
+        
+        default: {
+          // Generic fallback for unknown platforms
+          try {
+            const data = await igdl(url);
+            if (data && Array.isArray(data) && data[0] && data[0].url) {
+              videoUrl = data[0].url;
+            } else {
+              throw new Error("No valid URL in generic igdl response");
+            }
+          } catch (methodError) {
+            // Continue to next attempt
+          }
+          break;
+        }
+      }
+      
+      // If we got a video URL, validate it
+      if (videoUrl && videoUrl.includes("http")) {
+        // Validate the URL is accessible
+        try {
+          const response = await axios.head(videoUrl, { 
+            timeout: 10000,
+            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'
+            }
+          });
+          
+          if (response.status === 200) {
+            return videoUrl;
+          } else {
+            throw new Error(`URL validation failed with status ${response.status}`);
+          }
+        } catch (validationError) {
+          throw new Error(`Video URL is not accessible: ${validationError.message}`);
+        }
+      } else {
+        throw new Error("No valid video URL obtained from any fallback method");
+      }
+      
+    } catch (error) {
+      if (attempt === maxRetries) {
+        throw new Error(`Enhanced fallback method failed after ${maxRetries} attempts for ${platform}: ${error.message}`);
+      }
+      // Wait before retry (exponential backoff)
+      const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+}
+
+// Main MediaDownloader function
+const MediaDownloader = async (url, options = {}) => {
+  assertAuthorized();
+  const config = { ...defaultConfig, ...options };
+
+  if (!url || !url.includes("http")) {
+    throw new Error("Please specify a valid video URL.");
+  }
+
+  try {
+    url = await unshortenUrl(extractUrlFromString(url));
+  } catch (error) {
+    // Use original URL if unshortening fails
+  }
+
+  if (url.includes("snapchat.com")) {
+    throw new Error("Snapchat links are not supported for download. Download videos from Instagram, X, TikTok, and Facebook");
+  }
+  if (url.includes("threads.com")) {
+    throw new Error("Threads links are not supported for download. Download videos from Instagram, X, TikTok, and Facebook");
+  }
+  if (url.includes("pinterest.com")) {
+    throw new Error("Pinterest links are not supported for download. Download videos from Instagram, X, TikTok, and Facebook");
+  }
+  if (url.includes("pin.it")) {
+    throw new Error("Pinterest links are not supported for download. Download videos from Instagram, X, TikTok, and Facebook");
+  }
+
+  const blacklisted = blacklistLink(url);
+  if (blacklisted) {
+    throw new Error(`URL not supported: ${blacklisted.reason}`);
+  }
+
+  // Verificar se o link está na lista de plataformas suportadas
+  if (!isVideoLink(url)) {
+    throw new Error("This URL is not from a supported platform. Supported platforms: Instagram, X(Twitter), TikTok and Facebook");
+  }
+
+  // Verificar se é YouTube e lançar erro customizado
+  const platform = getPlatformType(url);
+  if (platform === "youtube") {
+    throw new Error("This URL is not from a supported platform. Supported platforms: Instagram, X(Twitter), TikTok and Facebook");
+  }
+
+  await cleanupTempFiles(); // Clean up previous temp files
+
+  let downloadedFilePath = null;
+
+  try {
+    // Try primary download method
+    try {
+      downloadedFilePath = await downloadSmartVideo(url, config);
+    } catch (error) {
+      const platform = getPlatformType(url);
+      
+      // YouTube doesn't use fallback method - it has its own specific implementation
+      if (platform === "youtube") {
+        throw new Error(`YouTube download failed: ${error.message}`);
+      }
+      
+      try {
+        const fallbackUrl = await tryFallbackDownload(url);
+        
+        // Validate fallback URL
+        const isValid = await validateVideoUrl(fallbackUrl, platform);
+        if (!isValid) {
+          throw new Error("Fallback URL validation failed");
+        }
+        
+        downloadedFilePath = await downloadDirectVideo(fallbackUrl, config);
+      } catch (fallbackError) {
+        throw new Error(`Failed to download video with both methods: ${fallbackError.message}`);
+      }
+    }
+
+    if (downloadedFilePath) {
+      const result = await uploadToGoFileIfNeeded(downloadedFilePath);
+      return result;
+    } else {
+      throw new Error("Failed to obtain downloaded file path.");
+    }
+  } catch (error) {
+    // Clean up any remaining temp files on error
+    await cleanupTempFiles();
+    throw new Error(`Error in downloader videos: ${error.message}`);
+  }
+};
+
+// Function to process downloaded file
+async function processDownloadedFile(fileName, config, platform = null) {
+  let processedFile = path.resolve(fileName);
+  if (config.rotation) {
+    processedFile = await rotateVideo(processedFile, config.rotation);
+  }
+  if (config.autocrop) {
+    processedFile = await autoCrop(processedFile);
+  }
+  processedFile = await checkAndCompressVideo(processedFile, config.limitSizeMB, platform);
+  if (config.outputFormat) {
+    processedFile = await convertVideoFormat(processedFile, String(config.outputFormat).toLowerCase());
+  }
+  return processedFile;
+}
+
+// Function for platform-specific video download
+async function downloadSmartVideo(url, config) {
+  try {
+    let videoUrl = null;
+    let platform = getPlatformType(url);
+
+    switch (platform) {
+      case "instagram": {
+        let data = null;
+        let attempts = 0;
+        const maxAttempts = 3;
+        while (attempts < maxAttempts && !data) {
+          attempts++;
+          try {
+            data = await igdl(url);
+            if (data && Array.isArray(data) && data[0] && data[0].url) {
+              videoUrl = data[0].url;
+              break;
+            } else {
+              throw new Error("Invalid response structure from igdl");
+            }
+          } catch (error) {
+            if (attempts === maxAttempts) {
+              throw new Error(`Instagram download failed after ${maxAttempts} attempts: ${error.message}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000 * attempts));
+          }
+        }
+        if (!videoUrl) {
+          throw new Error("Video unavailable or invalid link for Instagram.");
+        }
+        break;
+      }
+      case "tiktok": {
+        let data = null;
+        let fallbackError = null;
+        try {
+          data = await ttdl(url);
+          if (!data || !data.video || !data.video[0]) {
+            throw new Error("Invalid response from ttdl");
+          }
+          videoUrl = data.video[0];
+        } catch (error) {
+          // Fallback: @tobyg74/tiktok-api-dl
+          try {
+            const result = await Tiktok.Downloader(url, { version: "v1" });
+            if (result.status === "success" && result.result) {
+              if (result.result.video && result.result.video.playAddr && result.result.video.playAddr.length > 0) {
+                videoUrl = result.result.video.playAddr[0];
+              } else if (result.result.videoHD) {
+                videoUrl = result.result.videoHD;
+              } else {
+                throw new Error("No valid video found in fallback v1");
+              }
+            } else {
+              throw new Error("Fallback v1 returned unsuccessful status");
+            }
+          } catch (err) {
+            // Try v2
+            try {
+              const result = await Tiktok.Downloader(url, { version: "v2" });
+              if (result.status === "success" && result.result) {
+                if (result.result.video && result.result.video.playAddr && result.result.video.playAddr.length > 0) {
+                  videoUrl = result.result.video.playAddr[0];
+                } else if (result.result.videoHD) {
+                  videoUrl = result.result.videoHD;
+                } else {
+                  throw new Error("No valid video found in fallback v2");
+                }
+              } else {
+                throw new Error("Fallback v2 returned unsuccessful status");
+              }
+            } catch (err2) {
+              fallbackError = err2;
+              throw new Error(`TikTok download failed: ${error.message} | Fallback v1: ${err.message} | Fallback v2: ${err2.message}`);
+            }
+          }
+        }
+        break;
+      }
+      case "facebook": {
+        try {
+          const data = await fbdown(url);
+          if (!data || (!data.Normal_video && !data.HD)) {
+            throw new Error("No video URLs found in Facebook response");
+          }
+          videoUrl = data.Normal_video || data.HD;
+          
+          // Validate the URL is accessible
+          const response = await axios.head(videoUrl, { 
+            timeout: 10000,
+            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'
+            }
+          }).catch(() => null);
+          
+          if (!response || response.status !== 200) {
+            throw new Error("Facebook video URL is not accessible");
+          }
+        } catch (error) {
+          throw new Error(`Facebook download failed: ${error.message}`);
+        }
+        break;
+      }
+      case "mediafire": {
+        try {
+          const data = await mediafire(url);
+          if (!data || !data.url) {
+            throw new Error("No URL found in MediaFire response");
+          }
+          videoUrl = data.url;
+        } catch (error) {
+          throw new Error(`MediaFire download failed: ${error.message}`);
+        }
+        break;
+      }
+      case "twitter": {
+        try {
+          // Validate and clean the Twitter URL
+          const cleanUrl = validateTwitterUrl(url);
+          const data = await TwitterDL(cleanUrl, {});
+          
+          if (data && data.result) {
+            // Try multiple possible response structures
+            if (data.result.media && data.result.media[0] && 
+                data.result.media[0].videos && data.result.media[0].videos[0] && 
+                data.result.media[0].videos[0].url) {
+              videoUrl = data.result.media[0].videos[0].url;
+            } else if (data.result.video && data.result.video[0] && data.result.video[0].url) {
+              videoUrl = data.result.video[0].url;
+            } else if (data.result.url) {
+              videoUrl = data.result.url;
+            } else if (data.result.media && data.result.media[0] && data.result.media[0].url) {
+              videoUrl = data.result.media[0].url;
+            } else {
+              // Search for any video URL in the response
+              const findVideoUrl = (obj) => {
+                if (typeof obj === 'string' && obj.includes('http') && 
+                    (obj.includes('.mp4') || obj.includes('video') || obj.includes('media'))) {
+                  return obj;
+                }
+                if (typeof obj === 'object' && obj !== null) {
+                  for (const key in obj) {
+                    const result = findVideoUrl(obj[key]);
+                    if (result) return result;
+                  }
+                }
+                return null;
+              };
+              
+              const foundUrl = findVideoUrl(data.result);
+              if (foundUrl) {
+                videoUrl = foundUrl;
+              } else {
+                throw new Error("No video URL found in Twitter response structure");
+              }
+            }
+          } else {
+            throw new Error("Invalid Twitter response structure");
+          }
+        } catch (error) {
+          throw new Error(`Twitter download failed: ${error.message}`);
+        }
+        break;
+      }
+      default:
+        throw new Error("Platform not supported or invalid link.");
+    }
+
+    if (!videoUrl || !videoUrl.includes("http")) {
+      throw new Error("Returned video URL is invalid or unavailable.");
+    }
+    
+    // Download the video with better error handling
+    const response = await axios({ 
+      url: videoUrl, 
+      method: "GET", 
+      responseType: "stream",
+      timeout: 30000,
+      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'
+      }
+    });
+    
+    // Create minimal unique file name in output dir
+    let fileName = path.join(OUTPUT_DIR, `v_${uuidv4().slice(0,4)}.mp4`);
+    
+    const videoWriter = fs.createWriteStream(fileName);
+    response.data.pipe(videoWriter);
+
+    return new Promise((resolve, reject) => {
+      videoWriter.on("finish", async () => {
+        try {
+          const finalFilePath = await processDownloadedFile(fileName, config, platform);
+          resolve(finalFilePath);
+        } catch (error) {
+          reject(new Error(`Error processing downloaded video: ${error.message}`));
+        }
+      });
+      videoWriter.on("error", (error) => {
+        reject(new Error(`Error saving video: ${error.message}`));
+      });
+    });
+  } catch (error) {
+    throw new Error(`Failed to download video: ${error.message}`);
+  }
+}
+
+// Function for direct video download
+async function downloadDirectVideo(url, config) {
+  try {
+    const response = await axios({ 
+      url: url, 
+      method: "GET", 
+      responseType: "stream",
+      timeout: 30000,
+      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'
+      }
+    });
+    
+    // Create minimal unique file name in output dir
+    let fileName = path.join(OUTPUT_DIR, `v_${uuidv4().slice(0,4)}.mp4`);
+    
+    const videoWriter = fs.createWriteStream(fileName);
+    response.data.pipe(videoWriter);
+
+    return new Promise((resolve, reject) => {
+      videoWriter.on("finish", async () => {
+        try {
+          const finalFilePath = await processDownloadedFile(fileName, config, "unknown");
+          resolve(finalFilePath);
+        } catch (error) {
+          reject(new Error(`Error processing downloaded video: ${error.message}`));
+        }
+      });
+      videoWriter.on("error", (error) => {
+        reject(new Error(`Error saving video: ${error.message}`));
+      });
+    });
+  } catch (error) {
+    throw new Error(`Failed to download video directly: ${error.message}`);
+  }
+}
+
+// Function to rotate video
+async function rotateVideo(fileName, rotation) {
+  const outputPath = path.join(OUTPUT_DIR, `vr_${uuidv4().slice(0,4)}.mp4`);
+  let angle;
+  switch (rotation.toLowerCase()) {
+    case "left": angle = "transpose=2"; break;
+    case "right": angle = "transpose=1"; break;
+    case "180":
+    case "flip": angle = "transpose=2,transpose=2"; break;
+    default: throw new Error("Invalid rotation value. Use 'left', 'right', '180', or 'flip'.");
+  }
+
+  return new Promise((resolve, reject) => {
+    ffmpeg(fileName)
+      .videoFilters(angle)
+      .output(outputPath)
+      .on('end', async () => {
+        await safeUnlinkWithRetry(fileName);
+        resolve(outputPath);
+      })
+      .on('error', (err) => reject(new Error(`Error during video rotation: ${err.message}`)))
+      .run();
+  });
+}
+
+// Function to extract URL from string
+function extractUrlFromString(text) {
+  const urlRegex = /(https?:\/\/[^\s]+)/;
+  const match = text.match(urlRegex);
+  return match ? match[0] : null;
+}
+
+// Function to delete temporary videos
+async function deleteTempVideos() {
+  try {
+    if (!fs.existsSync(TEMP_DIR)) return;
+    const files = fs.readdirSync(TEMP_DIR);
+    const tempVideoFiles = files.filter(file => /^temp_video.*\.mp4$/.test(file));
+    for (const file of tempVideoFiles) {
+      safeUnlink(path.join(TEMP_DIR, file));
+    }
+  } catch (error) {
+    if (error && error.code !== 'ENOENT') {
+      console.error(`Error reading directory for temp file deletion: ${error.message}`);
+    }
+  }
+}
+
+// Enhanced cleanup function for all temporary files
+async function cleanupTempFiles() {
+  try {
+    if (!fs.existsSync(TEMP_DIR)) return;
+    const files = fs.readdirSync(TEMP_DIR);
+    const tempFiles = files.filter(file => 
+      /^temp_video.*\.mp4$/.test(file) || 
+      /_audio\.mp3$/.test(file) ||
+      /_rotated\.mp4$/.test(file) ||
+      /_cropped\.mp4$/.test(file) ||
+      /_compressed\.mp4$/.test(file)
+    );
+    for (const file of tempFiles) {
+      await safeUnlinkWithRetry(path.join(TEMP_DIR, file));
+    }
+  } catch (error) {
+    if (error && error.code !== 'ENOENT') {
+      console.error(`Error during temp file cleanup: ${error.message}`);
+    }
+  }
+}
+
+// Cleanup files in output folder older than OUTPUT_RETENTION_MIN
+async function cleanupOutputFiles() {
+  try {
+    if (!fs.existsSync(OUTPUT_DIR)) return;
+    const files = fs.readdirSync(OUTPUT_DIR);
+    const now = Date.now();
+    const maxAgeMs = OUTPUT_RETENTION_MIN * 60 * 1000;
+    for (const file of files) {
+      // Only consider our generated short names
+      if (!/^(v_|vr_|vc_|vx_|vf_|a_)[0-9a-f]{4}/i.test(file)) continue;
+      const full = path.join(OUTPUT_DIR, file);
+      try {
+        const st = fs.statSync(full);
+        if (now - st.mtimeMs > maxAgeMs) {
+          await safeUnlinkWithRetry(full);
+        }
+      } catch (_) {}
+    }
+  } catch (_) {}
+}
+
+// Schedule periodic cleanup (every 10 minutes)
+setInterval(() => {
+  cleanupTempFiles();
+  cleanupOutputFiles();
+}, 60 * 1000);
+// Run once at startup
+cleanupOutputFiles();
+
+// Function to auto-crop video
+async function autoCrop(fileName) {
+  const inputPath = fileName;
+  const outputPath = path.join(OUTPUT_DIR, `vc_${uuidv4().slice(0,4)}.mp4`);
+
+  return new Promise((resolve, reject) => {
+    let cropValues = null;
+    ffmpeg(inputPath)
+      .outputOptions('-vf', 'cropdetect=24:16:0')
+      .outputFormat('null')
+      .output('-')
+      .on('stderr', function(stderrLine) {
+        const cropMatch = stderrLine.match(/crop=([0-9]+):([0-9]+):([0-9]+):([0-9]+)/);
+        if (cropMatch) {
+          cropValues = `crop=${cropMatch[1]}:${cropMatch[2]}:${cropMatch[3]}:${cropMatch[4]}`;
+        }
+      })
+      .on('end', function() {
+        if (!cropValues) {
+          resolve(inputPath);
+          return;
+        }
+        ffmpeg(inputPath)
+          .outputOptions('-vf', cropValues)
+          .output(outputPath)
+          .on('end', async () => {
+            await safeUnlinkWithRetry(inputPath);
+            resolve(outputPath);
+          })
+          .on('error', (err) => reject(new Error(`Error during auto-cropping: ${err.message}`)))
+          .run();
+      });
+  });
+}
+
+// Function to check and compress video
+async function checkAndCompressVideo(filePath, limitSizeMB, platform = null) {
+  // Não comprimir vídeos do YouTube
+  if (platform === "youtube") return filePath;
+
+  if (!limitSizeMB) return filePath;
+
+  const stats = fs.statSync(filePath);
+  const fileSizeInBytes = stats.size;
+  const limitSizeInBytes = limitSizeMB * 1024 * 1024;
+
+  if (fileSizeInBytes <= limitSizeInBytes) {
+    return filePath;
+  }
+
+  const outputPath = path.join(OUTPUT_DIR, `vx_${uuidv4().slice(0,4)}.mp4`);
+
+  return new Promise((resolve, reject) => {
+    ffmpeg(filePath)
+      .outputOptions(
+        '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2',
+        '-crf', '28',
+        '-preset', 'slow'
+      )
+      .output(outputPath)
+      .on('end', async () => {
+        await safeUnlinkWithRetry(filePath);
+        resolve(outputPath);
+      })
+      .on('error', (err) => {
+        resolve(filePath);
+      })
+      .run();
+  });
+}
+
+// Video format conversion
+async function convertVideoFormat(inputPath, targetFormat) {
+  try {
+    const fmt = String(targetFormat).toLowerCase();
+
+    if (fmt === "mp3") {
+      const audioPath = await extractAudioMp3(inputPath);
+      await safeUnlinkWithRetry(inputPath);
+      return audioPath;
+    }
+
+    const supported = ["mp4", "mov", "webm", "mkv"];
+    if (!supported.includes(fmt)) return inputPath;
+
+    const outputPath = path.join(OUTPUT_DIR, `vf_${uuidv4().slice(0,4)}.${fmt}`);
+
+    const ff = ffmpeg(inputPath);
+    switch (fmt) {
+      case "mp4":
+      case "mov":
+      case "mkv":
+        ff.outputOptions("-c:v","libx264","-pix_fmt","yuv420p","-c:a","aac","-b:a","192k");
+        break;
+      case "webm":
+        ff.outputOptions("-c:v","libvpx-vp9","-b:v","0","-crf","30","-c:a","libopus","-b:a","128k");
+        break;
+      default:
+        return inputPath;
+    }
+
+    return await new Promise((resolve) => {
+      ff.output(outputPath)
+        .on("end", async () => { await safeUnlinkWithRetry(inputPath); resolve(outputPath); })
+        .on("error", () => resolve(inputPath))
+        .run();
+    });
+  } catch (_) {
+    return inputPath;
+  }
+}
+
+// Function to get file name from URL
+function getFileName(url) {
+  try {
+    const urlObj = new URL(url);
+    const pathname = urlObj.pathname;
+    const parts = pathname.split('/');
+    let fileName = parts[parts.length - 1];
+    if (!fileName || fileName.includes('.')) {
+      fileName = `video_${Date.now()}.mp4`;
+    }
+    return fileName;
+  } catch (error) {
+    console.error("Error getting file name from URL:", error.message);
+    return `video_${Date.now()}.mp4`;
+  }
+}
+
+// Function to unshorten URLs
+async function unshortenUrl(url) {
+  try {
+    // Special handling for Facebook URLs
+    if (url.includes('facebook.com') || url.includes('fb.watch') || url.includes('fb.com')) {
+      const response = await axios.get(url, {
+        maxRedirects: 10,
+        timeout: 10000,
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+          'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+          'Accept-Language': 'en-US,en;q=0.5',
+          'Accept-Encoding': 'gzip, deflate',
+          'Connection': 'keep-alive',
+          'Upgrade-Insecure-Requests': '1'
+        },
+        validateStatus: function (status) {
+          return status >= 200 && status < 400; // Accept redirects
+        }
+      });
+      
+      // Get the final URL after all redirects
+      const finalUrl = response.request.res.responseUrl || response.config.url;
+      return finalUrl;
+    }
+    
+    // For other URLs, use the original method
+    const response = await axios.head(url, { 
+      maxRedirects: 10,
+      timeout: 10000,
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+      }
+    });
+    return response.request.res.responseUrl || url;
+  } catch (error) {
+    return url;
+  }
+}
+
+// Função para baixar áudio em mp3
+const AudioDownloader = async (url, options = {}) => {
+  assertAuthorized();
+  const config = { ...defaultConfig, ...options };
+
+  if (!url || !url.includes("http")) {
+    throw new Error("Please specify a valid video URL.");
+  }
+
+  url = await unshortenUrl(extractUrlFromString(url));
+
+  const blacklisted = blacklistLink(url);
+  if (blacklisted) {
+    throw new Error(`URL not supported: ${blacklisted.reason}`);
+  }
+
+  // Verificar se o link está na lista de plataformas suportadas
+  if (!isVideoLink(url)) {
+    throw new Error("This URL is not from a supported platform. Supported platforms: Instagram, X(Twitter), TikTok, Facebook, and YouTube");
+  }
+
+  await cleanupTempFiles(); // Clean up previous temp files
+
+  let downloadedFilePath = null;
+  let audioFilePath = null;
+
+  try {
+    let platform = getPlatformType(url);
+    if (platform === "y124outube") {
+      // Baixar áudio do YouTube usando ytdlp-nodejs
+      let fileName = "temp_audio.mp3";
+      let count = 1;
+      while (fs.existsSync(fileName)) {
+        fileName = `temp_audio_${count}.mp3`;
+        count++;
+      }
+      await downloadYoutubeAudio(url, fileName);
+      audioFilePath = fileName;
+      const result = await uploadToGoFileIfNeeded(audioFilePath);
+      return result;
+    }
+    // Baixar vídeo normalmente
+    try {
+      downloadedFilePath = await downloadSmartVideo(url, config);
+    } catch (error) {
+      try {
+        const fallbackUrl = await tryFallbackDownload(url);
+        downloadedFilePath = await downloadDirectVideo(fallbackUrl, config);
+      } catch (fallbackError) {
+        throw new Error(`Failed to download video with both methods: ${fallbackError.message}`);
+      }
+    }
+
+    if (downloadedFilePath) {
+      // Extrair áudio em mp3
+      audioFilePath = await extractAudioMp3(downloadedFilePath);
+      
+      // Remove o arquivo de vídeo temporário após extrair o áudio
+      await safeUnlinkWithRetry(downloadedFilePath);
+      
+      const result = await uploadToGoFileIfNeeded(audioFilePath);
+      return result;
+    } else {
+      throw new Error("Failed to obtain downloaded file path.");
+    }
+  } catch (error) {
+    // Clean up any remaining temp files on error
+    await cleanupTempFiles();
+    throw new Error(`Error in AudioDownloader: ${error.message}`);
+  }
+};
+
+// Função para extrair áudio em mp3 usando ffmpeg
+async function extractAudioMp3(videoPath) {
+  return new Promise((resolve, reject) => {
+    const audioPath = path.join(OUTPUT_DIR, `a_${uuidv4().slice(0,4)}.mp3`);
+    ffmpeg(videoPath)
+      .noVideo()
+      .audioCodec('libmp3lame')
+      .audioBitrate(192)
+      .format('mp3')
+      .save(audioPath)
+      .on('end', () => {
+        resolve(audioPath);
+      })
+      .on('error', (err) => {
+        reject(new Error(`Error extracting audio: ${err.message}`));
+      });
+  });
+}
+
+MediaDownloader.isVideoLink = isVideoLink;
+AudioDownloader.isVideoLink = isVideoLink;
+
+module.exports = {
+  MediaDownloader,
+  AudioDownloader,
+  cleanupTempFiles,
+  safeUnlink,
+  safeUnlinkWithRetry,
+  setAuthKey
+};