frostpv 1.0.22 → 1.0.25

package/index.js

@@ -27,12 +27,13 @@ try { fs.mkdirSync(OUTPUT_DIR, { recursive: true }); } catch (_) { }
 
 const TEMP_DIR = path.join(os.tmpdir(), "downloader-dl-bot");
 try { fs.mkdirSync(TEMP_DIR, { recursive: true }); } catch (_) { }
-const OUTPUT_RETENTION_MIN = Number(process.env.OUTPUT_RETENTION_MIN || 5);
+const OUTPUT_RETENTION_MIN = Math.max(5, Number(process.env.OUTPUT_RETENTION_MIN || 5));
 
-const GOFILE_API = "1eNR6qXgKMn6GGl4oRcfOlQnxrgSrNSL";
+const GOFILE_API = "Cs05tkrbwIb0vNdXJWI5nee869RDJG37";
 const GOFILE_UPLOAD_URL = "https://upload.gofile.io/uploadfile";
 const SIZE_LIMIT_MB = 10;
 const SIZE_LIMIT_BYTES = SIZE_LIMIT_MB * 1024 * 1024;
+const ABSOLUTE_MAX_BYTES = 1024 * 1024 * 1024; // 1GB limit to prevent RAM exhaustion
 
 const videoPlatforms = [
   "https://www.instagram.com",
@@ -173,7 +174,7 @@ async function safeUnlinkWithRetry(filePath, maxRetries = 3) {
 }
 
 // Function to upload to GoFile if needed
-async function uploadToGoFileIfNeeded(filePath) {
+async function uploadToGoFileIfNeeded(filePath, signal = null) {
   try {
     const stats = fs.statSync(filePath);
     const fileSizeInBytes = stats.size;
@@ -194,10 +195,11 @@ async function uploadToGoFileIfNeeded(filePath) {
       headers: {
         ...form.getHeaders(),
         "Authorization": `Bearer ${GOFILE_API}`,
-        "Content-Length": form.getLengthSync() 
+        "Content-Length": form.getLengthSync()
       },
       maxContentLength: Infinity,
-      maxBodyLength: Infinity
+      maxBodyLength: Infinity,
+      signal: signal
     });
 
     if (response.data && response.data.status === "ok") {
@@ -761,6 +763,9 @@ async function tryFallbackDownload(url, maxRetries = 3) {
 const MediaDownloader = async (url, options = {}) => {
   assertAuthorized();
   const config = { ...defaultConfig, ...options };
+  const signal = config.signal;
+
+  if (signal?.aborted) throw new Error("AbortError");
 
   if (!url || !url.includes("http")) {
     throw new Error("Please specify a valid video URL.");
@@ -793,26 +798,46 @@ 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");
+      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
+  // No longer cleanup at start to avoid race conditions during concurrent downloads
+  // await cleanupTempFiles(); // Clean up previous temp files
 
   let downloadedFilePath = null;
+  let primaryError = null;
 
   try {
-    // Try primary download method
+    // 1. Try primary download method
     try {
-      downloadedFilePath = await downloadSmartVideo(url, config);
+      downloadedFilePath = await downloadSmartVideo(url, config, signal);
+      
+      // Verify integrity of primary download
+      if (downloadedFilePath) {
+         try {
+            const stats = fs.statSync(downloadedFilePath);
+            if (stats.size < 500) {
+               throw new Error(`Downloaded file is too small, likely corrupted.`);
+            }
+         } catch (statError) {
+            throw new Error(`Failed to verify file integrity`);
+         }
+      }
     } catch (error) {
-      const platform = getPlatformType(url);
+      if (signal?.aborted || error.message?.includes("AbortError")) throw error;
+      primaryError = error;
+      downloadedFilePath = null; // Ensure null to trigger fallback
+    }
 
-      // YouTube doesn't use fallback method - it has its own specific implementation
-      if (platform === "youtube") {
-        throw new Error(`YouTube download failed: ${error.message}`);
-      }
+    // 2. If primary failed OR file was invalid, try fallback
+    if (!downloadedFilePath) {
+       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: ${primaryError?.message || 'Unknown error'}`);
+       }
 
-      try {
+       try {
         const fallbackUrl = await tryFallbackDownload(url);
 
         // Validate fallback URL
@@ -821,8 +846,19 @@ const MediaDownloader = async (url, options = {}) => {
           throw new Error("Fallback URL validation failed");
         }
 
-        downloadedFilePath = await downloadDirectVideo(fallbackUrl, config);
+        downloadedFilePath = await downloadDirectVideo(fallbackUrl, config, signal);
+        
+        // Verify integrity of fallback download
+        if (downloadedFilePath) {
+            const stats = fs.statSync(downloadedFilePath);
+            if (stats.size < 500) {
+               await safeUnlinkWithRetry(downloadedFilePath); // Clean up bad file
+               throw new Error(`Fallback downloaded file is too small, likely corrupted.`);
+            }
+        }
+
       } catch (fallbackError) {
+        // If both failed, throw a combined error
         throw new Error(`Failed to download video with both methods: ${fallbackError.message}`);
       }
     }
@@ -831,10 +867,10 @@ const MediaDownloader = async (url, options = {}) => {
       if (config.noGofile) {
         return { type: "local", value: downloadedFilePath };
       }
-      const result = await uploadToGoFileIfNeeded(downloadedFilePath);
+      const result = await uploadToGoFileIfNeeded(downloadedFilePath, signal);
       return result;
     } else {
-      throw new Error("Failed to obtain downloaded file path.");
+      throw new Error("Failed to obtain downloaded file path (both methods failed).");
     }
   } catch (error) {
     // Clean up any remaining temp files on error
@@ -844,23 +880,27 @@ const MediaDownloader = async (url, options = {}) => {
 };
 
 // Function to process downloaded file
-async function processDownloadedFile(fileName, config, platform = null) {
+async function processDownloadedFile(fileName, config, platform = null, signal = null) {
   let processedFile = path.resolve(fileName);
   if (config.rotation) {
-    processedFile = await rotateVideo(processedFile, config.rotation);
+    if (signal?.aborted) throw new Error("AbortError");
+    processedFile = await rotateVideo(processedFile, config.rotation, signal);
   }
   if (config.autocrop) {
-    processedFile = await autoCrop(processedFile);
+    if (signal?.aborted) throw new Error("AbortError");
+    processedFile = await autoCrop(processedFile, signal);
   }
-  processedFile = await checkAndCompressVideo(processedFile, config.limitSizeMB, platform);
+  if (signal?.aborted) throw new Error("AbortError");
+  processedFile = await checkAndCompressVideo(processedFile, config.limitSizeMB, platform, signal);
   if (config.outputFormat) {
-    processedFile = await convertVideoFormat(processedFile, String(config.outputFormat).toLowerCase());
+    if (signal?.aborted) throw new Error("AbortError");
+    processedFile = await convertVideoFormat(processedFile, String(config.outputFormat).toLowerCase(), signal);
   }
   return processedFile;
 }
 
 // Function for platform-specific video download
-async function downloadSmartVideo(url, config) {
+async function downloadSmartVideo(url, config, signal = null) {
   try {
     let videoUrl = null;
     let platform = getPlatformType(url);
@@ -1094,21 +1134,78 @@ async function downloadSmartVideo(url, config) {
       method: "GET",
       responseType: "stream",
       timeout: 30000,
+      signal: signal,
       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'
       }
     });
+    
+    // Check content-length early if available
+    const contentLength = parseInt(response.headers['content-length']);
+    if (!isNaN(contentLength) && contentLength > ABSOLUTE_MAX_BYTES) {
+      throw new Error(`Video is too large (${(contentLength / (1024 * 1024)).toFixed(2)}MB). Max limit is 1GB.`);
+    }
+
+    if (!isNaN(contentLength) && contentLength < 200) {
+    }
 
     // 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().replace(/-/g, '').slice(0, 12)}.mp4`);
 
     const videoWriter = fs.createWriteStream(fileName);
+    
+    // Byte counter to abort if stream exceeds limit
+    let downloadedBytes = 0;
+    response.data.on('data', (chunk) => {
+      downloadedBytes += chunk.length;
+      if (downloadedBytes > ABSOLUTE_MAX_BYTES) {
+        response.data.destroy(); // Stop the download
+        videoWriter.destroy();
+        safeUnlink(fileName);
+        // We can't easily throw from here to the outer scope, but the writer error/finish will handle it
+      }
+    });
+
+    // Catch errors on the incoming source stream
+    response.data.on('error', (err) => {
+      videoWriter.destroy();
+      safeUnlink(fileName);
+    });
+
     response.data.pipe(videoWriter);
 
+    if (signal) {
+      if (signal.aborted) {
+        response.data.destroy();
+        videoWriter.destroy();
+        safeUnlink(fileName);
+        reject(new Error("AbortError"));
+        return;
+      }
+      signal.addEventListener('abort', () => {
+        response.data.destroy();
+        videoWriter.destroy();
+        safeUnlink(fileName);
+        // We don't reject here because the writer error/finish will handle it or the outer timeout will catch it
+        // But rejecting helps propagate the abort faster
+      });
+    }
+
     return new Promise((resolve, reject) => {
       videoWriter.on("finish", async () => {
         try {
-          const finalFilePath = await processDownloadedFile(fileName, config, platform);
+          if (downloadedBytes > ABSOLUTE_MAX_BYTES) {
+             throw new Error("Video exceeded 1GB limit.");
+          }
+
+          // Check if file is empty
+          const stats = fs.statSync(fileName);
+          if (stats.size < 200) {
+            await safeUnlinkWithRetry(fileName);
+            throw new Error("Downloaded file is too small or corrupted (likely download failed)");
+          }
+
+          const finalFilePath = await processDownloadedFile(fileName, config, platform, signal);
           triggerGC(); // Limpar memória após processamento pesado
           resolve(finalFilePath);
 
@@ -1127,7 +1224,7 @@ async function downloadSmartVideo(url, config) {
 
 
 // Function for direct video download
-async function downloadDirectVideo(url, config) {
+async function downloadDirectVideo(url, config, signal = null) {
   try {
     const response = await axios({
       url: url,
@@ -1138,17 +1235,62 @@ async function downloadDirectVideo(url, config) {
         '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'
       }
     });
+    
+    // Check content-length early if available
+    const contentLength = parseInt(response.headers['content-length']);
+    if (!isNaN(contentLength) && contentLength > ABSOLUTE_MAX_BYTES) {
+      throw new Error(`Video is too large (${(contentLength / (1024 * 1024)).toFixed(2)}MB). Max limit is 1GB.`);
+    }
+
+    if (!isNaN(contentLength) && contentLength < 200) {
+    }
 
     // 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().replace(/-/g, '').slice(0, 12)}.mp4`);
 
     const videoWriter = fs.createWriteStream(fileName);
+
+    // Byte counter
+    let downloadedBytes = 0;
+    response.data.on('data', (chunk) => {
+      downloadedBytes += chunk.length;
+      if (downloadedBytes > ABSOLUTE_MAX_BYTES) {
+        response.data.destroy();
+        videoWriter.destroy();
+        safeUnlink(fileName);
+      }
+    });
+
+    // Catch errors on the incoming source stream
+    response.data.on('error', (err) => {
+      videoWriter.destroy();
+      safeUnlink(fileName);
+    });
+
     response.data.pipe(videoWriter);
 
+    if (signal) {
+      signal.addEventListener('abort', () => {
+        videoWriter.destroy();
+        safeUnlink(fileName);
+      });
+    }
+
     return new Promise((resolve, reject) => {
       videoWriter.on("finish", async () => {
         try {
-          const finalFilePath = await processDownloadedFile(fileName, config, "unknown");
+          if (downloadedBytes > ABSOLUTE_MAX_BYTES) {
+            throw new Error("Video exceeded 1GB limit.");
+          }
+
+          // Check if file is empty
+          const stats = fs.statSync(fileName);
+          if (stats.size < 200) {
+            await safeUnlinkWithRetry(fileName);
+            throw new Error("Downloaded file is too small or corrupted (likely download failed)");
+          }
+
+          const finalFilePath = await processDownloadedFile(fileName, config, "unknown", signal);
           resolve(finalFilePath);
         } catch (error) {
           reject(new Error(`Error processing downloaded video: ${error.message}`));
@@ -1176,6 +1318,11 @@ async function downloadGenericFile(url, preferredExt = null) {
       }
     });
 
+    // Check content-length early if available
+    const contentLength = parseInt(response.headers['content-length']);
+    if (!isNaN(contentLength) && contentLength < 200) {
+    }
+
     // Try to infer extension from content-type
     const ct = (response.headers && response.headers['content-type']) || '';
     let ext = preferredExt;
@@ -1189,7 +1336,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().replace(/-/g, '').slice(0, 12)}.${ext}`);
     const writer = fs.createWriteStream(fileName);
     response.data.pipe(writer);
 
@@ -1203,8 +1350,8 @@ 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`);
+async function rotateVideo(fileName, rotation, signal = null) {
+  const outputPath = path.join(OUTPUT_DIR, `vr_${uuidv4().replace(/-/g, '').slice(0, 12)}.mp4`);
   let angle;
   switch (rotation.toLowerCase()) {
     case "left": angle = "transpose=2"; break;
@@ -1215,13 +1362,27 @@ async function rotateVideo(fileName, rotation) {
   }
 
   return new Promise((resolve, reject) => {
-    ffmpeg(fileName)
+    const ff = ffmpeg(fileName)
       .videoFilters(angle)
-      .output(outputPath)
-      .on('end', async () => {
-        await safeUnlinkWithRetry(fileName);
-        resolve(outputPath);
-      })
+      .audioCodec('copy')
+      .output(outputPath);
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(new Error("AbortError"));
+        return;
+      }
+      signal.addEventListener('abort', () => {
+        ff.kill('SIGKILL');
+        safeUnlink(outputPath);
+        reject(new Error("AbortError"));
+      });
+    }
+
+    ff.on('end', async () => {
+      await safeUnlinkWithRetry(fileName);
+      resolve(outputPath);
+    })
       .on('error', (err) => reject(new Error(`Error during video rotation: ${err.message}`)))
       .run();
   });
@@ -1256,14 +1417,19 @@ async function cleanupTempFiles() {
     if (!fs.existsSync(TEMP_DIR)) return;
     const files = fs.readdirSync(TEMP_DIR);
     const tempFiles = files.filter(file =>
-      /^temp_video.*\.mp4$/.test(file) ||
-      /_audio\.mp3$/.test(file) ||
-      /_rotated\.mp4$/.test(file) ||
-      /_cropped\.mp4$/.test(file) ||
-      /_compressed\.mp4$/.test(file)
+       /_compressed\.mp4$/.test(file)
     );
+    const now = Date.now();
+    const GRACE_PERIOD_MS = 10 * 60 * 1000; // 10 minutes
+
     for (const file of tempFiles) {
-      await safeUnlinkWithRetry(path.join(TEMP_DIR, file));
+      const full = path.join(TEMP_DIR, file);
+      try {
+        const st = fs.statSync(full);
+        if (now - st.mtimeMs > GRACE_PERIOD_MS) {
+          await safeUnlinkWithRetry(full);
+        }
+      } catch (_) { }
     }
     triggerGC();
   } catch (error) {
@@ -1282,12 +1448,14 @@ async function cleanupOutputFiles() {
     const now = Date.now();
     const maxAgeMs = OUTPUT_RETENTION_MIN * 60 * 1000;
     for (const file of files) {
-      // Only consider our generated short names
-      if (!/^(v_|vr_|vc_|vx_|vf_|a_)[0-9a-f]{4}/i.test(file)) continue;
+      // Only consider our generated names with exactly 12 char hex suffix
+      if (!/^(v_|vr_|vc_|vx_|vf_|a_)[0-9a-f]{12}/i.test(file)) continue;
       const full = path.join(OUTPUT_DIR, file);
       try {
         const st = fs.statSync(full);
-        if (now - st.mtimeMs > maxAgeMs) {
+        const GRACE_PERIOD_MS = 10 * 60 * 1000; // 10 minutes
+        // Only delete if matches retention AND is not extremely new (grace period)
+        if (now - st.mtimeMs > maxAgeMs && now - st.mtimeMs > GRACE_PERIOD_MS) {
           await safeUnlinkWithRetry(full);
         }
       } catch (_) { }
@@ -1306,42 +1474,65 @@ setInterval(() => {
 cleanupOutputFiles();
 
 // Function to auto-crop video
-async function autoCrop(fileName) {
+async function autoCrop(fileName, signal = null) {
   const inputPath = fileName;
-  const outputPath = path.join(OUTPUT_DIR, `vc_${uuidv4().slice(0, 4)}.mp4`);
+  const outputPath = path.join(OUTPUT_DIR, `vc_${uuidv4().replace(/-/g, '').slice(0, 12)}.mp4`);
 
   return new Promise((resolve, reject) => {
     let cropValues = null;
-    ffmpeg(inputPath)
+    const ffDetect = ffmpeg(inputPath)
       .outputOptions('-vf', 'cropdetect=24:16:0')
       .outputFormat('null')
-      .output('-')
-      .on('stderr', function (stderrLine) {
-        const cropMatch = stderrLine.match(/crop=([0-9]+):([0-9]+):([0-9]+):([0-9]+)/);
-        if (cropMatch) {
-          cropValues = `crop=${cropMatch[1]}:${cropMatch[2]}:${cropMatch[3]}:${cropMatch[4]}`;
-        }
-      })
+      .output('-');
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(new Error("AbortError"));
+        return;
+      }
+      signal.addEventListener('abort', () => {
+        ffDetect.kill('SIGKILL');
+        reject(new Error("AbortError"));
+      });
+    }
+
+    ffDetect.on('stderr', function (stderrLine) {
+      const cropMatch = stderrLine.match(/crop=([0-9]+):([0-9]+):([0-9]+):([0-9]+)/);
+      if (cropMatch) {
+        cropValues = `crop=${cropMatch[1]}:${cropMatch[2]}:${cropMatch[3]}:${cropMatch[4]}`;
+      }
+    })
       .on('end', function () {
         if (!cropValues) {
           resolve(inputPath);
           return;
         }
-        ffmpeg(inputPath)
+        const ffCrop = ffmpeg(inputPath)
           .outputOptions('-vf', cropValues)
-          .output(outputPath)
-          .on('end', async () => {
-            await safeUnlinkWithRetry(inputPath);
-            resolve(outputPath);
-          })
+          .audioCodec('copy')
+          .output(outputPath);
+
+        if (signal) {
+          signal.addEventListener('abort', () => {
+            ffCrop.kill('SIGKILL');
+            safeUnlink(outputPath);
+            reject(new Error("AbortError"));
+          });
+        }
+
+        ffCrop.on('end', async () => {
+          await safeUnlinkWithRetry(inputPath);
+          resolve(outputPath);
+        })
           .on('error', (err) => reject(new Error(`Error during auto-cropping: ${err.message}`)))
           .run();
-      });
+      })
+      .run();
   });
 }
 
 // Function to check and compress video
-async function checkAndCompressVideo(filePath, limitSizeMB, platform = null) {
+async function checkAndCompressVideo(filePath, limitSizeMB, platform = null, signal = null) {
   // Não comprimir vídeos do YouTube
   if (platform === "youtube") return filePath;
 
@@ -1355,20 +1546,34 @@ 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().replace(/-/g, '').slice(0, 12)}.mp4`);
 
   return new Promise((resolve, reject) => {
-    ffmpeg(filePath)
+    const ff = ffmpeg(filePath)
       .outputOptions(
         '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2',
         '-crf', '28',
         '-preset', 'slow'
       )
-      .output(outputPath)
-      .on('end', async () => {
-        await safeUnlinkWithRetry(filePath);
-        resolve(outputPath);
-      })
+      .audioCodec('aac')
+      .output(outputPath);
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(new Error("AbortError"));
+        return;
+      }
+      signal.addEventListener('abort', () => {
+        ff.kill('SIGKILL');
+        safeUnlink(outputPath);
+        reject(new Error("AbortError"));
+      });
+    }
+
+    ff.on('end', async () => {
+      await safeUnlinkWithRetry(filePath);
+      resolve(outputPath);
+    })
       .on('error', (err) => {
         resolve(filePath);
       })
@@ -1377,12 +1582,12 @@ async function checkAndCompressVideo(filePath, limitSizeMB, platform = null) {
 }
 
 // Video format conversion
-async function convertVideoFormat(inputPath, targetFormat) {
+async function convertVideoFormat(inputPath, targetFormat, signal = null) {
   try {
     const fmt = String(targetFormat).toLowerCase();
 
     if (fmt === "mp3") {
-      const audioPath = await extractAudioMp3(inputPath);
+      const audioPath = await extractAudioMp3(inputPath, signal);
       await safeUnlinkWithRetry(inputPath);
       return audioPath;
     }
@@ -1390,9 +1595,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().replace(/-/g, '').slice(0, 12)}.${fmt}`);
 
     const ff = ffmpeg(inputPath);
+    if (signal) {
+      if (signal.aborted) throw new Error("AbortError");
+      signal.addEventListener('abort', () => {
+        ff.kill('SIGKILL');
+        safeUnlink(outputPath);
+      });
+    }
+
     switch (fmt) {
       case "mp4":
       case "mov":
@@ -1481,6 +1694,9 @@ async function unshortenUrl(url) {
 const AudioDownloader = async (url, options = {}) => {
   assertAuthorized();
   const config = { ...defaultConfig, ...options };
+  const signal = config.signal;
+
+  if (signal?.aborted) throw new Error("AbortError");
 
   if (!url || !url.includes("http")) {
     throw new Error("Please specify a valid video URL.");
@@ -1498,7 +1714,8 @@ const AudioDownloader = async (url, options = {}) => {
     throw new Error("This URL is not from a supported platform. Supported platforms: Instagram, X(Twitter), TikTok, Facebook, and YouTube");
   }
 
-  await cleanupTempFiles(); // Clean up previous temp files
+  // No longer cleanup at start to avoid race conditions during concurrent downloads
+  // await cleanupTempFiles(); // Clean up previous temp files
 
   let downloadedFilePath = null;
   let audioFilePath = null;
@@ -1515,16 +1732,16 @@ const AudioDownloader = async (url, options = {}) => {
       }
       await downloadYoutubeAudio(url, fileName);
       audioFilePath = fileName;
-      const result = await uploadToGoFileIfNeeded(audioFilePath);
+      const result = await uploadToGoFileIfNeeded(audioFilePath, signal);
       return result;
     }
     // Baixar vídeo normalmente
     try {
-      downloadedFilePath = await downloadSmartVideo(url, config);
+      downloadedFilePath = await downloadSmartVideo(url, config, signal);
     } catch (error) {
       try {
         const fallbackUrl = await tryFallbackDownload(url);
-        downloadedFilePath = await downloadDirectVideo(fallbackUrl, config);
+        downloadedFilePath = await downloadDirectVideo(fallbackUrl, config, signal);
       } catch (fallbackError) {
         throw new Error(`Failed to download video with both methods: ${fallbackError.message}`);
       }
@@ -1532,12 +1749,12 @@ const AudioDownloader = async (url, options = {}) => {
 
     if (downloadedFilePath) {
       // Extrair áudio em mp3
-      audioFilePath = await extractAudioMp3(downloadedFilePath);
+      audioFilePath = await extractAudioMp3(downloadedFilePath, signal);
 
       // Remove o arquivo de vídeo temporário após extrair o áudio
       await safeUnlinkWithRetry(downloadedFilePath);
 
-      const result = await uploadToGoFileIfNeeded(audioFilePath);
+      const result = await uploadToGoFileIfNeeded(audioFilePath, signal);
       triggerGC();
       return result;
 
@@ -1551,20 +1768,32 @@ const AudioDownloader = async (url, options = {}) => {
   }
 };
 
-// Função para extrair áudio em mp3 usando ffmpeg
-async function extractAudioMp3(videoPath) {
+async function extractAudioMp3(videoPath, signal = null) {
   return new Promise((resolve, reject) => {
-    const audioPath = path.join(OUTPUT_DIR, `a_${uuidv4().slice(0, 4)}.mp3`);
-    ffmpeg(videoPath)
+    const audioPath = path.join(OUTPUT_DIR, `a_${uuidv4().replace(/-/g, '').slice(0, 12)}.mp3`);
+    const ff = ffmpeg(videoPath)
       .noVideo()
       .audioCodec('libmp3lame')
       .audioBitrate(192)
       .format('mp3')
-      .save(audioPath)
-      .on('end', () => {
-        triggerGC();
-        resolve(audioPath);
-      })
+      .save(audioPath);
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(new Error("AbortError"));
+        return;
+      }
+      signal.addEventListener('abort', () => {
+        ff.kill();
+        safeUnlink(audioPath);
+        reject(new Error("AbortError"));
+      });
+    }
+
+    ff.on('end', () => {
+      triggerGC();
+      resolve(audioPath);
+    })
 
       .on('error', (err) => {
         reject(new Error(`Error extracting audio: ${err.message}`));

package/package.json

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