amiudmodz 5.0.0 → 5.0.2

package/engine-requirements.js

@@ -7,4 +7,4 @@ if (major < 20) {
     `   Please upgrade to Node.js 20+ to proceed.\n`
   );
   process.exit(1);
-}
+}

package/lib/Defaults/index.js

@@ -141,7 +141,7 @@ exports.MEDIA_HKDF_KEY_MAPPING = {
 exports.MEDIA_KEYS = Object.keys(exports.MEDIA_PATH_MAP);
 exports.MIN_PREKEY_COUNT = 5;
 exports.INITIAL_PREKEY_COUNT = 30;
-exports.UPLOAD_TIMEOUT = 600000;
+exports.UPLOAD_TIMEOUT = 7200000; // 2 hours in ms
 exports.MIN_UPLOAD_INTERVAL = 5000;
 
 exports.TimeMs = {

package/lib/Utils/messages-media.js

@@ -400,33 +400,60 @@ const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequi
     logger === null || logger === void 0 ? void 0 : logger.debug('fetched media stream');
     let bodyPath;
     let didSaveToTmpPath = false;
+    let fileLength = 0;
+    const sha256 = Crypto.createHash('sha256');
+    
+    // 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) {
+        bodyPath = (0, path_1.join)(getTmpFilesDirectory(), mediaType + (0, generics_1.generateMessageID)());
+        didSaveToTmpPath = true;
+    }
+
+    const writeStream = bodyPath && !media.url ? (0, fs_1.createWriteStream)(bodyPath) : undefined;
+
     try {
-        const buffer = await (0, exports.toBuffer)(stream);
-        if (type === 'file') {
-            bodyPath = media.url;
-        }
-        else if (saveOriginalFileIfRequired) {
-            bodyPath = (0, path_1.join)(getTmpFilesDirectory(), mediaType + (0, generics_1.generateMessageID)());
-            (0, fs_1.writeFileSync)(bodyPath, buffer);
-            didSaveToTmpPath = true;
+        for await (const chunk of stream) {
+            fileLength += chunk.length;
+            sha256.update(chunk);
+            if (writeStream) {
+                if (!writeStream.write(chunk)) {
+                    await (0, events_1.once)(writeStream, 'drain');
+                }
+            }
+            if (!preparedWriteStream.write(chunk)) {
+                await (0, events_1.once)(preparedWriteStream, 'drain');
+            }
         }
-        const fileLength = buffer.length;
-        const fileSha256 = Crypto.createHash('sha256').update(buffer).digest();
-        stream === null || stream === void 0 ? void 0 : stream.destroy();
+
+        preparedWriteStream.end();
+        writeStream?.end();
+
+        const fileSha256 = sha256.digest();
         logger === null || logger === void 0 ? void 0 : logger.debug('prepare stream data successfully');
+        
         return {
             mediaKey: undefined,
-            encWriteStream: buffer,
+            encWriteStream: (0, fs_1.createReadStream)(preparedPath),
             fileLength,
             fileSha256,
             fileEncSha256: undefined,
             bodyPath,
+            streamPath: preparedPath,
             didSaveToTmpPath
         };
     }
     catch (error) {
-
         stream.destroy();
+        preparedWriteStream.destroy();
+        writeStream?.destroy();
+        try {
+            await fs_1.promises.unlink(preparedPath);
+        } catch {}
         if (didSaveToTmpPath) {
             try {
                 await fs_1.promises.unlink(bodyPath);
@@ -441,7 +468,7 @@ 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)) {
         try {
@@ -449,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;
     }
@@ -470,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;
@@ -487,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,
@@ -521,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);
@@ -538,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';
@@ -664,14 +701,14 @@ function extensionForMediaMessage(message) {
 }
 exports.extensionForMediaMessage = extensionForMediaMessage;
 const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options }, refreshMediaConn) => {
-    return async (stream, { mediaType, fileEncSha256B64, newsletter, timeoutMs }) => {
+    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) {
@@ -681,11 +718,16 @@ 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 = Buffer.isBuffer(reqBody) ? reqBody.length : 0;
+                const bodyLength = fileLength || (Buffer.isBuffer(reqBody) ? reqBody.length : 0);
                 if (maxContentLengthBytes && bodyLength > maxContentLengthBytes) {
-                    throw new boom_1.Boom(`Body too large for "${hostname}"`, { statusCode: 413 });
+                    throw new boom_1.Boom(`Body too large for "${hostname}" (${bodyLength} > ${maxContentLengthBytes})`, { statusCode: 413 });
                 }
                 const body = await axios.post(url, reqBody, {
                     ...options,

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 });
+            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.0",
+    "version": "5.0.2",
     "description": "WhatsApp Baileys mod Powered by UDMODZ",
     "keywords": [
         "whatsapp",