amiudmodz 5.0.8 → 5.0.9

package/lib/Utils/messages-media.js

@@ -343,9 +343,31 @@ const toBuffer = async (stream) => {
     return Buffer.concat(chunks);
 };
 exports.toBuffer = toBuffer;
+/**
+ * Spills a Buffer or Readable stream to a temp file on disk so it is not
+ * held entirely in RAM. Returns the temp-file path so the caller can clean
+ * it up when done.
+ */
+const spillToDisk = async (source) => {
+    const tmpPath = (0, path_1.join)(getTmpFilesDirectory(), `spill-${(0, generics_1.generateMessageID)()}`);
+    const writeStream = (0, fs_1.createWriteStream)(tmpPath);
+    await new Promise((resolve, reject) => {
+        writeStream.on('error', reject);
+        writeStream.on('finish', resolve);
+        if (Buffer.isBuffer(source)) {
+            writeStream.end(source);
+        } else {
+            source.pipe(writeStream);
+            source.on('error', reject);
+        }
+    });
+    return tmpPath;
+};
 const getStream = async (item, opts) => {
     if (Buffer.isBuffer(item)) {
-        return { stream: (0, exports.toReadable)(item), type: 'buffer' };
+        // Write the Buffer to a temp file so it can be GC'd from RAM
+        const tmpPath = await spillToDisk(item);
+        return { stream: (0, fs_1.createReadStream)(tmpPath), type: 'file', spilledPath: tmpPath };
     }
     if ('stream' in item) {
         return { stream: item.stream, type: 'readable' };
@@ -479,15 +501,25 @@ const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequi
 };
 exports.prepareStream = prepareStream;
 const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, isPtt, forceOpus } = {}) => {
-    const { stream, type } = await (0, exports.getStream)(media, opts);
+    const { stream, type, spilledPath } = await (0, exports.getStream)(media, opts);
     let finalStream = stream;
     let opusConverted = false;
+    // Track temp files created for spill-to-disk of audio opus conversion
+    let opusSpillPath;
     if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
         try {
-            const buffer = await (0, exports.toBuffer)(stream);
-            const opusBuffer = await exports.convertToOpusBuffer(buffer, logger);
-            finalStream = (0, exports.toReadable)(opusBuffer);
-            opusConverted = true;
+            // Write audio to temp file, convert via ffmpeg, write result to another temp file
+            const audioTmpPath = await spillToDisk(stream);
+            try {
+                const opusBuffer = await exports.convertToOpusBuffer(
+                    await fs_1.promises.readFile(audioTmpPath), logger
+                );
+                opusSpillPath = await spillToDisk(opusBuffer);
+                finalStream = (0, fs_1.createReadStream)(opusSpillPath);
+                opusConverted = true;
+            } finally {
+                await fs_1.promises.unlink(audioTmpPath).catch(() => {});
+            }
         }
         catch (error) {
             const { stream: newStream } = await (0, exports.getStream)(media, opts);
@@ -497,15 +529,16 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
     const mediaKey = Crypto.randomBytes(32);
     const { cipherKey, iv, macKey } = getMediaKeys(mediaKey, mediaType);
 
-
     const encPath = (0, path_1.join)(getTmpFilesDirectory(), `enc-${mediaType}-${(0, generics_1.generateMessageID)()}`);
     const encTempWriteStream = (0, fs_1.createWriteStream)(encPath);
 
     let bodyPath;
     let writeStream;
     let didSaveToTmpPath = false;
+    // For 'file' type (includes our spill-to-disk buffers), use the path directly
     if (type === 'file') {
-        bodyPath = media.url;
+        // If spilled from a Buffer, spilledPath IS the original; use it as bodyPath
+        bodyPath = spilledPath || (media && media.url ? media.url : undefined);
     }
     else if (saveOriginalFileIfRequired) {
         bodyPath = (0, path_1.join)(getTmpFilesDirectory(), mediaType + (0, generics_1.generateMessageID)());
@@ -556,15 +589,32 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
         const fileSha256 = sha256Plain.digest();
         const fileEncSha256 = sha256Enc.digest();
 
-        encTempWriteStream.end();
-        writeStream === null || writeStream === void 0 ? void 0 : writeStream.end();
+        await new Promise((resolve, reject) => {
+            encTempWriteStream.end(resolve);
+            encTempWriteStream.once('error', reject);
+        });
+        if (writeStream) {
+            await new Promise((resolve, reject) => {
+                writeStream.end(resolve);
+                writeStream.once('error', reject);
+            });
+        }
         finalStream.destroy();
+        // Clean up the opus spill temp file if used
+        if (opusSpillPath) {
+            await fs_1.promises.unlink(opusSpillPath).catch(() => {});
+        }
+        // Clean up the buffer-spill temp file — it's no longer needed once encrypted
+        // (the enc temp file is what gets uploaded; bodyPath/spilledPath is only
+        //  needed for thumbnail/duration computation which happens in parallel)
+        // Caller (messages.js) handles cleanup of streamPath & bodyPath.
 
         return {
             mediaKey,
             encWriteStream: (0, fs_1.createReadStream)(encPath),
             bodyPath,
             streamPath: encPath,
+            spilledPath,  // expose so caller can clean up the buffer spill file
             mac,
             fileEncSha256,
             fileSha256,
@@ -581,6 +631,9 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
         sha256Plain.destroy();
         sha256Enc.destroy();
         finalStream.destroy();
+        if (opusSpillPath) {
+            await fs_1.promises.unlink(opusSpillPath).catch(() => {});
+        }
         try {
             await fs_1.promises.unlink(encPath);
         } catch { }

package/lib/Utils/messages.js

@@ -149,7 +149,7 @@ const prepareWAMessageMedia = async (message, options) => {
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
 
-    const { mediaKey, encWriteStream, bodyPath, streamPath, fileEncSha256, fileSha256, fileLength, didSaveToTmpPath, opusConverted } = await (options.newsletter ? messages_media_1.prepareStream : messages_media_1.encryptedStream)(uploadData.media, options.mediaTypeOverride || mediaType, {
+    const { mediaKey, encWriteStream, bodyPath, streamPath, spilledPath, fileEncSha256, fileSha256, fileLength, didSaveToTmpPath, opusConverted } = await (options.newsletter ? messages_media_1.prepareStream : messages_media_1.encryptedStream)(uploadData.media, options.mediaTypeOverride || mediaType, {
         logger,
         saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
         opts: options.options,
@@ -210,6 +210,12 @@ const prepareWAMessageMedia = async (message, options) => {
             if (streamPath) {
                 await fs_1.promises.unlink(streamPath).catch(() => { });
             }
+            // Clean up the buffer-spill temp file (if input was a Buffer, it was
+            // written to /tmp to avoid holding it in RAM; delete it now that we
+            // are done with thumbnail/duration computation)
+            if (spilledPath && spilledPath !== bodyPath) {
+                await fs_1.promises.unlink(spilledPath).catch(() => { });
+            }
             logger === null || logger === void 0 ? void 0 : logger.debug('removed tmp files');
         });
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "amiudmodz",
-    "version": "5.0.8",
+    "version": "5.0.9",
     "description": "WhatsApp Baileys mod Powered by UDMODZ",
     "keywords": [
         "whatsapp",