@badzz88/baileys 8.5.3 → 8.5.4

package/lib/Utils/messages-media.js

@@ -60,6 +60,7 @@ exports.getStatusCodeForMediaRetry =
 	exports.downloadEncryptedContent =
 	exports.downloadContentFromMessage =
 	exports.getUrlFromDirectPath =
+	exports.getMediaProp =
 	exports.encryptedStream =
 	exports.getHttpStream =
 	exports.getStream =
@@ -93,7 +94,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')))
@@ -146,13 +147,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')
@@ -160,7 +161,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),
@@ -168,7 +169,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}`
@@ -181,8 +182,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)
 	}
@@ -225,9 +226,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()
@@ -253,7 +254,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')
@@ -274,12 +275,10 @@ 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)) {
@@ -291,22 +290,22 @@ async function getAudioWaveform(buffer, logger) {
 			audioData = await (0, exports.toBuffer)(buffer)
 		}
 		const audioBuffer = await decoder(audioData)
-		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 rawData = audioBuffer.getChannelData(0) 
+		const samples = 64 
+		const blockSize = Math.floor(rawData.length / samples) 
 		const filteredData = []
 		for (let i = 0; i < samples; i++) {
-			const blockStart = blockSize * i // the location of the first sample in the block
+			const blockStart = blockSize * i 
 			let sum = 0
 			for (let j = 0; j < blockSize; j++) {
-				sum = sum + Math.abs(rawData[blockStart + j]) // find the sum of all the samples in the block
+				sum = sum + Math.abs(rawData[blockStart + j]) 
 			}
-			filteredData.push(sum / blockSize) // divide the sum by the block size to get the average
+			filteredData.push(sum / blockSize) 
 		}
-		// 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) {
@@ -347,7 +346,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
@@ -385,7 +384,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
@@ -416,7 +415,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')
 		}
@@ -450,8 +449,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')
@@ -465,7 +464,7 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
 			fileLength
 		}
 	} catch (error) {
-		// destroy all streams with error
+		
 		encFileWriteStream.destroy()
 		originalFileStream?.destroy?.()
 		aes.destroy()
@@ -492,25 +491,74 @@ 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 isValidMediaUrl = url?.startsWith('https://mmg.whatsapp.net/')
-	const downloadUrl = isValidMediaUrl ? url : (0, exports.getUrlFromDirectPath)(directPath)
-	if (!downloadUrl) {
+	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 {
 		throw new boom_1.Boom('No valid media URL or directPath present in message', { statusCode: 400 })
 	}
 	const keys = await getMediaKeys(mediaKey, type)
-	return (0, exports.downloadEncryptedContent)(downloadUrl, keys, opts)
+	
+	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
+	}
 }
 exports.downloadContentFromMessage = downloadContentFromMessage
-/**
- * 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 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
+
 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) {
@@ -531,7 +579,7 @@ const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, { startB
 			headers.Range += endChunk
 		}
 	}
-	// download the message
+	
 	const fetched = await (0, exports.getHttpStream)(downloadUrl, {
 		...(options || {}),
 		headers
@@ -561,8 +609,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)
 				}
@@ -583,7 +631,15 @@ const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, { startB
 			}
 		}
 	})
-	return fetched.pipe(output, { end: true })
+	
+	
+	
+	;(0, stream_1.pipeline)(fetched, output, error => {
+		if (error && !output.destroyed) {
+			output.destroy(error)
+		}
+	})
+	return output
 }
 exports.downloadEncryptedContent = downloadEncryptedContent
 function extensionForMediaMessage(message) {
@@ -606,6 +662,14 @@ 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')
@@ -615,7 +679,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) => {
@@ -629,13 +693,13 @@ const uploadWithNodeHttp = async ({ url, filePath, headers, timeoutMs, agent },
 					...headers,
 					'Content-Length': fileSize
 				},
-				agent,
+				agent: isFetchDispatcher(agent) ? undefined : agent,
 				timeout: timeoutMs
 			},
 			res => {
-				// Handle redirects (3xx)
+				
 				if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-					res.resume() // Consume response to free resources
+					res.resume() 
 					const newUrl = new url_1.URL(res.headers.location, url).toString()
 					resolve(
 						(0, exports.uploadWithNodeHttp)(
@@ -655,13 +719,9 @@ const uploadWithNodeHttp = async ({ url, filePath, headers, timeoutMs, agent },
 				res.on('data', chunk => (body += chunk))
 				res.on('end', () => {
 					try {
-						const parsed = JSON.parse(body)
-						if (parsed && typeof parsed === 'object') {
-							Object.defineProperty(parsed, '__statusCode', { value: res.statusCode, enumerable: false })
-						}
-						resolve(parsed)
+						resolve(JSON.parse(body))
 					} catch {
-						resolve({ __statusCode: res.statusCode })
+						resolve(undefined)
 					}
 				})
 			}
@@ -681,11 +741,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: agent,
+		dispatcher: isFetchDispatcher(agent) ? agent : undefined,
 		method: 'POST',
 		body: webStream,
 		headers,
@@ -693,49 +753,32 @@ const uploadWithFetch = async ({ url, filePath, headers, timeoutMs, agent }) =>
 		signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined
 	})
 	try {
-		const parsed = await response.json()
-		if (parsed && typeof parsed === 'object') {
-			Object.defineProperty(parsed, '__statusCode', { value: response.status, enumerable: false })
-		}
-		return parsed
+		return await response.json()
 	} catch {
-		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.
- */
+		return undefined
+	}
+}
+
 const uploadMedia = async (params, logger) => {
-	if (isNodeRuntime()) {
+	if (isNodeRuntime() && !isFetchDispatcher(params.agent)) {
 		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 {}
@@ -751,52 +794,37 @@ 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
-			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)}`)
+			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
 					}
 					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 })
@@ -806,11 +834,12 @@ 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()
@@ -825,9 +854,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: {},
@@ -841,7 +870,7 @@ const encryptMediaRetryRequest = (key, mediaKey, meId) => {
 				attrs: {
 					jid: key.remoteJid,
 					from_me: (!!key.fromMe).toString(),
-					// @ts-ignore
+					
 					participant: key.participant || undefined
 				}
 			}