@fer2809fl/baileys 7.0.1 → 7.0.2

package/lib/Utils/messages-media.js

@@ -1,5 +1,5 @@
 import { Boom } from '@hapi/boom';
-import { spawn } from 'child_process';
+import { exec } from 'child_process';
 import * as Crypto from 'crypto';
 import { once } from 'events';
 import { createReadStream, createWriteStream, promises as fs, WriteStream } from 'fs';
@@ -13,31 +13,16 @@ import { getBinaryNodeChild, getBinaryNodeChildBuffer, jidNormalizedUser } from
 import { aesDecryptGCM, aesEncryptGCM, hkdf } from './crypto.js';
 import { generateMessageIDV2 } from './generics.js';
 const getTmpFilesDirectory = () => tmpdir();
-let imageProcessingLibrary;
-export const getImageProcessingLibrary = async () => {
-    if (imageProcessingLibrary) {
-        return imageProcessingLibrary;
-    }
+const getImageProcessingLibrary = async () => {
     //@ts-ignore
-    const [jimp, sharp, napi] = await Promise.all([
-        import('jimp').catch(() => { }),
-        import('sharp').catch(() => { }),
-        //@ts-ignore
-        import('@napi-rs/image').catch(() => { })
-    ]);
+    const [jimp, sharp] = await Promise.all([import('jimp').catch(() => { }), import('sharp').catch(() => { })]);
     if (sharp) {
-        imageProcessingLibrary = { sharp };
-    }
-    else if (napi) {
-        imageProcessingLibrary = { napi };
-    }
-    else if (jimp) {
-        imageProcessingLibrary = { jimp };
+        return { sharp };
     }
-    else {
-        throw new Boom('No image processing library available');
+    if (jimp) {
+        return { jimp };
     }
-    return imageProcessingLibrary;
+    throw new Boom('No image processing library available');
 };
 export const hkdfInfoKey = (type) => {
     const hkdfInfo = MEDIA_HKDF_KEY_MAPPING[type];
@@ -99,32 +84,13 @@ export async function getMediaKeys(buffer, mediaType) {
 }
 /** Extracts video thumb using FFMPEG */
 const extractVideoThumb = async (path, destPath, time, size) => new Promise((resolve, reject) => {
-    const args = [
-        '-ss',
-        time,
-        '-i',
-        path,
-        '-y',
-        '-vf',
-        `scale=${size.width}:-1`,
-        '-vframes',
-        '1',
-        '-f',
-        'image2',
-        destPath
-    ];
-    const child = spawn('ffmpeg', args);
-    let stderr = '';
-    child.stderr?.on('data', chunk => {
-        stderr += chunk;
-    });
-    child.on('error', reject);
-    child.on('close', code => {
-        if (code === 0) {
-            resolve();
+    const cmd = `ffmpeg -ss ${time} -i ${path} -y -vf scale=${size.width}:-1 -vframes 1 -f image2 ${destPath}`;
+    exec(cmd, err => {
+        if (err) {
+            reject(err);
         }
         else {
-            reject(new Boom(`ffmpeg exited with code ${code}`, { data: stderr }));
+            resolve();
         }
     });
 });
@@ -161,28 +127,14 @@ export const extractImageThumb = async (bufferOrFilePath, width = 32) => {
             original: dimensions
         };
     }
-    else if ('napi' in lib && typeof lib.napi?.Transformer === 'function') {
-        const input = typeof bufferOrFilePath === 'string' ? await fs.readFile(bufferOrFilePath) : bufferOrFilePath;
-        const img = new lib.napi.Transformer(input);
-        const meta = await img.metadata();
-        const buffer = await img.resize(width).jpeg(50);
-        return {
-            buffer,
-            original: {
-                width: meta.width,
-                height: meta.height
-            }
-        };
-    }
     else {
         throw new Boom('No image processing library available');
     }
 };
 export const encodeBase64EncodedStringForUpload = (b64) => encodeURIComponent(b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/\=+$/, ''));
-export const generateProfilePicture = async (mediaUpload, dimensions, opts) => {
+export const generateProfilePicture = async (mediaUpload, dimensions) => {
     let buffer;
-    const { full = true } = opts || {};
-    const { width: w = full ? 720 : 640, height: h = full ? 720 : 640 } = dimensions || {};
+    const { width: w = 640, height: h = 640 } = dimensions || {};
     if (Buffer.isBuffer(mediaUpload)) {
         buffer = mediaUpload;
     }
@@ -197,38 +149,17 @@ export const generateProfilePicture = async (mediaUpload, dimensions, opts) => {
     if ('sharp' in lib && typeof lib.sharp?.default === 'function') {
         img = lib.sharp
             .default(buffer)
-            .resize(w, h, full ? { fit: 'inside', withoutEnlargement: false } : undefined)
+            .resize(w, h)
             .jpeg({
-            quality: full ? 100 : 50
+            quality: 50
         })
             .toBuffer();
     }
     else if ('jimp' in lib && typeof lib.jimp?.Jimp === 'function') {
         const jimp = await lib.jimp.Jimp.read(buffer);
-        let resized;
-        if (full) {
-            const scale = Math.min(w / jimp.width, h / jimp.height, 1);
-            const targetW = Math.max(1, Math.round(jimp.width * scale));
-            const targetH = Math.max(1, Math.round(jimp.height * scale));
-            resized = jimp.resize({ w: targetW, h: targetH, mode: lib.jimp.ResizeStrategy.BILINEAR });
-        }
-        else {
-            const min = Math.min(jimp.width, jimp.height);
-            const cropped = jimp.crop({ x: 0, y: 0, w: min, h: min });
-            resized = cropped.resize({ w, h, mode: lib.jimp.ResizeStrategy.BILINEAR });
-        }
-        img = resized.getBuffer('image/jpeg', { quality: full ? 100 : 50 });
-    }
-    else if ('napi' in lib && typeof lib.napi?.Transformer === 'function') {
-        const transformer = new lib.napi.Transformer(buffer);
-        const meta = await transformer.metadata();
-        if (full) {
-            img = transformer.resize(w, h).jpeg(100);
-        }
-        else {
-            const min = Math.min(meta.width, meta.height);
-            img = transformer.crop(0, 0, min, min).resize(w, h).jpeg(50);
-        }
+        const min = Math.min(jimp.width, jimp.height);
+        const cropped = jimp.crop({ x: 0, y: 0, w: min, h: min });
+        img = cropped.resize({ w, h, mode: lib.jimp.ResizeStrategy.BILINEAR }).getBuffer('image/jpeg', { quality: 50 });
     }
     else {
         throw new Boom('No image processing library available');
@@ -375,34 +306,35 @@ export const getHttpStream = async (url, options = {}) => {
     // @ts-ignore Node18+ Readable.fromWeb exists
     return response.body instanceof Readable ? response.body : Readable.fromWeb(response.body);
 };
-export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts } = {}) => {
+export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, mediaKey: providedMediaKey } = {}) => {
     const { stream, type } = await getStream(media, opts);
-    logger?.debug('fetched media stream');
-    const mediaKey = Crypto.randomBytes(32);
+    let finalStream = stream;
+    const mediaKey = providedMediaKey || Crypto.randomBytes(32);
     const { cipherKey, iv, macKey } = await getMediaKeys(mediaKey, mediaType);
-    const encFilePath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2() + '-enc');
-    const encFileWriteStream = createWriteStream(encFilePath);
-    let originalFileStream;
-    let originalFilePath;
-    if (saveOriginalFileIfRequired) {
-        originalFilePath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2() + '-original');
-        originalFileStream = createWriteStream(originalFilePath);
+    const encWriteStream = new Readable({ read: () => {}, highWaterMark: 64 * 1024 });
+    let bodyPath;
+    let writeStream;
+    let didSaveToTmpPath = false;
+    if (type === 'file') {
+        bodyPath = media.url?.toString?.() || media.url;
+    }
+    else if (saveOriginalFileIfRequired) {
+        bodyPath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2());
+        writeStream = createWriteStream(bodyPath);
+        didSaveToTmpPath = true;
     }
     let fileLength = 0;
     const aes = Crypto.createCipheriv('aes-256-cbc', cipherKey, iv);
-    const hmac = Crypto.createHmac('sha256', macKey).update(iv);
-    const sha256Plain = Crypto.createHash('sha256');
-    const sha256Enc = Crypto.createHash('sha256');
-    const onChunk = async (buff) => {
-        sha256Enc.update(buff);
-        hmac.update(buff);
-        // Handle backpressure: if write returns false, wait for drain
-        if (!encFileWriteStream.write(buff)) {
-            await once(encFileWriteStream, 'drain');
-        }
+    let hmac = Crypto.createHmac('sha256', macKey).update(iv);
+    let sha256Plain = Crypto.createHash('sha256');
+    let sha256Enc = Crypto.createHash('sha256');
+    const onChunk = (buff) => {
+        sha256Enc = sha256Enc.update(buff);
+        hmac = hmac.update(buff);
+        encWriteStream.push(buff);
     };
     try {
-        for await (const data of stream) {
+        for await (const data of finalStream) {
             fileLength += data.length;
             if (type === 'remote' &&
                 opts?.maxContentLength &&
@@ -411,82 +343,59 @@ export const encryptedStream = async (media, mediaType, { logger, saveOriginalFi
                     data: { media, type }
                 });
             }
-            if (originalFileStream) {
-                if (!originalFileStream.write(data)) {
-                    await once(originalFileStream, 'drain');
+            sha256Plain = sha256Plain.update(data);
+            if (writeStream) {
+                if (!writeStream.write(data)) {
+                    await once(writeStream, 'drain');
                 }
             }
-            sha256Plain.update(data);
-            await onChunk(aes.update(data));
+            onChunk(aes.update(data));
         }
-        await onChunk(aes.final());
+        onChunk(aes.final());
         const mac = hmac.digest().slice(0, 10);
-        sha256Enc.update(mac);
+        sha256Enc = sha256Enc.update(mac);
         const fileSha256 = sha256Plain.digest();
         const fileEncSha256 = sha256Enc.digest();
-        encFileWriteStream.write(mac);
-        const encFinishPromise = once(encFileWriteStream, 'finish');
-        const originalFinishPromise = originalFileStream ? once(originalFileStream, 'finish') : Promise.resolve();
-        encFileWriteStream.end();
-        originalFileStream?.end?.();
-        stream.destroy();
-        // Wait for write streams to fully flush to disk
-        // This helps reduce memory pressure by allowing OS to release buffers
-        await encFinishPromise;
-        await originalFinishPromise;
-        logger?.debug('encrypted data successfully');
+        encWriteStream.push(mac);
+        encWriteStream.push(null);
+        writeStream?.end?.();
+        if (writeStream) await once(writeStream, 'finish');
+        finalStream.destroy();
         return {
             mediaKey,
-            originalFilePath,
-            encFilePath,
+            encWriteStream,
+            bodyPath,
             mac,
             fileEncSha256,
             fileSha256,
-            fileLength
+            fileLength,
+            didSaveToTmpPath
         };
     }
     catch (error) {
-        // destroy all streams with error
-        encFileWriteStream.destroy();
-        originalFileStream?.destroy?.();
+        encWriteStream.destroy();
+        writeStream?.destroy?.();
         aes.destroy();
         hmac.destroy();
         sha256Plain.destroy();
         sha256Enc.destroy();
         stream.destroy();
-        try {
-            await fs.unlink(encFilePath);
-            if (originalFilePath) {
-                await fs.unlink(originalFilePath);
-            }
-        }
-        catch (err) {
-            logger?.error({ err }, 'failed deleting tmp files');
+        if (didSaveToTmpPath) {
+            try { await fs.unlink(bodyPath); } catch (_) {}
         }
         throw error;
     }
 };
-export const DEF_MEDIA_HOST = 'mmg.whatsapp.net';
+
+const DEF_HOST = 'mmg.whatsapp.net';
 const AES_CHUNK_SIZE = 16;
 const toSmallestChunkSize = (num) => {
     return Math.floor(num / AES_CHUNK_SIZE) * AES_CHUNK_SIZE;
 };
-export const getUrlFromDirectPath = (directPath, host = DEF_MEDIA_HOST) => `https://${host}${directPath}`;
-const extractHost = (url) => {
-    if (!url)
-        return undefined;
-    try {
-        return new URL(url).host;
-    }
-    catch {
-        return undefined;
-    }
-};
+export const getUrlFromDirectPath = (directPath) => `https://${DEF_HOST}${directPath}`;
 export const downloadContentFromMessage = async ({ mediaKey, directPath, url }, type, opts = {}) => {
-    // Fallback host: explicit opt > host parsed from `url` > DEF_MEDIA_HOST.
-    // Lets us honor a non-default host carried by the proto without forcing callers to thread it through.
-    const fallbackHost = opts.host ?? extractHost(url);
-    const downloadUrl = directPath ? getUrlFromDirectPath(directPath, fallbackHost) : url;
+    const isValidMediaUrl = url?.startsWith('https://mmg.whatsapp.net/');
+    const downloadUrl = isValidMediaUrl ? url : getUrlFromDirectPath(directPath);
     if (!downloadUrl) {
         throw new Boom('No valid media URL or directPath present in message', { statusCode: 400 });
     }
@@ -546,7 +455,7 @@ export const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, {
     };
     const output = new Transform({
         transform(chunk, _, callback) {
-            let data = remainingBytes.length ? Buffer.concat([remainingBytes, chunk]) : chunk;
+            let data = Buffer.concat([remainingBytes, chunk]);
             const decryptLength = toSmallestChunkSize(data.length);
             remainingBytes = data.slice(decryptLength);
             data = data.slice(0, decryptLength);
@@ -665,10 +574,8 @@ const uploadWithFetch = async ({ url, filePath, headers, timeoutMs, agent }) =>
     // Convert Node.js Readable to Web ReadableStream
     const nodeStream = createReadStream(filePath);
     const webStream = Readable.toWeb(nodeStream);
-    // Native fetch only accepts Undici-style dispatchers, not generic https Agents.
-    const dispatcher = typeof agent?.dispatch === 'function' ? agent : undefined;
     const response = await fetch(url, {
-        ...(dispatcher ? { dispatcher } : {}),
+        dispatcher: agent,
         method: 'POST',
         body: webStream,
         headers,
@@ -710,17 +617,14 @@ const uploadMedia = async (params, logger) => {
     }
 };
 export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options }, refreshMediaConn) => {
-    return async (filePath, { mediaType, fileEncSha256B64, timeoutMs }) => {
-        // send a query JSON to obtain the url & auth token to upload our media
+    return async (streamOrPath, { mediaType, fileEncSha256B64, newsletter, timeoutMs }) => {
         let uploadInfo = await refreshMediaConn(false);
         let urls;
         const hosts = [...customUploadHosts, ...uploadInfo.hosts];
         fileEncSha256B64 = encodeBase64EncodedStringForUpload(fileEncSha256B64);
-        // Prepare common headers
         const customHeaders = (() => {
             const hdrs = options?.headers;
-            if (!hdrs)
-                return {};
+            if (!hdrs) return {};
             return Array.isArray(hdrs) ? Object.fromEntries(hdrs) : hdrs;
         })();
         const headers = {
@@ -728,23 +632,43 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
             'Content-Type': 'application/octet-stream',
             Origin: DEFAULT_ORIGIN
         };
+        let reqBuffer;
+        if (Buffer.isBuffer(streamOrPath)) {
+            reqBuffer = streamOrPath;
+        }
+        else if (typeof streamOrPath === 'string') {
+            reqBuffer = await fs.readFile(streamOrPath);
+        }
+        else {
+            const chunks = [];
+            for await (const chunk of streamOrPath) chunks.push(chunk);
+            reqBuffer = Buffer.concat(chunks);
+        }
+        let mediaPath = MEDIA_PATH_MAP[mediaType];
+        if (newsletter && mediaPath) {
+            mediaPath = mediaPath.replace('/mms/', '/newsletter/newsletter-');
+        }
         for (const { hostname } of hosts) {
             logger.debug(`uploading to "${hostname}"`);
             const auth = encodeURIComponent(uploadInfo.auth);
-            const url = `https://${hostname}${MEDIA_PATH_MAP[mediaType]}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
+            const url = `https://${hostname}${mediaPath}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
             let result;
             try {
-                result = await uploadMedia({
-                    url,
-                    filePath,
+                const axios = (await import('axios')).default;
+                const body = await axios.post(url, reqBuffer, {
                     headers,
-                    timeoutMs,
-                    agent: fetchAgent
-                }, logger);
+                    httpsAgent: fetchAgent,
+                    timeout: timeoutMs,
+                    responseType: 'json',
+                    maxBodyLength: Infinity,
+                    maxContentLength: Infinity
+                });
+                result = body.data;
                 if (result?.url || result?.direct_path) {
                     urls = {
                         mediaUrl: result.url,
                         directPath: result.direct_path,
+                        handle: result.handle,
                         meta_hmac: result.meta_hmac,
                         fbid: result.fbid,
                         ts: result.ts
@@ -767,6 +691,7 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
         return urls;
     };
 };
+
 const getMediaRetryKey = (mediaKey) => {
     return hkdf(mediaKey, 32, { info: 'WhatsApp Media Retry Notification' });
 };
@@ -854,124 +779,4 @@ const MEDIA_RETRY_STATUS_MAP = {
     [proto.MediaRetryNotification.ResultType.NOT_FOUND]: 404,
     [proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418
 };
-const runFfmpegBuffer = (args, input) => {
-    return new Promise((resolve, reject) => {
-        const ff = spawn('ffmpeg', args, { stdio: ['pipe', 'pipe', 'ignore'] });
-        const chunks = [];
-        let len = 0;
-        ff.stdout.on('data', (c) => {
-            chunks.push(c);
-            len += c.length;
-        });
-        ff.on('close', code => (code === 0 ? resolve(Buffer.concat(chunks, len)) : reject(new Boom(`ffmpeg exited with code ${code}`))));
-        ff.on('error', reject);
-        ff.stdin.end(input);
-    });
-};
-export const resizeImage = async (buf, width, height, opts = {}) => {
-    const { quality = 80 } = opts;
-    const lib = await getImageProcessingLibrary();
-    if ('sharp' in lib && typeof lib.sharp?.default === 'function') {
-        return lib.sharp.default(buf).resize(width, height, { fit: 'inside' }).jpeg({ quality }).toBuffer();
-    }
-    //@ts-ignore
-    const jimpMod = await import('jimp').catch(() => undefined);
-    if (jimpMod) {
-        const Jimp = jimpMod.default || jimpMod;
-        const img = await Jimp.read(buf);
-        img.resize(width, height);
-        img.quality(quality);
-        return img.getBufferAsync(Jimp.MIME_JPEG);
-    }
-    throw new Boom('resizeImage requires "sharp" or "jimp" to be installed', { statusCode: 500 });
-};
-export const convertMedia = async (buf, opts) => {
-    const fmt = opts.to.toLowerCase().replace('.', '');
-    const imageFormats = { jpeg: 'jpeg', jpg: 'jpeg', png: 'png', webp: 'webp' };
-    if (imageFormats[fmt]) {
-        const lib = await getImageProcessingLibrary();
-        if ('sharp' in lib && typeof lib.sharp?.default === 'function') {
-            return lib.sharp.default(buf).toFormat(imageFormats[fmt]).toBuffer();
-        }
-        throw new Boom('convertMedia to an image format requires "sharp" to be installed', { statusCode: 500 });
-    }
-    const args = ['-i', 'pipe:0', '-y'];
-    if (fmt === 'mp4') {
-        args.push('-movflags', 'frag_keyframe+empty_moov', '-f', 'mp4');
-    }
-    else {
-        args.push('-f', fmt);
-    }
-    args.push('pipe:1');
-    return runFfmpegBuffer(args, buf);
-};
-export const imageToWebpSticker = async (buf, opts = {}) => {
-    const { quality = 80 } = opts;
-    const lib = await getImageProcessingLibrary();
-    if ('sharp' in lib && typeof lib.sharp?.default === 'function') {
-        return lib.sharp
-            .default(buf)
-            .resize(512, 512, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
-            .webp({ quality })
-            .toBuffer();
-    }
-    throw new Boom('imageToWebpSticker requires "sharp" to be installed', { statusCode: 500 });
-};
-export const compressMedia = async (buf, opts = {}) => {
-    const { quality = 50 } = opts;
-    const lib = await getImageProcessingLibrary();
-    if ('sharp' in lib && typeof lib.sharp?.default === 'function') {
-        try {
-            const { format } = await lib.sharp.default(buf).metadata();
-            if (format) {
-                return lib.sharp.default(buf).toFormat(format, { quality }).toBuffer();
-            }
-        }
-        catch { }
-    }
-    const crf = String(Math.round(51 - (quality / 100) * 51));
-    return runFfmpegBuffer(['-i', 'pipe:0', '-y', '-crf', crf, '-preset', 'ultrafast', '-movflags', 'frag_keyframe+empty_moov', '-f', 'mp4', 'pipe:1'], buf);
-};
-export const getMediaMetadata = async (buf) => {
-    const result = { size: buf.length };
-    const lib = await getImageProcessingLibrary();
-    if ('sharp' in lib && typeof lib.sharp?.default === 'function') {
-        try {
-            const meta = await lib.sharp.default(buf).metadata();
-            if (meta.format) {
-                result.mimetype = `image/${meta.format}`;
-                result.width = meta.width;
-                result.height = meta.height;
-                result.channels = meta.channels;
-                result.hasAlpha = meta.hasAlpha;
-                return result;
-            }
-        }
-        catch { }
-    }
-    return new Promise(resolve => {
-        const ff = spawn('ffprobe', ['-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', 'pipe:0'], {
-            stdio: ['pipe', 'pipe', 'ignore']
-        });
-        const chunks = [];
-        ff.stdout.on('data', (c) => chunks.push(c));
-        ff.on('close', () => {
-            try {
-                const d = JSON.parse(Buffer.concat(chunks).toString());
-                const vid = d.streams?.find((s) => s.codec_type === 'video');
-                const aud = d.streams?.find((s) => s.codec_type === 'audio');
-                if (vid) {
-                    result.width = vid.width;
-                    result.height = vid.height;
-                }
-                result.duration = parseFloat(d.format?.duration) || undefined;
-                result.mimetype = vid ? 'video/mp4' : aud ? 'audio/mpeg' : undefined;
-            }
-            catch { }
-            resolve(result);
-        });
-        ff.on('error', () => resolve(result));
-        ff.stdin.end(buf);
-    });
-};
 //# sourceMappingURL=messages-media.js.map