@bellaxchuu/flowred 0.8.6

package/lib/Utils/sticker.js

@@ -0,0 +1,145 @@
+'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/sync-action-utils.js

@@ -0,0 +1,54 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.emitSyncActionResults = exports.processContactAction = void 0
+const WABinary_1 = require('../WABinary')
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
+const processContactAction = (action, id, logger) => {
+	const results = []
+	if (!id) {
+		logger?.warn(
+			{ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid },
+			'contactAction sync: missing id in index'
+		)
+		return results
+	}
+	const lidJid = action.lidJid
+	const idIsPn = (0, WABinary_1.isPnUser)(id)
+	// PN is in index[1], not in contactAction.pnJid which is usually null
+	const phoneNumber = idIsPn ? id : action.pnJid || undefined
+	// Always emit contacts.upsert
+	results.push({
+		event: 'contacts.upsert',
+		data: [
+			{
+				id,
+				name: action.fullName || action.firstName || action.username || undefined,
+				username: action.username || undefined,
+				lid: lidJid || undefined,
+				phoneNumber
+			}
+		]
+	})
+	// Emit lid-mapping.update if we have valid LID-PN pair
+	if (lidJid && (0, WABinary_1.isLidUser)(lidJid) && idIsPn) {
+		results.push({
+			event: 'lid-mapping.update',
+			data: { lid: lidJid, pn: id }
+		})
+	}
+	return results
+}
+exports.processContactAction = processContactAction
+const emitSyncActionResults = (ev, results) => {
+	for (const result of results) {
+		if (result.event === 'contacts.upsert') {
+			ev.emit('contacts.upsert', result.data)
+		} else {
+			ev.emit('lid-mapping.update', result.data)
+		}
+	}
+}
+exports.emitSyncActionResults = emitSyncActionResults

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,161 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.TC_TOKEN_INDEX_KEY = void 0
+exports.readTcTokenIndex = readTcTokenIndex
+exports.buildMergedTcTokenIndexWrite = buildMergedTcTokenIndexWrite
+exports.isTcTokenExpired = isTcTokenExpired
+exports.shouldSendNewTcToken = shouldSendNewTcToken
+exports.resolveTcTokenJid = resolveTcTokenJid
+exports.resolveIssuanceJid = resolveIssuanceJid
+exports.buildTcTokenFromJid = buildTcTokenFromJid
+exports.storeTcTokensFromIqResult = storeTcTokensFromIqResult
+const WABinary_1 = require('../WABinary')
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+	if (!jid) return false
+	const user = jid.split('@')[0] ?? ''
+	if (user === '0') return false // PSA
+	if (BOT_PHONE_REGEX.test(user)) return false // Bot by phone pattern
+	if ((0, WABinary_1.isJidMetaAI)(jid)) return false // MetaAI (@bot server)
+	return !!(
+		(0, WABinary_1.isPnUser)(jid) ||
+		(0, WABinary_1.isLidUser)(jid) ||
+		(0, WABinary_1.isHostedPnUser)(jid) ||
+		(0, WABinary_1.isHostedLidUser)(jid) ||
+		jid.endsWith('@c.us')
+	)
+}
+const TC_TOKEN_BUCKET_DURATION = 604800 // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4 // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+exports.TC_TOKEN_INDEX_KEY = '__index'
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+async function readTcTokenIndex(keys) {
+	const data = await keys.get('tctoken', [exports.TC_TOKEN_INDEX_KEY])
+	const entry = data[exports.TC_TOKEN_INDEX_KEY]
+	if (!entry?.token?.length) return []
+	try {
+		const parsed = JSON.parse(Buffer.from(entry.token).toString())
+		if (!Array.isArray(parsed)) return []
+		return parsed.filter(j => typeof j === 'string' && j.length > 0 && j !== exports.TC_TOKEN_INDEX_KEY)
+	} catch {
+		return []
+	}
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+	const persisted = await readTcTokenIndex(keys)
+	const merged = new Set(persisted)
+	for (const jid of addedJids) {
+		if (jid && jid !== exports.TC_TOKEN_INDEX_KEY) merged.add(jid)
+	}
+	return {
+		[exports.TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+	}
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+function isTcTokenExpired(timestamp) {
+	if (timestamp === null || timestamp === undefined) return true
+	const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp
+	if (isNaN(ts)) return true
+	const now = Math.floor(Date.now() / 1000)
+	const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION)
+	const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1)
+	const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION
+	return ts < cutoffTimestamp
+}
+function shouldSendNewTcToken(senderTimestamp) {
+	if (senderTimestamp === undefined) return true
+	const now = Math.floor(Date.now() / 1000)
+	const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION)
+	const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION)
+	return currentBucket > senderBucket
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+async function resolveTcTokenJid(jid, getLIDForPN) {
+	if ((0, WABinary_1.isLidUser)(jid)) return jid
+	const lid = await getLIDForPN(jid)
+	return lid ?? jid
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+	if (issueToLid) {
+		if ((0, WABinary_1.isLidUser)(jid)) return jid
+		const lid = await getLIDForPN(jid)
+		return lid ?? jid
+	}
+	if (!(0, WABinary_1.isLidUser)(jid)) return jid
+	if (getPNForLID) {
+		const pn = await getPNForLID(jid)
+		return pn ?? jid
+	}
+	return jid
+}
+async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+	try {
+		const storageJid = await resolveTcTokenJid(jid, getLIDForPN)
+		const tcTokenData = await authState.keys.get('tctoken', [storageJid])
+		const entry = tcTokenData?.[storageJid]
+		const tcTokenBuffer = entry?.token
+		if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+			if (tcTokenBuffer) {
+				// Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+				// after we drop the unusable peer token. Only wipe the record entirely when
+				// there's nothing worth keeping.
+				const cleared =
+					entry?.senderTimestamp !== undefined
+						? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+						: null
+				await authState.keys.set({ tctoken: { [storageJid]: cleared } })
+			}
+			return baseContent.length > 0 ? baseContent : undefined
+		}
+		baseContent.push({
+			tag: 'tctoken',
+			attrs: {},
+			content: tcTokenBuffer
+		})
+		return baseContent
+	} catch (error) {
+		return baseContent.length > 0 ? baseContent : undefined
+	}
+}
+async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+	const tokensNode = (0, WABinary_1.getBinaryNodeChild)(result, 'tokens')
+	if (!tokensNode) return
+	const tokenNodes = (0, WABinary_1.getBinaryNodeChildren)(tokensNode, 'token')
+	for (const tokenNode of tokenNodes) {
+		if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+			continue
+		}
+		// In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+		const rawJid = (0, WABinary_1.jidNormalizedUser)(fallbackJid || tokenNode.attrs.jid)
+		if (!isRegularUser(rawJid)) continue
+		const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN)
+		const existingTcData = await keys.get('tctoken', [storageJid])
+		const existingEntry = existingTcData[storageJid]
+		const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0
+		const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0
+		// timestamp-less tokens would be immediately expired
+		if (!incomingTs) continue
+		if (existingTs > 0 && existingTs > incomingTs) continue
+		await keys.set({
+			tctoken: {
+				[storageJid]: {
+					...existingEntry,
+					token: Buffer.from(tokenNode.content),
+					timestamp: tokenNode.attrs.t
+				}
+			}
+		})
+		onNewJidStored?.(storageJid)
+	}
+}

package/lib/Utils/use-multi-file-auth-state.js

@@ -0,0 +1,121 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.useMultiFileAuthState = void 0
+const async_mutex_1 = require('async-mutex')
+const promises_1 = require('fs/promises')
+const path_1 = require('path')
+const index_js_1 = require('../../WAProto/index.js')
+const auth_utils_1 = require('./auth-utils')
+const generics_1 = require('./generics')
+// We need to lock files due to the fact that we are using async functions to read and write files
+// https://github.com/WhiskeySockets/Baileys/issues/794
+// https://github.com/nodejs/node/issues/26338
+// Use a Map to store mutexes for each file path
+const fileLocks = new Map()
+// Get or create a mutex for a specific file path
+const getFileLock = path => {
+	let mutex = fileLocks.get(path)
+	if (!mutex) {
+		mutex = new async_mutex_1.Mutex()
+		fileLocks.set(path, mutex)
+	}
+	return mutex
+}
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+const useMultiFileAuthState = async folder => {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const writeData = async (data, file) => {
+		const filePath = (0, path_1.join)(folder, fixFileName(file))
+		const mutex = getFileLock(filePath)
+		return mutex.acquire().then(async release => {
+			try {
+				await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer))
+			} finally {
+				release()
+			}
+		})
+	}
+	const readData = async file => {
+		try {
+			const filePath = (0, path_1.join)(folder, fixFileName(file))
+			const mutex = getFileLock(filePath)
+			return await mutex.acquire().then(async release => {
+				try {
+					const data = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' })
+					return JSON.parse(data, generics_1.BufferJSON.reviver)
+				} finally {
+					release()
+				}
+			})
+		} catch (error) {
+			return null
+		}
+	}
+	const removeData = async file => {
+		try {
+			const filePath = (0, path_1.join)(folder, fixFileName(file))
+			const mutex = getFileLock(filePath)
+			return mutex.acquire().then(async release => {
+				try {
+					await (0, promises_1.unlink)(filePath)
+				} catch {
+				} finally {
+					release()
+				}
+			})
+		} catch {}
+	}
+	const folderInfo = await (0, promises_1.stat)(folder).catch(() => {})
+	if (folderInfo) {
+		if (!folderInfo.isDirectory()) {
+			throw new Error(
+				`found something that is not a directory at ${folder}, either delete it or specify a different location`
+			)
+		}
+	} else {
+		await (0, promises_1.mkdir)(folder, { recursive: true })
+	}
+	const fixFileName = file => file?.replace(/\//g, '__')?.replace(/:/g, '-')
+	const creds = (await readData('creds.json')) || (0, auth_utils_1.initAuthCreds)()
+	return {
+		state: {
+			creds,
+			keys: {
+				get: async (type, ids) => {
+					const data = {}
+					await Promise.all(
+						ids.map(async id => {
+							let value = await readData(`${type}-${id}.json`)
+							if (type === 'app-state-sync-key' && value) {
+								value = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(value)
+							}
+							data[id] = value
+						})
+					)
+					return data
+				},
+				set: async data => {
+					const tasks = []
+					for (const category in data) {
+						for (const id in data[category]) {
+							const value = data[category][id]
+							const file = `${category}-${id}.json`
+							tasks.push(value ? writeData(value, file) : removeData(file))
+						}
+					}
+					await Promise.all(tasks)
+				}
+			}
+		},
+		saveCreds: async () => {
+			return writeData(creds, 'creds.json')
+		}
+	}
+}
+exports.useMultiFileAuthState = useMultiFileAuthState