frostpv 1.0.11 → 1.0.13

package/index.js

@@ -4,7 +4,7 @@ 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 { igdl, ttdl, fbdown, mediafire, capcut, gdrive, pinterest, twitter } = require("btch-downloader");
 const { TwitterDL } = require("twitter-downloader");
 const btch = require("btch-downloader");
 const btchOld = require("btch-downloader-old");
@@ -21,10 +21,10 @@ 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 (_) {}
+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 (_) {}
+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);
 
@@ -73,7 +73,7 @@ const isVideoLink = (link) => {
     const u = new URL(link);
     const host = (u.hostname || '').toLowerCase();
     if (host.endsWith('pintere21313213st.com')) return true;
-  } catch (_) {}
+  } catch (_) { }
   return videoPlatforms.some(platform => link.startsWith(platform));
 };
 
@@ -146,14 +146,14 @@ 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 {
@@ -225,7 +225,7 @@ async function validateVideoUrl(url, platform) {
         return status >= 200 && status < 400; // Accept redirects
       }
     });
-    
+
     return true;
   } catch (error) {
     return false;
@@ -237,18 +237,18 @@ 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}`);
@@ -287,10 +287,10 @@ async function downloadYoutubeAudio(url, outputPath) {
     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 = {
@@ -301,11 +301,11 @@ async function downloadYoutubeAudio(url, outputPath) {
           },
           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
@@ -314,7 +314,7 @@ async function downloadYoutubeAudio(url, outputPath) {
           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()));
@@ -325,18 +325,18 @@ async function downloadYoutubeAudio(url, outputPath) {
       } 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
@@ -363,25 +363,25 @@ async function downloadYoutubeAudio(url, outputPath) {
 // 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": {
@@ -427,7 +427,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
               }
             }
           ];
-          
+
           for (const method of methods) {
             try {
               videoUrl = await method();
@@ -438,7 +438,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           break;
         }
-        
+
         case "tiktok": {
           // Try multiple TikTok methods
           const methods = [
@@ -473,7 +473,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
               throw new Error("No valid video in Tiktok.Downloader v2 response");
             }
           ];
-          
+
           for (const method of methods) {
             try {
               videoUrl = await method();
@@ -484,7 +484,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           break;
         }
-        
+
         case "facebook": {
           // Try multiple Facebook methods
           const methods = [
@@ -508,7 +508,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
               throw new Error("No valid video in fbdown response with custom headers");
             }
           ];
-          
+
           for (const method of methods) {
             try {
               videoUrl = await method();
@@ -519,42 +519,42 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           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) {
+                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'))) {
+                  if (typeof obj === 'string' && obj.includes('http') &&
+                    (obj.includes('.mp4') || obj.includes('video') || obj.includes('media'))) {
                     return obj;
                   }
                   if (typeof obj === 'object' && obj !== null) {
@@ -565,13 +565,13 @@ async function tryFallbackDownload(url, maxRetries = 3) {
                   }
                   return null;
                 };
-                
+
                 const foundUrl = findVideoUrl(data.result);
                 if (foundUrl) {
                   return foundUrl;
                 }
               }
-              
+
               throw new Error("No valid video URL found in TwitterDL response structure");
             },
             async () => {
@@ -587,30 +587,30 @@ async function tryFallbackDownload(url, maxRetries = 3) {
                   '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) {
+                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'))) {
+                  if (typeof obj === 'string' && obj.includes('http') &&
+                    (obj.includes('.mp4') || obj.includes('video') || obj.includes('media'))) {
                     return obj;
                   }
                   if (typeof obj === 'object' && obj !== null) {
@@ -621,13 +621,13 @@ async function tryFallbackDownload(url, maxRetries = 3) {
                   }
                   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 () => {
@@ -663,9 +663,9 @@ async function tryFallbackDownload(url, maxRetries = 3) {
                       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) {
+                        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) {
@@ -692,7 +692,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
               }
             }
           ];
-          
+
           for (const method of methods) {
             try {
               videoUrl = await method();
@@ -703,12 +703,12 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           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 {
@@ -746,10 +746,10 @@ async function tryFallbackDownload(url, maxRetries = 3) {
             };
             mediaUrl = pickFrom(data);
             if (mediaUrl) return mediaUrl;
-          } catch (_) {}
+          } catch (_) { }
           break;
         }
-        
+
         default: {
           // Generic fallback for unknown platforms
           try {
@@ -765,18 +765,18 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           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, { 
+          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 {
@@ -788,7 +788,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
       } 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}`);
@@ -849,21 +849,21 @@ const MediaDownloader = async (url, options = {}) => {
       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}`);
@@ -986,15 +986,15 @@ async function downloadSmartVideo(url, config) {
             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, { 
+          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");
           }
@@ -1063,47 +1063,45 @@ async function downloadSmartVideo(url, config) {
       }
       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;
+          const data = await twitter(url);
+          if (data && data.url) {
+            // Se data.url for um array, procuramos por qualidade HD
+            if (Array.isArray(data.url)) {
+              // Tentar encontrar HD especificamente
+              const hdVideo = data.url.find(v => v.hd);
+              if (hdVideo) {
+                videoUrl = hdVideo.hd;
               } else {
-                throw new Error("No video URL found in Twitter response structure");
+                // Tentar encontrar por label ou qualidade
+                const highQuality = data.url.find(v =>
+                  (v.quality && typeof v.quality === 'string' && v.quality.toUpperCase().includes('HD')) ||
+                  (v.label && typeof v.label === 'string' && v.label.toUpperCase().includes('HD'))
+                );
+
+                if (highQuality) {
+                  videoUrl = highQuality.url;
+                } else {
+                  // Fallback: pega o primeiro que tiver url
+                  const anyVideo = data.url.find(v => v.url);
+                  videoUrl = anyVideo ? anyVideo.url : data.url[0];
+                }
               }
+            } else if (typeof data.url === 'string') {
+              videoUrl = data.url;
             }
-          } else {
-            throw new Error("Invalid Twitter response structure");
+          }
+
+          if (!videoUrl) {
+            // Fallback para estrutura antiga ou diferente
+            if (Array.isArray(data) && data[0] && data[0].url) {
+              videoUrl = data[0].url;
+            } else if (data && data.HD) {
+              videoUrl = data.HD;
+            }
+          }
+
+          if (!videoUrl) {
+            throw new Error("No video URL found in btch-downloader twitter response");
           }
         } catch (error) {
           throw new Error(`Twitter download failed: ${error.message}`);
@@ -1117,21 +1115,21 @@ async function downloadSmartVideo(url, config) {
     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", 
+    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`);
-    
+    let fileName = path.join(OUTPUT_DIR, `v_${uuidv4().slice(0, 4)}.mp4`);
+
     const videoWriter = fs.createWriteStream(fileName);
     response.data.pipe(videoWriter);
 
@@ -1156,19 +1154,19 @@ async function downloadSmartVideo(url, config) {
 // Function for direct video download
 async function downloadDirectVideo(url, config) {
   try {
-    const response = await axios({ 
-      url: url, 
-      method: "GET", 
+    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`);
-    
+    let fileName = path.join(OUTPUT_DIR, `v_${uuidv4().slice(0, 4)}.mp4`);
+
     const videoWriter = fs.createWriteStream(fileName);
     response.data.pipe(videoWriter);
 
@@ -1216,7 +1214,7 @@ async function downloadGenericFile(url, preferredExt = null) {
       else ext = 'bin';
     }
 
-    const fileName = path.join(OUTPUT_DIR, `v_${uuidv4().slice(0,4)}.${ext}`);
+    const fileName = path.join(OUTPUT_DIR, `v_${uuidv4().slice(0, 4)}.${ext}`);
     const writer = fs.createWriteStream(fileName);
     response.data.pipe(writer);
 
@@ -1231,7 +1229,7 @@ async function downloadGenericFile(url, preferredExt = null) {
 
 // Function to rotate video
 async function rotateVideo(fileName, rotation) {
-  const outputPath = path.join(OUTPUT_DIR, `vr_${uuidv4().slice(0,4)}.mp4`);
+  const outputPath = path.join(OUTPUT_DIR, `vr_${uuidv4().slice(0, 4)}.mp4`);
   let angle;
   switch (rotation.toLowerCase()) {
     case "left": angle = "transpose=2"; break;
@@ -1282,8 +1280,8 @@ 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) || 
+    const tempFiles = files.filter(file =>
+      /^temp_video.*\.mp4$/.test(file) ||
       /_audio\.mp3$/.test(file) ||
       /_rotated\.mp4$/.test(file) ||
       /_cropped\.mp4$/.test(file) ||
@@ -1315,9 +1313,9 @@ async function cleanupOutputFiles() {
         if (now - st.mtimeMs > maxAgeMs) {
           await safeUnlinkWithRetry(full);
         }
-      } catch (_) {}
+      } catch (_) { }
     }
-  } catch (_) {}
+  } catch (_) { }
 }
 
 // Schedule periodic cleanup (every 10 minutes)
@@ -1331,7 +1329,7 @@ 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`);
+  const outputPath = path.join(OUTPUT_DIR, `vc_${uuidv4().slice(0, 4)}.mp4`);
 
   return new Promise((resolve, reject) => {
     let cropValues = null;
@@ -1339,13 +1337,13 @@ async function autoCrop(fileName) {
       .outputOptions('-vf', 'cropdetect=24:16:0')
       .outputFormat('null')
       .output('-')
-      .on('stderr', function(stderrLine) {
+      .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() {
+      .on('end', function () {
         if (!cropValues) {
           resolve(inputPath);
           return;
@@ -1378,7 +1376,7 @@ async function checkAndCompressVideo(filePath, limitSizeMB, platform = null) {
     return filePath;
   }
 
-  const outputPath = path.join(OUTPUT_DIR, `vx_${uuidv4().slice(0,4)}.mp4`);
+  const outputPath = path.join(OUTPUT_DIR, `vx_${uuidv4().slice(0, 4)}.mp4`);
 
   return new Promise((resolve, reject) => {
     ffmpeg(filePath)
@@ -1413,17 +1411,17 @@ async function convertVideoFormat(inputPath, targetFormat) {
     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 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");
+        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");
+        ff.outputOptions("-c:v", "libvpx-vp9", "-b:v", "0", "-crf", "30", "-c:a", "libopus", "-b:a", "128k");
         break;
       default:
         return inputPath;
@@ -1480,14 +1478,14 @@ async function unshortenUrl(url) {
           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, { 
+    const response = await axios.head(url, {
       maxRedirects: 10,
       timeout: 10000,
       headers: {
@@ -1556,10 +1554,10 @@ const AudioDownloader = async (url, options = {}) => {
     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 {
@@ -1575,7 +1573,7 @@ const AudioDownloader = async (url, options = {}) => {
 // 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`);
+    const audioPath = path.join(OUTPUT_DIR, `a_${uuidv4().slice(0, 4)}.mp3`);
     ffmpeg(videoPath)
       .noVideo()
       .audioCodec('libmp3lame')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frostpv",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "downloads",
   "main": "index.js",
   "scripts": {