frostpv 1.0.11 → 1.0.12

package/index.js

@@ -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}`);
@@ -886,16 +886,25 @@ const MediaDownloader = async (url, options = {}) => {
 // 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());
+
+  // Check if file is video or image based on extension
+  const ext = path.extname(processedFile).toLowerCase();
+  const isVideo = ['.mp4', '.mov', '.webm', '.mkv'].includes(ext);
+
+  // Only apply video processing if it is a video
+  if (isVideo) {
+    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;
 }
 
@@ -986,15 +995,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 +1075,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 +1091,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 +1103,7 @@ async function downloadSmartVideo(url, config) {
                 }
                 return null;
               };
-              
+
               const foundUrl = findVideoUrl(data.result);
               if (foundUrl) {
                 videoUrl = foundUrl;
@@ -1117,35 +1126,47 @@ 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", 
+
+    // Download the video/image 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'
       }
     });
-    
+
+    // Detect file type from content-type
+    const contentType = response.headers['content-type'] || 'video/mp4';
+    let ext = 'mp4'; // default
+
+    if (contentType.includes('image/jpeg')) ext = 'jpg';
+    else if (contentType.includes('image/png')) ext = 'png';
+    else if (contentType.includes('image/webp')) ext = 'webp';
+    else if (contentType.includes('image/gif')) ext = 'gif';
+    else if (contentType.includes('video/webm')) ext = 'webm';
+    else if (contentType.includes('video/quicktime')) ext = 'mov';
+    else if (contentType.includes('video/x-matroska')) ext = 'mkv';
+
     // 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);
+    let fileName = path.join(OUTPUT_DIR, `v_${uuidv4().slice(0, 4)}.${ext}`);
+
+    const writer = fs.createWriteStream(fileName);
+    response.data.pipe(writer);
 
     return new Promise((resolve, reject) => {
-      videoWriter.on("finish", async () => {
+      writer.on("finish", async () => {
         try {
           const finalFilePath = await processDownloadedFile(fileName, config, platform);
           resolve(finalFilePath);
         } catch (error) {
-          reject(new Error(`Error processing downloaded video: ${error.message}`));
+          reject(new Error(`Error processing downloaded file: ${error.message}`));
         }
       });
-      videoWriter.on("error", (error) => {
-        reject(new Error(`Error saving video: ${error.message}`));
+      writer.on("error", (error) => {
+        reject(new Error(`Error saving file: ${error.message}`));
       });
     });
   } catch (error) {
@@ -1156,33 +1177,45 @@ 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'
       }
     });
-    
+
+    // Detect file type from content-type
+    const contentType = response.headers['content-type'] || 'video/mp4';
+    let ext = 'mp4'; // default
+
+    if (contentType.includes('image/jpeg')) ext = 'jpg';
+    else if (contentType.includes('image/png')) ext = 'png';
+    else if (contentType.includes('image/webp')) ext = 'webp';
+    else if (contentType.includes('image/gif')) ext = 'gif';
+    else if (contentType.includes('video/webm')) ext = 'webm';
+    else if (contentType.includes('video/quicktime')) ext = 'mov';
+    else if (contentType.includes('video/x-matroska')) ext = 'mkv';
+
     // 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);
+    let fileName = path.join(OUTPUT_DIR, `v_${uuidv4().slice(0, 4)}.${ext}`);
+
+    const writer = fs.createWriteStream(fileName);
+    response.data.pipe(writer);
 
     return new Promise((resolve, reject) => {
-      videoWriter.on("finish", async () => {
+      writer.on("finish", async () => {
         try {
           const finalFilePath = await processDownloadedFile(fileName, config, "unknown");
           resolve(finalFilePath);
         } catch (error) {
-          reject(new Error(`Error processing downloaded video: ${error.message}`));
+          reject(new Error(`Error processing downloaded file: ${error.message}`));
         }
       });
-      videoWriter.on("error", (error) => {
-        reject(new Error(`Error saving video: ${error.message}`));
+      writer.on("error", (error) => {
+        reject(new Error(`Error saving file: ${error.message}`));
       });
     });
   } catch (error) {
@@ -1216,7 +1249,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 +1264,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 +1315,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 +1348,9 @@ async function cleanupOutputFiles() {
         if (now - st.mtimeMs > maxAgeMs) {
           await safeUnlinkWithRetry(full);
         }
-      } catch (_) {}
+      } catch (_) { }
     }
-  } catch (_) {}
+  } catch (_) { }
 }
 
 // Schedule periodic cleanup (every 10 minutes)
@@ -1331,7 +1364,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 +1372,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 +1411,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 +1446,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 +1513,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 +1589,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 +1608,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.12",
   "description": "downloads",
   "main": "index.js",
   "scripts": {