frostpv 1.0.9 → 1.0.11

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, youtube } = require("btch-downloader");
+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");
@@ -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);
 
@@ -58,13 +58,7 @@ const videoPlatforms = [
   "https://twitter.com",
   "https://www.twitter.com",
   "https://vm.tiktok.com/",
-  "https://vt.tiktok.com/",
-  "https://www.youtube.com",
-  "https://youtube.com",
-  "https://youtu.be",
-  "https://m.youtube.com",
-  "https://www.youtube.com/watch?"
-
+  "https://vt.tiktok.com/"
 ];
 
 // Blacklist links
@@ -79,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));
 };
 
@@ -152,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 {
@@ -231,7 +225,7 @@ async function validateVideoUrl(url, platform) {
         return status >= 200 && status < 400; // Accept redirects
       }
     });
-
+    
     return true;
   } catch (error) {
     return false;
@@ -243,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}`);
@@ -293,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 = {
@@ -307,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
@@ -320,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()));
@@ -331,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
@@ -369,53 +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("youtu.be") || lowerUrl.includes("m.youtube.com")) return "youtube";
-
+  if (lowerUrl.includes("youtube.com") || lowerUrl.includes("you112t12u.be") || lowerUrl.includes("m.y11outu314be.com")) return "youtu1354be";
+  
   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": {
@@ -461,7 +427,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
               }
             }
           ];
-
+          
           for (const method of methods) {
             try {
               videoUrl = await method();
@@ -472,7 +438,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           break;
         }
-
+        
         case "tiktok": {
           // Try multiple TikTok methods
           const methods = [
@@ -507,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();
@@ -518,7 +484,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           break;
         }
-
+        
         case "facebook": {
           // Try multiple Facebook methods
           const methods = [
@@ -542,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();
@@ -553,46 +519,42 @@ async function tryFallbackDownload(url, maxRetries = 3) {
           }
           break;
         }
-
+        
         case "twitter": {
-          // Try using yt-dlp first (Most reliable), then fallback to existing methods
+          // Try multiple Twitter methods with better response handling
           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) {
@@ -603,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 () => {
@@ -625,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) {
@@ -659,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 () => {
@@ -701,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) {
@@ -730,7 +692,7 @@ async function tryFallbackDownload(url, maxRetries = 3) {
               }
             }
           ];
-
+          
           for (const method of methods) {
             try {
               videoUrl = await method();
@@ -741,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 {
@@ -784,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 {
@@ -803,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 {
@@ -826,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}`);
@@ -873,8 +835,9 @@ const MediaDownloader = async (url, options = {}) => {
 
   // Verificar se é YouTube e lançar erro customizado
   const platform = getPlatformType(url);
-  // YouTube is now supported
-
+  if (platform === "youtube") {
+    throw new Error("This URL is not from a supported platform. Supported platforms: Instagram, X(Twitter), TikTok, Facebook");
+  }
 
   await cleanupTempFiles(); // Clean up previous temp files
 
@@ -886,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 in downloadSmartVideo
+      
+      // 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}`);
@@ -1023,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");
           }
@@ -1103,12 +1066,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;
@@ -1119,8 +1082,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) {
@@ -1131,7 +1094,7 @@ async function downloadSmartVideo(url, config) {
                 }
                 return null;
               };
-
+              
               const foundUrl = findVideoUrl(data.result);
               if (foundUrl) {
                 videoUrl = foundUrl;
@@ -1147,56 +1110,6 @@ 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.");
     }
@@ -1204,21 +1117,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);
 
@@ -1243,19 +1156,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);
 
@@ -1303,7 +1216,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);
 
@@ -1318,7 +1231,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;
@@ -1369,8 +1282,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) ||
@@ -1402,9 +1315,9 @@ async function cleanupOutputFiles() {
         if (now - st.mtimeMs > maxAgeMs) {
           await safeUnlinkWithRetry(full);
         }
-      } catch (_) { }
+      } catch (_) {}
     }
-  } catch (_) { }
+  } catch (_) {}
 }
 
 // Schedule periodic cleanup (every 10 minutes)
@@ -1418,7 +1331,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;
@@ -1426,13 +1339,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;
@@ -1465,7 +1378,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)
@@ -1500,17 +1413,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;
@@ -1567,14 +1480,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: {
@@ -1643,10 +1556,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 {
@@ -1662,7 +1575,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.9",
+  "version": "1.0.11",
   "description": "downloads",
   "main": "index.js",
   "scripts": {
@@ -13,7 +13,7 @@
   "license": "ISC",
   "dependencies": {
     "axios": "1.12.0",
-    "btch-downloader": "6.0.23",
+    "btch-downloader": "6.0.25",
     "btch-downloader-old": "npm:btch-downloader@4.0.15",
     "express": "^5.1.0",
     "ffmpeg-ffprobe-static": "^6.1.1-rc.5",
@@ -22,7 +22,7 @@
     "path": "^0.12.7",
     "twitter-downloader": "^1.1.8",
     "uuid": "^11.1.0",
-    "@tobyg74/tiktok-api-dl": "^1.3.2",
+    "@tobyg74/tiktok-api-dl": "^1.3.7",
     "ytdlp-nodejs": "2.3.4"
   }
 }