amiudmodz 5.0.8 → 5.1.0

package/lib/Utils/messages-media.js

@@ -103,43 +103,52 @@ const extractVideoThumb = async (path, destPath, time, size) => new Promise((res
 });
 const extractImageThumb = async (bufferOrFilePath, width = 32) => {
     var _a, _b;
+    let tmpPath;
     if (bufferOrFilePath instanceof stream_1.Readable) {
-        bufferOrFilePath = await (0, exports.toBuffer)(bufferOrFilePath);
-    }
-    const lib = await getImageProcessingLibrary();
-    if ('sharp' in lib && typeof ((_a = lib.sharp) === null || _a === void 0 ? void 0 : _a.default) === 'function') {
-        const img = lib.sharp.default(bufferOrFilePath);
-        const dimensions = await img.metadata();
-        const buffer = await img
-            .resize(width)
-            .jpeg({ quality: 50 })
-            .toBuffer();
-        return {
-            buffer,
-            original: {
-                width: dimensions.width,
-                height: dimensions.height,
-            },
-        };
-    }
-    else if ('jimp' in lib && typeof ((_b = lib.jimp) === null || _b === void 0 ? void 0 : _b.read) === 'function') {
-        const { read, MIME_JPEG, RESIZE_BILINEAR, AUTO } = lib.jimp;
-        const jimp = await read(bufferOrFilePath);
-        const dimensions = {
-            width: jimp.getWidth(),
-            height: jimp.getHeight()
-        };
-        const buffer = await jimp
-            .quality(50)
-            .resize(width, AUTO, RESIZE_BILINEAR)
-            .getBufferAsync(MIME_JPEG);
-        return {
-            buffer,
-            original: dimensions
-        };
+        // Spill stream to disk instead of buffering to RAM
+        tmpPath = await spillToDisk(bufferOrFilePath);
+        bufferOrFilePath = tmpPath;
     }
-    else {
-        throw new boom_1.Boom('No image processing library available');
+    try {
+        const lib = await getImageProcessingLibrary();
+        if ('sharp' in lib && typeof ((_a = lib.sharp) === null || _a === void 0 ? void 0 : _a.default) === 'function') {
+            const img = lib.sharp.default(bufferOrFilePath);
+            const dimensions = await img.metadata();
+            const buffer = await img
+                .resize(width)
+                .jpeg({ quality: 50 })
+                .toBuffer();
+            return {
+                buffer,
+                original: {
+                    width: dimensions.width,
+                    height: dimensions.height,
+                    },
+            };
+        }
+        else if ('jimp' in lib && typeof ((_b = lib.jimp) === null || _b === void 0 ? void 0 : _b.read) === 'function') {
+            const { read, MIME_JPEG, RESIZE_BILINEAR, AUTO } = lib.jimp;
+            const jimp = await read(bufferOrFilePath);
+            const dimensions = {
+                width: jimp.getWidth(),
+                height: jimp.getHeight()
+            };
+            const buffer = await jimp
+                .quality(50)
+                .resize(width, AUTO, RESIZE_BILINEAR)
+                .getBufferAsync(MIME_JPEG);
+            return {
+                buffer,
+                original: dimensions
+            };
+        }
+        else {
+            throw new boom_1.Boom('No image processing library available');
+        }
+    } finally {
+        if (tmpPath) {
+            await fs_1.promises.unlink(tmpPath).catch(() => {});
+        }
     }
 };
 exports.extractImageThumb = extractImageThumb;
@@ -151,6 +160,7 @@ exports.encodeBase64EncodedStringForUpload = encodeBase64EncodedStringForUpload;
 const generateProfilePicture = async (mediaUpload) => {
     var _a, _b;
     let bufferOrFilePath;
+    let tmpPath;
     if (Buffer.isBuffer(mediaUpload)) {
         bufferOrFilePath = mediaUpload;
     }
@@ -158,34 +168,41 @@ const generateProfilePicture = async (mediaUpload) => {
         bufferOrFilePath = mediaUpload.url.toString();
     }
     else {
-        bufferOrFilePath = await (0, exports.toBuffer)(mediaUpload.stream);
-    }
-    const lib = await getImageProcessingLibrary();
-    let img;
-    if ('sharp' in lib && typeof ((_a = lib.sharp) === null || _a === void 0 ? void 0 : _a.default) === 'function') {
-        img = lib.sharp.default(bufferOrFilePath)
-            .resize(640, 640)
-            .jpeg({
-                quality: 50,
-            })
-            .toBuffer();
-    }
-    else if ('jimp' in lib && typeof ((_b = lib.jimp) === null || _b === void 0 ? void 0 : _b.read) === 'function') {
-        const { read, MIME_JPEG, RESIZE_BILINEAR } = lib.jimp;
-        const jimp = await read(bufferOrFilePath);
-        const min = Math.min(jimp.getWidth(), jimp.getHeight());
-        const cropped = jimp.crop(0, 0, min, min);
-        img = cropped
-            .quality(50)
-            .resize(640, 640, RESIZE_BILINEAR)
-            .getBufferAsync(MIME_JPEG);
+        tmpPath = await spillToDisk(mediaUpload.stream);
+        bufferOrFilePath = tmpPath;
     }
-    else {
-        throw new boom_1.Boom('No image processing library available');
+    try {
+        const lib = await getImageProcessingLibrary();
+        let img;
+        if ('sharp' in lib && typeof ((_a = lib.sharp) === null || _a === void 0 ? void 0 : _a.default) === 'function') {
+            img = lib.sharp.default(bufferOrFilePath)
+                .resize(640, 640)
+                .jpeg({
+                    quality: 50,
+                })
+                .toBuffer();
+        }
+        else if ('jimp' in lib && typeof ((_b = lib.jimp) === null || _b === void 0 ? void 0 : _b.read) === 'function') {
+            const { read, MIME_JPEG, RESIZE_BILINEAR } = lib.jimp;
+            const jimp = await read(bufferOrFilePath);
+            const min = Math.min(jimp.getWidth(), jimp.getHeight());
+            const cropped = jimp.crop(0, 0, min, min);
+            img = cropped
+                .quality(50)
+                .resize(640, 640, RESIZE_BILINEAR)
+                .getBufferAsync(MIME_JPEG);
+        }
+        else {
+            throw new boom_1.Boom('No image processing library available');
+        }
+        return {
+            img: await img,
+        };
+    } finally {
+        if (tmpPath) {
+            await fs_1.promises.unlink(tmpPath).catch(() => {});
+        }
     }
-    return {
-        img: await img,
-    };
 };
 exports.generateProfilePicture = generateProfilePicture;
 /** gets the SHA256 of the given media message */
@@ -239,19 +256,14 @@ async function getAudioWaveform(buffer, logger) {
         const { PassThrough } = require('stream');
         const ff = require('fluent-ffmpeg');
 
-        let audioData;
+        const inputStream = new PassThrough();
         if (Buffer.isBuffer(buffer)) {
-            audioData = buffer;
+            inputStream.end(buffer);
         } else if (typeof buffer === 'string') {
-            const rStream = require('fs').createReadStream(buffer);
-            audioData = await exports.toBuffer(rStream);
+            (0, fs_1.createReadStream)(buffer).pipe(inputStream);
         } else {
-            audioData = await exports.toBuffer(buffer);
+            buffer.pipe(inputStream);
         }
-
-        return await new Promise((resolve, reject) => {
-            const inputStream = new PassThrough();
-            inputStream.end(audioData);
             const chunks = [];
             const bars = 64;
 
@@ -280,7 +292,7 @@ async function getAudioWaveform(buffer, logger) {
                     const normalized = avg.map(v => Math.floor((v / max) * 100));
                     resolve(new Uint8Array(normalized));
                 })
-                .pipe()
+                .pipe(new PassThrough(), { end: true })
                 .on('data', chunk => chunks.push(chunk));
         });
     } catch (e) {
@@ -343,9 +355,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 +513,48 @@ 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;
+    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 ff = require('fluent-ffmpeg');
+                opusSpillPath = (0, path_1.join)(getTmpFilesDirectory(), `opus-${(0, generics_1.generateMessageID)()}`);
+                const opusWriteStream = (0, fs_1.createWriteStream)(opusSpillPath);
+
+                await new Promise((resolve, reject) => {
+                    ff(audioTmpPath)
+                        .noVideo()
+                        .audioCodec('libopus')
+                        .format('ogg')
+                        .audioBitrate('48k')
+                        .audioChannels(1)
+                        .audioFrequency(48000)
+                        .outputOptions([
+                            '-vn',
+                            '-b:a 64k',
+                            '-ac 2',
+                            '-ar 48000',
+                            '-map_metadata', '-1',
+                            '-application', 'voip'
+                        ])
+                        .on('error', (err) => {
+                            opusWriteStream.destroy();
+                            reject(err);
+                        })
+                        .on('end', resolve)
+                        .pipe(opusWriteStream);
+                });
+
+                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 +564,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 +624,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 +666,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 { }
@@ -746,6 +834,7 @@ const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options },
                     headers: {
                         ...options.headers || {},
                         'Content-Type': 'application/octet-stream',
+                        'Content-Length': bodyLength.toString(),
                         'Origin': Defaults_1.DEFAULT_ORIGIN
                     },
                     httpsAgent: fetchAgent,

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,
@@ -157,6 +157,9 @@ const prepareWAMessageMedia = async (message, options) => {
         forceOpus: (mediaType === "audio" && uploadData.mimetype && uploadData.mimetype.includes('opus'))
     });
 
+    // Nullify the media reference to help GC free the memory if it's a large Buffer
+    uploadData.media = undefined;
+
     if (mediaType === 'audio' && opusConverted) {
         uploadData.mimetype = 'audio/ogg; codecs=opus';
     }
@@ -210,6 +213,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.1.0",
     "description": "WhatsApp Baileys mod Powered by UDMODZ",
     "keywords": [
         "whatsapp",