@badzz88/baileys 8.5.4 → 8.5.5

package/lib/Utils/messages-media.js

@@ -60,7 +60,6 @@ exports.getStatusCodeForMediaRetry =
 	exports.downloadEncryptedContent =
 	exports.downloadContentFromMessage =
 	exports.getUrlFromDirectPath =
-	exports.getMediaProp =
 	exports.encryptedStream =
 	exports.getHttpStream =
 	exports.getStream =
@@ -94,7 +93,7 @@ const crypto_1 = require('./crypto')
 const generics_1 = require('./generics')
 const getTmpFilesDirectory = () => (0, os_1.tmpdir)()
 const getImageProcessingLibrary = async () => {
-	
+	//@ts-ignore
 	const [jimp, sharp] = await Promise.all([
 		Promise.resolve()
 			.then(() => __importStar(require('jimp')))
@@ -147,13 +146,13 @@ const getRawMediaUploadData = async (media, mediaType, logger) => {
 		try {
 			await fs_1.promises.unlink(filePath)
 		} catch {
-			
+			//
 		}
 		throw error
 	}
 }
 exports.getRawMediaUploadData = getRawMediaUploadData
-
+/** generates all the keys required to encrypt/decrypt & sign a media message */
 async function getMediaKeys(buffer, mediaType) {
 	if (!buffer) {
 		throw new boom_1.Boom('Cannot derive from empty media key')
@@ -161,7 +160,7 @@ async function getMediaKeys(buffer, mediaType) {
 	if (typeof buffer === 'string') {
 		buffer = Buffer.from(buffer.replace('data:;base64,', ''), 'base64')
 	}
-	
+	// expand using HKDF to 112 bytes, also pass in the relevant app info
 	const expandedMediaKey = (0, crypto_1.hkdf)(buffer, 112, { info: (0, exports.hkdfInfoKey)(mediaType) })
 	return {
 		iv: expandedMediaKey.slice(0, 16),
@@ -169,7 +168,7 @@ async function getMediaKeys(buffer, mediaType) {
 		macKey: expandedMediaKey.slice(48, 80)
 	}
 }
-
+/** Extracts video thumb using FFMPEG */
 const extractVideoThumb = async (path, destPath, time, size) =>
 	new Promise((resolve, reject) => {
 		const cmd = `ffmpeg -ss ${time} -i ${path} -y -vf scale=${size.width}:-1 -vframes 1 -f image2 ${destPath}`
@@ -182,8 +181,8 @@ const extractVideoThumb = async (path, destPath, time, size) =>
 		})
 	})
 const extractImageThumb = async (bufferOrFilePath, width = 32) => {
-	
-	
+	// TODO: Move entirely to sharp, removing jimp as it supports readable streams
+	// This will have positive speed and performance impacts as well as minimizing RAM usage.
 	if (bufferOrFilePath instanceof stream_1.Readable) {
 		bufferOrFilePath = await (0, exports.toBuffer)(bufferOrFilePath)
 	}
@@ -226,9 +225,9 @@ const generateProfilePicture = async (mediaUpload, dimensions) => {
 	if (Buffer.isBuffer(mediaUpload)) {
 		buffer = mediaUpload
 	} else {
-		
+		// Use getStream to handle all WAMediaUpload types (Buffer, Stream, URL)
 		const { stream } = await (0, exports.getStream)(mediaUpload)
-		
+		// Convert the resulting stream to a buffer
 		buffer = await (0, exports.toBuffer)(stream)
 	}
 	const lib = await getImageProcessingLibrary()
@@ -254,7 +253,7 @@ const generateProfilePicture = async (mediaUpload, dimensions) => {
 	}
 }
 exports.generateProfilePicture = generateProfilePicture
-
+/** gets the SHA256 of the given media message */
 const mediaMessageSHA256B64 = message => {
 	const media = Object.values(message)[0]
 	return media?.fileSha256 && Buffer.from(media.fileSha256).toString('base64')
@@ -275,10 +274,12 @@ async function getAudioDuration(buffer) {
 	}
 	return metadata.format.duration
 }
-
+/**
+  referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
+ */
 async function getAudioWaveform(buffer, logger) {
 	try {
-		
+		// @ts-ignore
 		const { default: decoder } = await Promise.resolve().then(() => __importStar(require('audio-decode')))
 		let audioData
 		if (Buffer.isBuffer(buffer)) {
@@ -290,22 +291,22 @@ async function getAudioWaveform(buffer, logger) {
 			audioData = await (0, exports.toBuffer)(buffer)
 		}
 		const audioBuffer = await decoder(audioData)
-		const rawData = audioBuffer.getChannelData(0) 
-		const samples = 64 
-		const blockSize = Math.floor(rawData.length / samples) 
+		const rawData = audioBuffer.getChannelData(0) // We only need to work with one channel of data
+		const samples = 64 // Number of samples we want to have in our final data set
+		const blockSize = Math.floor(rawData.length / samples) // the number of samples in each subdivision
 		const filteredData = []
 		for (let i = 0; i < samples; i++) {
-			const blockStart = blockSize * i 
+			const blockStart = blockSize * i // the location of the first sample in the block
 			let sum = 0
 			for (let j = 0; j < blockSize; j++) {
-				sum = sum + Math.abs(rawData[blockStart + j]) 
+				sum = sum + Math.abs(rawData[blockStart + j]) // find the sum of all the samples in the block
 			}
-			filteredData.push(sum / blockSize) 
+			filteredData.push(sum / blockSize) // divide the sum by the block size to get the average
 		}
-		
+		// This guarantees that the largest data point will be set to 1, and the rest of the data will scale proportionally.
 		const multiplier = Math.pow(Math.max(...filteredData), -1)
 		const normalizedData = filteredData.map(n => n * multiplier)
-		
+		// Generate waveform like WhatsApp
 		const waveform = new Uint8Array(normalizedData.map(n => Math.floor(100 * n)))
 		return waveform
 	} catch (e) {
@@ -346,7 +347,7 @@ const getStream = async (item, opts) => {
 	return { stream: (0, fs_1.createReadStream)(item.url), type: 'file' }
 }
 exports.getStream = getStream
-
+/** generates a thumbnail for a given media, if required */
 async function generateThumbnail(file, mediaType, options) {
 	let thumbnail
 	let originalImageDimensions
@@ -384,7 +385,7 @@ const getHttpStream = async (url, options = {}) => {
 	if (!response.ok) {
 		throw new boom_1.Boom(`Failed to fetch stream from ${url}`, { statusCode: response.status, data: { url } })
 	}
-	
+	// @ts-ignore Node18+ Readable.fromWeb exists
 	return response.body instanceof stream_1.Readable ? response.body : stream_1.Readable.fromWeb(response.body)
 }
 exports.getHttpStream = getHttpStream
@@ -415,7 +416,7 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
 	const onChunk = async buff => {
 		sha256Enc.update(buff)
 		hmac.update(buff)
-		
+		// Handle backpressure: if write returns false, wait for drain
 		if (!encFileWriteStream.write(buff)) {
 			await (0, events_1.once)(encFileWriteStream, 'drain')
 		}
@@ -449,8 +450,8 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
 		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')
@@ -464,7 +465,7 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
 			fileLength
 		}
 	} catch (error) {
-		
+		// destroy all streams with error
 		encFileWriteStream.destroy()
 		originalFileStream?.destroy?.()
 		aes.destroy()
@@ -491,74 +492,25 @@ const toSmallestChunkSize = num => {
 }
 const getUrlFromDirectPath = directPath => `https://${DEF_HOST}${directPath}`
 exports.getUrlFromDirectPath = getUrlFromDirectPath
-
-const getMediaProp = (mediaAbProps, propName) => {
-	if (!mediaAbProps || typeof mediaAbProps !== 'object') return false
-	return !!mediaAbProps[propName]
-}
-exports.getMediaProp = getMediaProp
 const downloadContentFromMessage = async ({ mediaKey, directPath, url }, type, opts = {}) => {
-	const directUrl = directPath ? (0, exports.getUrlFromDirectPath)(directPath) : undefined
-	const fallbackUrl = url?.startsWith('https://') ? url : undefined
-	
-	
-	let downloadUrl
-	if (directUrl) {
-		downloadUrl = directUrl
-	} else if (fallbackUrl) {
-		downloadUrl = fallbackUrl
-	} else {
+	const isValidMediaUrl = url?.startsWith('https://mmg.whatsapp.net/')
+	const downloadUrl = isValidMediaUrl ? url : (0, exports.getUrlFromDirectPath)(directPath)
+	if (!downloadUrl) {
 		throw new boom_1.Boom('No valid media URL or directPath present in message', { statusCode: 400 })
 	}
 	const keys = await getMediaKeys(mediaKey, type)
-	
-	const mediaAbProps = opts.mediaAbProps
-	const pjpegHeaders = {}
-	if (type === 'image' && getMediaProp(mediaAbProps, 'partial_pjpeg_enabled')) {
-		
-		pjpegHeaders['X-WhatsApp-PJPEG'] = '1'
-	}
-	if (type === 'image' && getMediaProp(mediaAbProps, 'multi_scan_pjpeg')) {
-		pjpegHeaders['X-WhatsApp-Multi-Scan-PJPEG'] = '1'
-	}
-	const mergedOpts = Object.keys(pjpegHeaders).length
-		? { ...opts, options: { ...(opts.options || {}), headers: { ...(opts.options?.headers || {}), ...pjpegHeaders } } }
-		: opts
-	try {
-		return await (0, exports.downloadEncryptedContent)(downloadUrl, keys, mergedOpts)
-	} catch (err) {
-		
-		if (directUrl && fallbackUrl && fallbackUrl !== directUrl) {
-			return (0, exports.downloadEncryptedContent)(fallbackUrl, keys, mergedOpts)
-		}
-		throw err
-	}
+	return (0, exports.downloadEncryptedContent)(downloadUrl, keys, opts)
 }
 exports.downloadContentFromMessage = downloadContentFromMessage
-
-const downloadMediaChunk = (message, type, startByte, endByte, opts = {}) =>
-	downloadContentFromMessage(message, type, { ...opts, startByte, endByte })
-exports.downloadMediaChunk = downloadMediaChunk
-
-async function* streamMediaChunks(message, type, opts = {}) {
-	const chunkSize = opts.chunkSize || 2 * 1024 * 1024
-	const fileLength = message.fileLength
-	if (!fileLength || fileLength <= chunkSize) {
-		yield downloadContentFromMessage(message, type, opts)
-		return
-	}
-	for (let offset = 0; offset < fileLength; offset += chunkSize) {
-		const endByte = Math.min(offset + chunkSize - 1, fileLength - 1)
-		yield downloadContentFromMessage(message, type, { ...opts, startByte: offset, endByte })
-	}
-}
-exports.streamMediaChunks = streamMediaChunks
-
+/**
+ * Decrypts and downloads an AES256-CBC encrypted file given the keys.
+ * Assumes the SHA256 of the plaintext is appended to the end of the ciphertext
+ * */
 const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, { startByte, endByte, options } = {}) => {
 	let bytesFetched = 0
 	let startChunk = 0
 	let firstBlockIsIV = false
-	
+	// if a start byte is specified -- then we need to fetch the previous chunk as that will form the IV
 	if (startByte) {
 		const chunk = toSmallestChunkSize(startByte || 0)
 		if (chunk) {
@@ -579,7 +531,7 @@ const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, { startB
 			headers.Range += endChunk
 		}
 	}
-	
+	// download the message
 	const fetched = await (0, exports.getHttpStream)(downloadUrl, {
 		...(options || {}),
 		headers
@@ -609,8 +561,8 @@ const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, { startB
 					data = data.slice(AES_CHUNK_SIZE)
 				}
 				aes = Crypto.createDecipheriv('aes-256-cbc', cipherKey, ivValue)
-				
-				
+				// if an end byte that is not EOF is specified
+				// stop auto padding (PKCS7) -- otherwise throws an error for decryption
 				if (endByte) {
 					aes.setAutoPadding(false)
 				}
@@ -631,15 +583,7 @@ const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, { startB
 			}
 		}
 	})
-	
-	
-	
-	;(0, stream_1.pipeline)(fetched, output, error => {
-		if (error && !output.destroyed) {
-			output.destroy(error)
-		}
-	})
-	return output
+	return fetched.pipe(output, { end: true })
 }
 exports.downloadEncryptedContent = downloadEncryptedContent
 function extensionForMediaMessage(message) {
@@ -662,14 +606,6 @@ const isNodeRuntime = () => {
 		typeof globalThis.Deno === 'undefined'
 	)
 }
-
-
-
-
-const isFetchDispatcher = agent => {
-	return !!agent && typeof agent.dispatch === 'function'
-}
-exports.isFetchDispatcher = isFetchDispatcher
 const uploadWithNodeHttp = async ({ url, filePath, headers, timeoutMs, agent }, redirectCount = 0) => {
 	if (redirectCount > 5) {
 		throw new Error('Too many redirects')
@@ -679,7 +615,7 @@ const uploadWithNodeHttp = async ({ url, filePath, headers, timeoutMs, agent },
 		parsedUrl.protocol === 'https:'
 			? await Promise.resolve().then(() => __importStar(require('https')))
 			: await Promise.resolve().then(() => __importStar(require('http')))
-	
+	// Get file size for Content-Length header (required for Node.js streaming)
 	const fileStats = await fs_1.promises.stat(filePath)
 	const fileSize = fileStats.size
 	return new Promise((resolve, reject) => {
@@ -693,13 +629,13 @@ const uploadWithNodeHttp = async ({ url, filePath, headers, timeoutMs, agent },
 					...headers,
 					'Content-Length': fileSize
 				},
-				agent: isFetchDispatcher(agent) ? undefined : agent,
+				agent,
 				timeout: timeoutMs
 			},
 			res => {
-				
+				// Handle redirects (3xx)
 				if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-					res.resume() 
+					res.resume() // Consume response to free resources
 					const newUrl = new url_1.URL(res.headers.location, url).toString()
 					resolve(
 						(0, exports.uploadWithNodeHttp)(
@@ -719,9 +655,13 @@ const uploadWithNodeHttp = async ({ url, filePath, headers, timeoutMs, agent },
 				res.on('data', chunk => (body += chunk))
 				res.on('end', () => {
 					try {
-						resolve(JSON.parse(body))
+						const parsed = JSON.parse(body)
+						if (parsed && typeof parsed === 'object') {
+							Object.defineProperty(parsed, '__statusCode', { value: res.statusCode, enumerable: false })
+						}
+						resolve(parsed)
 					} catch {
-						resolve(undefined)
+						resolve({ __statusCode: res.statusCode })
 					}
 				})
 			}
@@ -741,11 +681,11 @@ const uploadWithNodeHttp = async ({ url, filePath, headers, timeoutMs, agent },
 }
 exports.uploadWithNodeHttp = uploadWithNodeHttp
 const uploadWithFetch = async ({ url, filePath, headers, timeoutMs, agent }) => {
-	
+	// Convert Node.js Readable to Web ReadableStream
 	const nodeStream = (0, fs_1.createReadStream)(filePath)
 	const webStream = stream_1.Readable.toWeb(nodeStream)
 	const response = await fetch(url, {
-		dispatcher: isFetchDispatcher(agent) ? agent : undefined,
+		dispatcher: agent,
 		method: 'POST',
 		body: webStream,
 		headers,
@@ -753,32 +693,49 @@ const uploadWithFetch = async ({ url, filePath, headers, timeoutMs, agent }) =>
 		signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined
 	})
 	try {
-		return await response.json()
+		const parsed = await response.json()
+		if (parsed && typeof parsed === 'object') {
+			Object.defineProperty(parsed, '__statusCode', { value: response.status, enumerable: false })
+		}
+		return parsed
 	} catch {
-		return undefined
-	}
-}
-
+		return { __statusCode: response.status }
+	}
+}
+/**
+ * Uploads media to WhatsApp servers.
+ *
+ * ## Why we have two upload implementations:
+ *
+ * Node.js's native `fetch` (powered by undici) has a known bug where it buffers
+ * the entire request body in memory before sending, even when using streams.
+ * This causes memory issues with large files (e.g., 1GB file = 1GB+ memory usage).
+ * See: https://github.com/nodejs/undici/issues/4058
+ *
+ * Other runtimes (Bun, Deno, browsers) correctly stream the request body without
+ * buffering, so we can use the web-standard Fetch API there.
+ *
+ * ## Future considerations:
+ * Once the undici bug is fixed, we can simplify this to use only the Fetch API
+ * across all runtimes. Monitor the GitHub issue for updates.
+ */
 const uploadMedia = async (params, logger) => {
-	if (isNodeRuntime() && !isFetchDispatcher(params.agent)) {
+	if (isNodeRuntime()) {
 		logger?.debug('Using Node.js https module for upload (avoids undici buffering bug)')
 		return (0, exports.uploadWithNodeHttp)(params)
 	} else {
-		
-		
 		logger?.debug('Using web-standard Fetch API for upload')
 		return uploadWithFetch(params)
 	}
 }
-exports.uploadMedia = uploadMedia
 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
 		let uploadInfo = await refreshMediaConn(false)
 		let urls
 		const hosts = [...customUploadHosts, ...uploadInfo.hosts]
 		fileEncSha256B64 = (0, exports.encodeBase64EncodedStringForUpload)(fileEncSha256B64)
-		
+		// Prepare common headers
 		const customHeaders = (() => {
 			const hdrs = options?.headers
 			if (!hdrs) return {}
@@ -794,37 +751,52 @@ const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options },
 			const auth = encodeURIComponent(uploadInfo.auth)
 			const url = `https://${hostname}${Defaults_1.MEDIA_PATH_MAP[mediaType]}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`
 			let result
-			try {
-				result = await uploadMedia(
-					{
-						url,
-						filePath,
-						headers,
-						timeoutMs,
-						agent: fetchAgent
-					},
-					logger
-				)
-				if (result?.url || result?.direct_path) {
-					urls = {
-						mediaUrl: result.url,
-						directPath: result.direct_path,
-						meta_hmac: result.meta_hmac,
-						fbid: result.fbid,
-						ts: result.ts
+			const maxRateLimitRetries = 3
+			for (let attempt = 0; attempt <= maxRateLimitRetries; attempt++) {
+				try {
+					result = await uploadMedia(
+						{
+							url,
+							filePath,
+							headers,
+							timeoutMs,
+							agent: fetchAgent
+						},
+						logger
+					)
+					const isRateLimited = result?.__statusCode === 429 || result?.__statusCode === 503
+					if (isRateLimited && attempt < maxRateLimitRetries) {
+						const backoffMs = Math.min(500 * 2 ** attempt, 8000) + Math.floor(Math.random() * 250)
+						logger.warn(
+							{ hostname, attempt, backoffMs, statusCode: result.__statusCode },
+							'media upload rate-limited, backing off before retry'
+						)
+						await new Promise(resolve => setTimeout(resolve, backoffMs))
+						continue
 					}
+					if (result?.url || result?.direct_path) {
+						urls = {
+							mediaUrl: result.url,
+							directPath: result.direct_path,
+							meta_hmac: result.meta_hmac,
+							fbid: result.fbid,
+							ts: result.ts
+						}
+					} else {
+						uploadInfo = await refreshMediaConn(true)
+						throw new Error(`upload failed, reason: ${JSON.stringify(result)}`)
+					}
+					break
+				} catch (error) {
+					const isLast = hostname === hosts[uploadInfo.hosts.length - 1]?.hostname
+					logger.warn(
+						{ trace: error?.stack, uploadResult: result },
+						`Error in uploading to ${hostname} ${isLast ? '' : ', retrying...'}`
+					)
 					break
-				} else {
-					uploadInfo = await refreshMediaConn(true)
-					throw new Error(`upload failed, reason: ${JSON.stringify(result)}`)
 				}
-			} catch (error) {
-				const isLast = hostname === hosts[uploadInfo.hosts.length - 1]?.hostname
-				logger.warn(
-					{ trace: error?.stack, uploadResult: result },
-					`Error in uploading to ${hostname} ${isLast ? '' : ', retrying...'}`
-				)
 			}
+			if (urls) break
 		}
 		if (!urls) {
 			throw new boom_1.Boom('Media upload failed on all hosts', { statusCode: 500 })
@@ -834,12 +806,11 @@ const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options },
 }
 exports.getWAUploadToServer = getWAUploadToServer
 const getMediaRetryKey = mediaKey => {
-	if (typeof mediaKey === 'string') {
-		mediaKey = Buffer.from(mediaKey.replace('data:;base64,', ''), 'base64')
-	}
 	return (0, crypto_1.hkdf)(mediaKey, 32, { info: 'WhatsApp Media Retry Notification' })
 }
-
+/**
+ * Generate a binary node that will request the phone to re-upload the media & return the newly uploaded URL
+ */
 const encryptMediaRetryRequest = (key, mediaKey, meId) => {
 	const recp = { stanzaId: key.id }
 	const recpBuffer = index_js_1.proto.ServerErrorReceipt.encode(recp).finish()
@@ -854,9 +825,9 @@ const encryptMediaRetryRequest = (key, mediaKey, meId) => {
 			type: 'server-error'
 		},
 		content: [
-			
-			
-			
+			// this encrypt node is actually pretty useless
+			// the media is returned even without this node
+			// keeping it here to maintain parity with WA Web
 			{
 				tag: 'encrypt',
 				attrs: {},
@@ -870,7 +841,7 @@ const encryptMediaRetryRequest = (key, mediaKey, meId) => {
 				attrs: {
 					jid: key.remoteJid,
 					from_me: (!!key.fromMe).toString(),
-					
+					// @ts-ignore
 					participant: key.participant || undefined
 				}
 			}