frostpv 1.0.7 → 1.0.8

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, youtube } = 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,53 @@ 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";
-  
+  if (lowerUrl.includes("youtube.com") || lowerUrl.includes("youtu.be") || lowerUrl.includes("m.youtube.com")) return "youtube";
+
   return "unknown";
 }
 
+// Function to get direct video URL from Twitter using yt-dlp
+async function downloadTwitterWithYtDlp(url) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const ytdlp = new YtDlp({ ffmpegPath });
+      // Use -g to get URL, -f "best[ext=mp4]/best" to get best quality single file if possible
+      const args = [
+        url,
+        '-g',
+        '-f', 'best[ext=mp4]/best'
+      ];
+
+      const result = await ytdlp.execAsync(args);
+      // yt-dlp might return multiple lines if it finds separate audio/video streams
+      // We take the first one, but for Twitter it is usually a single mp4 file
+      const videoUrl = result.trim().split('\n')[0];
+
+      if (videoUrl && videoUrl.startsWith('http')) {
+        resolve(videoUrl);
+      } else {
+        reject(new Error('yt-dlp did not return a valid URL'));
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
 // 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 +455,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
               }
             }
           ];
-          
+
           for (const method of methods) {
             try {
               videoUrl = await method();
@@ -438,7 +466,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           break;
         }
-        
+
         case "tiktok": {
           // Try multiple TikTok methods
           const methods = [
@@ -473,7 +501,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 +512,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           break;
         }
-        
+
         case "facebook": {
           // Try multiple Facebook methods
           const methods = [
@@ -508,7 +536,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 +547,46 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           break;
         }
-        
+
         case "twitter": {
-          // Try multiple Twitter methods with better response handling
+          // Try using yt-dlp first (Most reliable), then fallback to existing methods
           const methods = [
+            async () => {
+              // Priority 1: yt-dlp
+              return await downloadTwitterWithYtDlp(url);
+            },
             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 +597,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 +619,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 +653,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 +695,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 +724,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
               }
             }
           ];
-          
+
           for (const method of methods) {
             try {
               videoUrl = await method();
@@ -703,12 +735,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 +778,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 +797,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 +820,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}`);
@@ -835,9 +867,8 @@ const MediaDownloader = async (url, options = {}) => {
 
   // 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, Facebook");
-  }
+  // YouTube is now supported
+
 
   await cleanupTempFiles(); // Clean up previous temp files
 
@@ -849,21 +880,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
+
+      // YouTube doesn't use fallback method - it has its own specific implementation in downloadSmartVideo
       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 +1017,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");
           }
@@ -1066,12 +1097,12 @@ async function downloadSmartVideo(url, config) {
           // 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) {
+            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;
@@ -1082,8 +1113,8 @@ async function downloadSmartVideo(url, config) {
             } 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'))) {
+                if (typeof obj === 'string' && obj.includes('http') &&
+                  (obj.includes('.mp4') || obj.includes('video') || obj.includes('media'))) {
                   return obj;
                 }
                 if (typeof obj === 'object' && obj !== null) {
@@ -1094,7 +1125,7 @@ async function downloadSmartVideo(url, config) {
                 }
                 return null;
               };
-              
+
               const foundUrl = findVideoUrl(data.result);
               if (foundUrl) {
                 videoUrl = foundUrl;
@@ -1110,6 +1141,56 @@ async function downloadSmartVideo(url, config) {
         }
         break;
       }
+      case "youtube": {
+        try {
+          const data = await youtube(url);
+          // Try to find the video URL in the response
+          // Common patterns: data.url, data.mp4, data.link, or direct string
+
+          if (!data) throw new Error("No data returned from youtube downloader");
+
+          // Recursive function to find a valid video URL in the object
+          const findVideoUrl = (obj) => {
+            if (!obj) return null;
+            if (typeof obj === 'string' && obj.startsWith('http')) return obj;
+
+            if (Array.isArray(obj)) {
+              for (const item of obj) {
+                const found = findVideoUrl(item);
+                if (found) return found;
+              }
+            } else if (typeof obj === 'object') {
+              // Prioritize certain keys
+              const priorities = ['url', 'link', 'download', 'mp4', 'video', 'src'];
+              for (const key of priorities) {
+                if (obj[key]) {
+                  const found = findVideoUrl(obj[key]);
+                  if (found) return found;
+                }
+              }
+              // If not found in priorities, check all keys
+              for (const key of Object.keys(obj)) {
+                if (!priorities.includes(key)) {
+                  const found = findVideoUrl(obj[key]);
+                  if (found) return found;
+                }
+              }
+            }
+            return null;
+          };
+
+          videoUrl = findVideoUrl(data);
+
+          if (!videoUrl) {
+            console.log('YouTube data dump:', JSON.stringify(data, null, 2)); // Debug log since we can't test
+            throw new Error("Could not extract video URL from YouTube response");
+          }
+
+        } catch (error) {
+          throw new Error(`YouTube download failed: ${error.message}`);
+        }
+        break;
+      }
       default:
         throw new Error("Platform not supported or invalid link.");
     }
@@ -1117,21 +1198,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 +1237,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 +1297,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 +1312,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 +1363,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 +1396,9 @@ async function cleanupOutputFiles() {
         if (now - st.mtimeMs > maxAgeMs) {
           await safeUnlinkWithRetry(full);
         }
-      } catch (_) {}
+      } catch (_) { }
     }
-  } catch (_) {}
+  } catch (_) { }
 }
 
 // Schedule periodic cleanup (every 10 minutes)
@@ -1331,7 +1412,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 +1420,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 +1459,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 +1494,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 +1561,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 +1637,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 +1656,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.7",
+  "version": "1.0.8",
   "description": "downloads",
   "main": "index.js",
   "scripts": {