frostpv 1.0.24 → 1.0.26

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.");
@@ -796,20 +801,40 @@ const MediaDownloader = async (url, options = {}) => {
     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
+    }
 
+    // 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: ${error.message}`);
+        throw new Error(`YouTube download failed: ${primaryError?.message || 'Unknown error'}`);
       }
 
       try {
@@ -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,80 @@ 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);
+        throw new Error("AbortError");
+      }
+    }
+
     return new Promise((resolve, reject) => {
+      // Handle abort inside the Promise so reject is in scope
+      if (signal) {
+        signal.addEventListener('abort', () => {
+          response.data.destroy();
+          videoWriter.destroy();
+          safeUnlink(fileName);
+          reject(new Error("AbortError"));
+        }, { once: true });
+      }
+
       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 +1226,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,
@@ -1139,16 +1238,64 @@ async function downloadDirectVideo(url, config) {
       }
     });
 
+    // 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);
 
     return new Promise((resolve, reject) => {
+      // Handle abort inside the Promise so reject is in scope
+      if (signal) {
+        signal.addEventListener('abort', () => {
+          response.data.destroy();
+          videoWriter.destroy();
+          safeUnlink(fileName);
+          reject(new Error("AbortError"));
+        }, { once: true });
+      }
+
       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 +1323,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 +1341,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 +1355,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,14 +1367,27 @@ async function rotateVideo(fileName, rotation) {
   }
 
   return new Promise((resolve, reject) => {
-    ffmpeg(fileName)
+    const ff = ffmpeg(fileName)
       .videoFilters(angle)
       .audioCodec('copy')
-      .output(outputPath)
-      .on('end', async () => {
-        await safeUnlinkWithRetry(fileName);
-        resolve(outputPath);
-      })
+      .output(outputPath);
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(new Error("AbortError"));
+        return;
+      }
+      signal.addEventListener('abort', () => {
+        ff.kill('SIGKILL');
+        safeUnlink(outputPath);
+        reject(new Error("AbortError"));
+      }, { once: true });
+    }
+
+    ff.on('end', async () => {
+      await safeUnlinkWithRetry(fileName);
+      resolve(outputPath);
+    })
       .on('error', (err) => reject(new Error(`Error during video rotation: ${err.message}`)))
       .run();
   });
@@ -1253,26 +1418,55 @@ async function deleteTempVideos() {
 
 // Enhanced cleanup function for all temporary files
 async function cleanupTempFiles() {
+  // Clean TEMP_DIR (_compressed files)
   try {
-    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)
-    );
-    for (const file of tempFiles) {
-      await safeUnlinkWithRetry(path.join(TEMP_DIR, file));
+    if (fs.existsSync(TEMP_DIR)) {
+      const files = fs.readdirSync(TEMP_DIR);
+      const tempFiles = files.filter(file => /_compressed\.mp4$/.test(file));
+      const now = Date.now();
+      const GRACE_PERIOD_MS = 5 * 60 * 1000; // 5 minutes
+
+      for (const file of tempFiles) {
+        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) {
+    if (error && error.code !== 'ENOENT') {
+      console.error(`Error during temp file cleanup (TEMP_DIR): ${error.message}`);
+    }
+  }
 
+  // Also clean OUTPUT_DIR orphan files (v_, vr_, vc_, vx_, vf_, a_ prefixed)
+  try {
+    if (fs.existsSync(OUTPUT_DIR)) {
+      const files = fs.readdirSync(OUTPUT_DIR);
+      const now = Date.now();
+      const GRACE_PERIOD_MS = 5 * 60 * 1000; // 5 minutes
+
+      for (const file of files) {
+        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 > GRACE_PERIOD_MS) {
+            await safeUnlinkWithRetry(full);
+          }
+        } catch (_) { }
+      }
+    }
+  } catch (error) {
     if (error && error.code !== 'ENOENT') {
-      console.error(`Error during temp file cleanup: ${error.message}`);
+      console.error(`Error during temp file cleanup (OUTPUT_DIR): ${error.message}`);
     }
   }
+
+  triggerGC();
 }
 
 // Cleanup files in output folder older than OUTPUT_RETENTION_MIN
@@ -1283,12 +1477,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 (_) { }
@@ -1298,52 +1494,74 @@ async function cleanupOutputFiles() {
 }
 
 
-// Schedule periodic cleanup (every 10 minutes)
+// Schedule periodic cleanup (every 5 minutes)
 setInterval(() => {
   cleanupTempFiles();
   cleanupOutputFiles();
-}, 60 * 1000);
+}, 5 * 60 * 1000);
 // Run once at startup
 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"));
+      }, { once: true });
+    }
+
+    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)
           .audioCodec('copy')
-          .output(outputPath)
-          .on('end', async () => {
-            await safeUnlinkWithRetry(inputPath);
-            resolve(outputPath);
-          })
+          .output(outputPath);
+
+        if (signal) {
+          signal.addEventListener('abort', () => {
+            ffCrop.kill('SIGKILL');
+            safeUnlink(outputPath);
+            reject(new Error("AbortError"));
+          }, { once: true });
+        }
+
+        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;
 
@@ -1357,21 +1575,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'
       )
       .audioCodec('aac')
-      .output(outputPath)
-      .on('end', async () => {
-        await safeUnlinkWithRetry(filePath);
-        resolve(outputPath);
-      })
+      .output(outputPath);
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(new Error("AbortError"));
+        return;
+      }
+      signal.addEventListener('abort', () => {
+        ff.kill('SIGKILL');
+        safeUnlink(outputPath);
+        reject(new Error("AbortError"));
+      }, { once: true });
+    }
+
+    ff.on('end', async () => {
+      await safeUnlinkWithRetry(filePath);
+      resolve(outputPath);
+    })
       .on('error', (err) => {
         resolve(filePath);
       })
@@ -1380,12 +1611,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;
     }
@@ -1393,9 +1624,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":
@@ -1484,6 +1723,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.");
@@ -1501,7 +1743,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;
@@ -1518,16 +1761,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}`);
       }
@@ -1535,12 +1778,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;
 
@@ -1554,24 +1797,42 @@ 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)
-      .noVideo()
-      .audioCodec('libmp3lame')
-      .audioBitrate(192)
-      .format('mp3')
-      .save(audioPath)
-      .on('end', () => {
-        triggerGC();
-        resolve(audioPath);
-      })
+    const fileName = `a_${uuidv4().replace(/-/g, '').slice(0, 12)}.mp3`;
+    const audioPath = path.join(OUTPUT_DIR, fileName);
+
+    // We remove the hardcoded 'libmp3lame' codec which can cause "Invalid argument" 
+    // on some statically compiled ffmpeg versions and let it auto-select based on format.
+    const ff = ffmpeg(videoPath)
+      .outputOptions([
+        '-vn',           // No video
+        '-b:a', '192k'   // Audio bitrate
+      ])
+      .format('mp3');
+
+    if (signal) {
+      if (signal.aborted) {
+        reject(new Error("AbortError"));
+        return;
+      }
+      signal.addEventListener('abort', () => {
+        ff.kill('SIGKILL');
+        safeUnlink(audioPath);
+        reject(new Error("AbortError"));
+      }, { once: true });
+    }
 
+    // Attach events BEFORE calling run or save
+    ff.on('end', () => {
+      triggerGC();
+      resolve(audioPath);
+    })
       .on('error', (err) => {
         reject(new Error(`Error extracting audio: ${err.message}`));
-      });
+      })
+      .output(audioPath)
+      .run();
   });
 }
 

package/package.json

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