@badzz88/baileys 8.5.3 → 8.5.4

package/lib/Utils/session-pool.js

@@ -1,94 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.createSessionPool = void 0
-
-const DISCONNECT_REASON_LOGGED_OUT = 401
-
-/**
- * Manages multiple Baileys socket instances (one per account/session), automatically
- * restarting any session that disconnects -- except when it was logged out -- using
- * exponential backoff with jitter, instead of every project re-implementing its own
- * reconnect loop.
- *
- * @param {{
- *   makeSocket: (sessionId: string) => Promise<any> | any,
- *   logger?: any,
- *   maxBackoffMs?: number,
- *   onSessionUpdate?: (sessionId: string, sock: any) => void,
- *   onLoggedOut?: (sessionId: string) => void
- * }} options
- * @returns {{
- *   add: (sessionId: string) => Promise<void>,
- *   remove: (sessionId: string) => void,
- *   get: (sessionId: string) => any,
- *   list: () => string[]
- * }}
- */
-const createSessionPool = options => {
-	const logger = options.logger
-	const maxBackoffMs = options.maxBackoffMs ?? 60000
-	const sessions = new Map() // sessionId -> { sock, attempts, stopped }
-
-	const computeBackoffMs = attempts => {
-		const base = Math.min(1000 * 2 ** attempts, maxBackoffMs)
-		return base + Math.floor(Math.random() * (base * 0.2))
-	}
-
-	const start = async sessionId => {
-		const entry = sessions.get(sessionId) || { attempts: 0, stopped: false }
-		sessions.set(sessionId, entry)
-		if (entry.stopped) return
-		try {
-			const sock = await options.makeSocket(sessionId)
-			entry.sock = sock
-			options.onSessionUpdate?.(sessionId, sock)
-			sock.ev.on('connection.update', update => {
-				if (update.connection === 'open') {
-					entry.attempts = 0
-				}
-				if (update.connection === 'close') {
-					const statusCode = update.lastDisconnect?.error?.output?.statusCode
-					if (statusCode === DISCONNECT_REASON_LOGGED_OUT) {
-						logger?.info?.({ sessionId }, 'session logged out, removing from pool')
-						sessions.delete(sessionId)
-						options.onLoggedOut?.(sessionId)
-						return
-					}
-					if (entry.stopped) return
-					entry.attempts += 1
-					const backoffMs = computeBackoffMs(entry.attempts)
-					logger?.warn?.(
-						{ sessionId, attempt: entry.attempts, backoffMs },
-						'session disconnected, reconnecting with backoff'
-					)
-					setTimeout(() => start(sessionId), backoffMs)
-				}
-			})
-		} catch (error) {
-			entry.attempts += 1
-			const backoffMs = computeBackoffMs(entry.attempts)
-			logger?.error?.({ error, sessionId, backoffMs }, 'failed to start session, retrying with backoff')
-			if (!entry.stopped) {
-				setTimeout(() => start(sessionId), backoffMs)
-			}
-		}
-	}
-
-	const add = sessionId => start(sessionId)
-	const remove = sessionId => {
-		const entry = sessions.get(sessionId)
-		if (!entry) return
-		entry.stopped = true
-		if (entry.sock?.end) {
-			try {
-				entry.sock.end(undefined)
-			} catch {}
-		}
-		sessions.delete(sessionId)
-	}
-	const get = sessionId => sessions.get(sessionId)?.sock
-	const list = () => [...sessions.keys()]
-
-	return { add, remove, get, list }
-}
-exports.createSessionPool = createSessionPool

package/lib/Utils/sticker.d.ts

@@ -1,17 +0,0 @@
-export interface StickerMetaOptions {
-	packName?: string
-	packPublisher?: string
-	categories?: string[]
-}
-
-export function addExifToWebp(webpBuffer: Buffer, options?: StickerMetaOptions): Promise<Buffer>
-
-export function imageToWebpSticker(
-	imageBuffer: Buffer,
-	options?: StickerMetaOptions & { quality?: number }
-): Promise<Buffer>
-
-export function videoToWebpSticker(
-	videoBuffer: Buffer,
-	options?: StickerMetaOptions & { fps?: number; seconds?: number }
-): Promise<Buffer>

package/lib/Utils/sticker.js

@@ -1,145 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.imageToWebpSticker = exports.videoToWebpSticker = exports.addExifToWebp = void 0
-const os = require('os')
-const path = require('path')
-const fs = require('fs')
-const crypto = require('crypto')
-const { exec } = require('child_process')
-
-/**
- * Builds and writes the EXIF metadata WhatsApp expects on sticker webp files
- * (pack name / author, shown when a user long-presses a sticker).
- * Converts the file to the "extended" (VP8X) WebP container if it isn't already,
- * since that's the container format that actually carries an EXIF chunk.
- * Returns the new buffer with EXIF attached.
- */
-const addExifToWebp = async (webpBuffer, { packName = '', packPublisher = '', categories = [] } = {}) => {
-	const json = {
-		'sticker-pack-id': crypto.randomBytes(16).toString('hex'),
-		'sticker-pack-name': packName,
-		'sticker-pack-publisher': packPublisher,
-		emojis: categories.length ? categories : ['😀']
-	}
-	const jsonBuffer = Buffer.from(JSON.stringify(json), 'utf-8')
-	// TIFF header + IFD entry pointing at a single custom tag (0x5741 "AW") holding
-	// the JSON payload -- this is the exact structure WhatsApp's client parses.
-	const exifAttr = Buffer.from([
-		0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
-		0x00, 0x00, 0x00
-	])
-	exifAttr.writeUIntLE(jsonBuffer.length, 14, 4)
-	const exifPayload = Buffer.concat([exifAttr, jsonBuffer])
-	const pad = buf => (buf.length % 2 === 1 ? Buffer.concat([buf, Buffer.from([0x00])]) : buf)
-	const makeChunk = (tag, data) => {
-		const sizeField = Buffer.alloc(4)
-		sizeField.writeUInt32LE(data.length, 0)
-		return Buffer.concat([Buffer.from(tag, 'ascii'), sizeField, pad(data)])
-	}
-	const exifChunk = makeChunk('EXIF', exifPayload)
-	if (webpBuffer.slice(0, 4).toString('ascii') !== 'RIFF' || webpBuffer.slice(8, 12).toString('ascii') !== 'WEBP') {
-		throw new Error('addExifToWebp expects a valid WebP buffer')
-	}
-	let offset = 12
-	let vp8xChunk = null
-	let vp8xOffset = -1
-	const otherChunks = []
-	while (offset < webpBuffer.length) {
-		const tag = webpBuffer.slice(offset, offset + 4).toString('ascii')
-		const size = webpBuffer.readUInt32LE(offset + 4)
-		const dataStart = offset + 8
-		const dataEnd = dataStart + size
-		const chunkTotal = 8 + size + (size % 2)
-		if (tag === 'VP8X') {
-			vp8xChunk = webpBuffer.slice(offset, offset + chunkTotal)
-			vp8xOffset = offset
-		} else if (tag !== 'EXIF') {
-			// drop any pre-existing EXIF chunk, keep everything else (VP8/VP8L/ANIM/ANMF/ICCP/...)
-			otherChunks.push(webpBuffer.slice(offset, offset + chunkTotal))
-		}
-		offset += chunkTotal
-	}
-	let flags
-	let canvasWidth
-	let canvasHeight
-	if (vp8xChunk) {
-		flags = vp8xChunk.readUInt8(8)
-		canvasWidth = vp8xChunk.readUIntLE(12, 3) + 1
-		canvasHeight = vp8xChunk.readUIntLE(15, 3) + 1
-	} else {
-		flags = 0
-		let sharp
-		try {
-			sharp = require('sharp')
-		} catch (error) {
-			throw new Error('addExifToWebp needs the optional "sharp" dependency to read image dimensions')
-		}
-		const meta = await sharp(webpBuffer).metadata()
-		canvasWidth = meta.width
-		canvasHeight = meta.height
-	}
-	flags |= 0x08 // set the "has EXIF metadata" bit
-	const vp8xData = Buffer.alloc(10)
-	vp8xData.writeUInt8(flags, 0)
-	vp8xData.writeUIntLE(canvasWidth - 1, 4, 3)
-	vp8xData.writeUIntLE(canvasHeight - 1, 7, 3)
-	const newVp8xChunk = makeChunk('VP8X', vp8xData)
-	const body = Buffer.concat([newVp8xChunk, ...otherChunks, exifChunk])
-	const fileSize = Buffer.alloc(4)
-	fileSize.writeUInt32LE(4 + body.length, 0) // 4 = 'WEBP'
-	return Buffer.concat([Buffer.from('RIFF', 'ascii'), fileSize, Buffer.from('WEBP', 'ascii'), body])
-}
-exports.addExifToWebp = addExifToWebp
-
-/**
- * Converts a static image buffer to a WhatsApp sticker-ready webp buffer using `sharp`.
- * @param {Buffer} imageBuffer
- * @param {{ packName?: string, packPublisher?: string, categories?: string[], quality?: number }} [options]
- * @returns {Promise<Buffer>}
- */
-const imageToWebpSticker = async (imageBuffer, options = {}) => {
-	let sharp
-	try {
-		sharp = require('sharp')
-	} catch (error) {
-		throw new Error('imageToWebpSticker requires the optional "sharp" dependency to be installed')
-	}
-	const webp = await sharp(imageBuffer)
-		.resize(512, 512, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
-		.webp({ quality: options.quality ?? 80 })
-		.toBuffer()
-	return addExifToWebp(webp, options)
-}
-exports.imageToWebpSticker = imageToWebpSticker
-
-/**
- * Converts a video buffer to an animated WhatsApp sticker-ready webp buffer.
- * Requires the `ffmpeg` binary to be available on PATH.
- * @param {Buffer} videoBuffer
- * @param {{ packName?: string, packPublisher?: string, categories?: string[], fps?: number, seconds?: number }} [options]
- * @returns {Promise<Buffer>}
- */
-const videoToWebpSticker = async (videoBuffer, options = {}) => {
-	const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'xazbails-sticker-'))
-	const inputPath = path.join(tmpDir, 'input.mp4')
-	const outputPath = path.join(tmpDir, 'output.webp')
-	fs.writeFileSync(inputPath, videoBuffer)
-	const fps = options.fps ?? 10
-	const seconds = options.seconds ?? 5
-	const cmd =
-		`ffmpeg -y -i ${inputPath} -t ${seconds} -vf ` +
-		`"fps=${fps},scale=512:512:force_original_aspect_ratio=decrease,` +
-		`pad=512:512:(ow-iw)/2:(oh-ih)/2:color=0x00000000,split[a][b];` +
-		`[a]palettegen=reserve_transparent=1[p];[b][p]paletteuse" ` +
-		`-loop 0 -preset default -an -vsync 0 ${outputPath}`
-	try {
-		await new Promise((resolve, reject) => {
-			exec(cmd, err => (err ? reject(err) : resolve()))
-		})
-		const webp = fs.readFileSync(outputPath)
-		return await addExifToWebp(webp, options)
-	} finally {
-		fs.rmSync(tmpDir, { recursive: true, force: true })
-	}
-}
-exports.videoToWebpSticker = videoToWebpSticker

package/lib/Utils/view-once-cache.d.ts

@@ -1,9 +0,0 @@
-export interface AutoCacheViewOnceOptions {
-	cacheDir?: string
-	logger?: any
-	onCached?: (info: { id: string; jid: string; filePath: string; type: string }) => void
-}
-
-export function getViewOnceContent(message: any): Record<string, any> | null
-
-export function autoCacheViewOnceMedia(sock: any, options?: AutoCacheViewOnceOptions): () => void

package/lib/Utils/view-once-cache.js

@@ -1,79 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.autoCacheViewOnceMedia = void 0
-const path = require('path')
-const fs = require('fs')
-const Messages_1 = require('./messages')
-const MessagesMedia_1 = require('./messages-media')
-
-const VIEW_ONCE_WRAPPER_KEYS = ['viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension']
-const VIEW_ONCE_INNER_KEYS = ['imageMessage', 'videoMessage', 'audioMessage']
-
-/**
- * Unwraps a message and returns the inner view-once media content if present, otherwise null.
- * Handles both the wrapper style (viewOnceMessage[V2/V2Extension] -> message -> ...)
- * and the inline style (imageMessage/videoMessage with viewOnce: true set directly).
- */
-const getViewOnceContent = message => {
-	if (!message) return null
-	const content = (0, Messages_1.extractMessageContent)(message)
-	if (!content) return null
-	for (const wrapperKey of VIEW_ONCE_WRAPPER_KEYS) {
-		const wrapper = content[wrapperKey]
-		if (wrapper?.message) {
-			const inner = (0, Messages_1.extractMessageContent)(wrapper.message)
-			if (inner) return inner
-		}
-	}
-	for (const key of VIEW_ONCE_INNER_KEYS) {
-		if (content[key]?.viewOnce) {
-			return { [key]: content[key] }
-		}
-	}
-	return null
-}
-
-/**
- * Registers a `messages.upsert` listener on the given socket that automatically
- * downloads and saves view-once media (image/video/audio) to `cacheDir` as soon
- * as it arrives, before the sender's app can mark it as opened/consumed.
- *
- * @param {ReturnType<typeof import('../Socket').default>} sock - an active Baileys socket
- * @param {{ cacheDir?: string, logger?: any, onCached?: (info: { id: string, jid: string, filePath: string, type: string }) => void }} [options]
- * @returns {() => void} a function that removes the listener
- */
-const autoCacheViewOnceMedia = (sock, options = {}) => {
-	const cacheDir = options.cacheDir || './viewonce-cache'
-	const logger = options.logger || sock.logger
-	if (!fs.existsSync(cacheDir)) {
-		fs.mkdirSync(cacheDir, { recursive: true })
-	}
-	const handler = async ({ messages, type }) => {
-		if (type !== 'notify' && type !== 'append') return
-		for (const msg of messages) {
-			try {
-				const viewOnceContent = getViewOnceContent(msg.message)
-				if (!viewOnceContent) continue
-				const mediaType = Object.keys(viewOnceContent)[0]
-				const buffer = await (0, Messages_1.downloadMediaMessage)(
-					msg,
-					'buffer',
-					{},
-					{ logger, reuploadRequest: sock.updateMediaMessage }
-				)
-				const extension = (0, MessagesMedia_1.extensionForMediaMessage)(viewOnceContent) || 'bin'
-				const fileName = `${msg.key.id}.${extension}`
-				const filePath = path.join(cacheDir, fileName)
-				fs.writeFileSync(filePath, buffer)
-				logger?.debug?.({ id: msg.key.id, filePath, mediaType }, 'cached view-once media')
-				options.onCached?.({ id: msg.key.id, jid: msg.key.remoteJid, filePath, type: mediaType })
-			} catch (error) {
-				logger?.warn?.({ error, id: msg.key?.id }, 'failed to cache view-once media')
-			}
-		}
-	}
-	sock.ev.on('messages.upsert', handler)
-	return () => sock.ev.off('messages.upsert', handler)
-}
-exports.autoCacheViewOnceMedia = autoCacheViewOnceMedia
-exports.getViewOnceContent = getViewOnceContent