amiudmodz 5.0.1 → 5.0.2

package/lib/Utils/messages-media.js

@@ -402,9 +402,11 @@ const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequi
     let didSaveToTmpPath = false;
     let fileLength = 0;
     const sha256 = Crypto.createHash('sha256');
-    const encWriteStream = new stream_1.PassThrough();
     
-    // if it's already a file, we can use its path
+    // Always save prepared data to a temp file for large files support and retries
+    const preparedPath = (0, path_1.join)(getTmpFilesDirectory(), `prepared-${mediaType}-${(0, generics_1.generateMessageID)()}`);
+    const preparedWriteStream = (0, fs_1.createWriteStream)(preparedPath);
+    
     if (type === 'file') {
         bodyPath = media.url;
     } else if (saveOriginalFileIfRequired) {
@@ -423,10 +425,12 @@ const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequi
                     await (0, events_1.once)(writeStream, 'drain');
                 }
             }
-            encWriteStream.write(chunk);
+            if (!preparedWriteStream.write(chunk)) {
+                await (0, events_1.once)(preparedWriteStream, 'drain');
+            }
         }
 
-        encWriteStream.end();
+        preparedWriteStream.end();
         writeStream?.end();
 
         const fileSha256 = sha256.digest();
@@ -434,18 +438,22 @@ const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequi
         
         return {
             mediaKey: undefined,
-            encWriteStream, // Now a stream, not a buffer
+            encWriteStream: (0, fs_1.createReadStream)(preparedPath),
             fileLength,
             fileSha256,
             fileEncSha256: undefined,
             bodyPath,
+            streamPath: preparedPath,
             didSaveToTmpPath
         };
     }
     catch (error) {
         stream.destroy();
-        encWriteStream.destroy();
+        preparedWriteStream.destroy();
         writeStream?.destroy();
+        try {
+            await fs_1.promises.unlink(preparedPath);
+        } catch {}
         if (didSaveToTmpPath) {
             try {
                 await fs_1.promises.unlink(bodyPath);
@@ -460,7 +468,6 @@ 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);
-
     let finalStream = stream;
     let opusConverted = false;
     if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
@@ -469,19 +476,22 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
             const opusBuffer = await exports.convertToOpusBuffer(buffer, logger);
             finalStream = (0, exports.toReadable)(opusBuffer);
             opusConverted = true;
-        } catch (error) {
+        }
+        catch (error) {
             const { stream: newStream } = await (0, exports.getStream)(media, opts);
             finalStream = newStream;
         }
     }
-
     const mediaKey = Crypto.randomBytes(32);
     const { cipherKey, iv, macKey } = getMediaKeys(mediaKey, mediaType);
-    const encWriteStream = new stream_1.Readable({ read: () => { } });
+    
+    // Always save encrypted data to a temp file for 2GB support and retries
+    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;
-
     if (type === 'file') {
         bodyPath = media.url;
     }
@@ -490,13 +500,11 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
         writeStream = (0, fs_1.createWriteStream)(bodyPath);
         didSaveToTmpPath = true;
     }
-
     let fileLength = 0;
     const aes = Crypto.createCipheriv('aes-256-cbc', cipherKey, iv);
     let hmac = Crypto.createHmac('sha256', macKey).update(iv);
     let sha256Plain = Crypto.createHash('sha256');
     let sha256Enc = Crypto.createHash('sha256');
-
     try {
         for await (const data of finalStream) {
             fileLength += data.length;
@@ -507,31 +515,44 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
                     data: { media, type }
                 });
             }
-
             sha256Plain = sha256Plain.update(data);
             if (writeStream) {
                 if (!writeStream.write(data)) {
                     await (0, events_1.once)(writeStream, 'drain');
                 }
             }
-            onChunk(aes.update(data));
+            const encrypted = aes.update(data);
+            sha256Enc = sha256Enc.update(encrypted);
+            hmac = hmac.update(encrypted);
+            if (!encTempWriteStream.write(encrypted)) {
+                await (0, events_1.once)(encTempWriteStream, 'drain');
+            }
+        }
+        const finalEnc = aes.final();
+        sha256Enc = sha256Enc.update(finalEnc);
+        hmac = hmac.update(finalEnc);
+        if (!encTempWriteStream.write(finalEnc)) {
+            await (0, events_1.once)(encTempWriteStream, 'drain');
         }
 
-        onChunk(aes.final());
         const mac = hmac.digest().slice(0, 10);
         sha256Enc = sha256Enc.update(mac);
+        if (!encTempWriteStream.write(mac)) {
+            await (0, events_1.once)(encTempWriteStream, 'drain');
+        }
+
         const fileSha256 = sha256Plain.digest();
         const fileEncSha256 = sha256Enc.digest();
-
-        encWriteStream.push(mac);
-        encWriteStream.push(null);
+        
+        encTempWriteStream.end();
         writeStream === null || writeStream === void 0 ? void 0 : writeStream.end();
         finalStream.destroy();
 
         return {
             mediaKey,
-            encWriteStream,
+            encWriteStream: (0, fs_1.createReadStream)(encPath),
             bodyPath,
+            streamPath: encPath,
             mac,
             fileEncSha256,
             fileSha256,
@@ -541,14 +562,16 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
         };
     }
     catch (error) {
-        encWriteStream.destroy();
+        encTempWriteStream.destroy();
         writeStream === null || writeStream === void 0 ? void 0 : writeStream.destroy();
         aes.destroy();
         hmac.destroy();
         sha256Plain.destroy();
         sha256Enc.destroy();
         finalStream.destroy();
-
+        try {
+            await fs_1.promises.unlink(encPath);
+        } catch {}
         if (didSaveToTmpPath) {
             try {
                 await fs_1.promises.unlink(bodyPath);
@@ -558,12 +581,6 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
         }
         throw error;
     }
-
-    function onChunk(buff) {
-        sha256Enc = sha256Enc.update(buff);
-        hmac = hmac.update(buff);
-        encWriteStream.push(buff);
-    }
 };
 exports.encryptedStream = encryptedStream;
 const DEF_HOST = 'mmg.whatsapp.net';
@@ -684,14 +701,14 @@ function extensionForMediaMessage(message) {
 }
 exports.extensionForMediaMessage = extensionForMediaMessage;
 const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options }, refreshMediaConn) => {
-    return async (stream, { mediaType, fileEncSha256B64, newsletter, timeoutMs, fileLength }) => {
+    return async (stream, { mediaType, fileEncSha256B64, newsletter, timeoutMs, fileLength, streamPath }) => {
         var _a, _b;
         const { default: axios } = await import('axios');
+        const { createReadStream } = await import('fs');
 
         let uploadInfo = await refreshMediaConn(false);
         let urls;
         const hosts = [...customUploadHosts, ...uploadInfo.hosts];
-        const reqBody = stream;
         fileEncSha256B64 = (0, exports.encodeBase64EncodedStringForUpload)(fileEncSha256B64);
         let media = Defaults_1.MEDIA_PATH_MAP[mediaType];
         if (newsletter) {
@@ -701,6 +718,11 @@ const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options },
             logger.debug(`uploading to "${hostname}"`);
             const auth = encodeURIComponent(uploadInfo.auth);
             const url = `https://${hostname}${media}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
+            
+            // Re-create stream if retrying and we have a path
+            // This is essential for large files (2GB) as the first stream will be consumed
+            const reqBody = streamPath ? createReadStream(streamPath) : stream;
+
             let result;
             try {
                 const bodyLength = fileLength || (Buffer.isBuffer(reqBody) ? reqBody.length : 0);

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, 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, 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,
@@ -165,7 +165,7 @@ const prepareWAMessageMedia = async (message, options) => {
 
     const [{ mediaUrl, directPath, handle }] = await Promise.all([
         (async () => {
-            const result = await options.upload(encWriteStream, { fileEncSha256B64, mediaType, timeoutMs: options.mediaUploadTimeoutMs, fileLength });
+            const result = await options.upload(encWriteStream, { fileEncSha256B64, mediaType, timeoutMs: options.mediaUploadTimeoutMs, fileLength, streamPath });
             logger === null || logger === void 0 ? void 0 : logger.debug({ mediaType, cacheableKey }, 'uploaded media');
             return result;
         })(),
@@ -205,9 +205,12 @@ const prepareWAMessageMedia = async (message, options) => {
             }
 
             if (didSaveToTmpPath && bodyPath) {
-                await fs_1.promises.unlink(bodyPath);
-                logger === null || logger === void 0 ? void 0 : logger.debug('removed tmp files');
+                await fs_1.promises.unlink(bodyPath).catch(() => { });
             }
+            if (streamPath) {
+                await fs_1.promises.unlink(streamPath).catch(() => { });
+            }
+            logger === null || logger === void 0 ? void 0 : logger.debug('removed tmp files');
         });
 
     const obj = Types_1.WAProto.Message.fromObject({

package/package.json

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