@badzz88/baileys 8.5.7 → 8.5.8

package/lib/Utils/sticker.js

@@ -1,145 +1,110 @@
-'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')
+import { Boom } from '@hapi/boom';
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
 
-/**
- * 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
+const runFfmpeg = (input, args) => new Promise((resolve, reject) => {
+    const proc = spawn('ffmpeg', ['-hide_banner', '-loglevel', 'error', '-i', 'pipe:0', ...args, 'pipe:1'], { stdio: ['pipe', 'pipe', 'pipe'] });
+    const outChunks = [];
+    const errChunks = [];
+    proc.stdout.on('data', chunk => outChunks.push(chunk));
+    proc.stderr.on('data', chunk => errChunks.push(chunk));
+    proc.on('error', err => reject(new Boom(`ffmpeg failed to start: ${err.message}`, { statusCode: 500 })));
+    proc.on('close', code => {
+        if (code !== 0) {
+            reject(new Boom(`ffmpeg exited with code ${code}: ${Buffer.concat(errChunks).toString('utf8').slice(0, 500)}`, { statusCode: 500 }));
+            return;
+        }
+        resolve(Buffer.concat(outChunks));
+    });
+    proc.stdin.on('error', () => { });
+    proc.stdin.end(input);
+});
+export const convertToWebp = async (buffer, { animated = false, quality = 60 } = {}) => {
+    const scalePad = "scale='min(512,iw)':'min(512,ih)':force_original_aspect_ratio=decrease,format=rgba,pad=512:512:-1:-1:color=#00000000";
+    const args = animated
+        ? ['-vf', `${scalePad},fps=15`, '-loop', '0', '-preset', 'default', '-an', '-vsync', '0', '-vcodec', 'libwebp', '-q:v', String(quality), '-f', 'webp']
+        : ['-vf', `${scalePad}`, '-vframes', '1', '-vcodec', 'libwebp', '-q:v', String(quality), '-f', 'webp'];
+    return runFfmpeg(buffer, args);
+};
+const readChunks = (buf) => {
+    const chunks = [];
+    let offset = 12;
+    while (offset + 8 <= buf.length) {
+        const fourCC = buf.toString('ascii', offset, offset + 4);
+        const size = buf.readUInt32LE(offset + 4);
+        const dataStart = offset + 8;
+        const data = buf.subarray(dataStart, dataStart + size);
+        chunks.push({ fourCC, data });
+        offset = dataStart + size + (size % 2);
+    }
+    return chunks;
+};
+const buildChunk = (fourCC, data) => {
+    const header = Buffer.alloc(8);
+    header.write(fourCC, 0, 4, 'ascii');
+    header.writeUInt32LE(data.length, 4);
+    const pad = data.length % 2 === 1 ? Buffer.from([0]) : Buffer.alloc(0);
+    return Buffer.concat([header, data, pad]);
+};
+const buildExifChunkData = (json) => {
+    const header = Buffer.from([0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
+    const payload = Buffer.from(JSON.stringify(json), 'utf8');
+    header.writeUInt32LE(payload.length, 14);
+    return Buffer.concat([header, payload]);
+};
+export const writeExifToWebp = (webpBuffer, { packId, packName = '', publisher = '', emojis = [], isAvatar = false } = {}) => {
+    if (webpBuffer.toString('ascii', 0, 4) !== 'RIFF' || webpBuffer.toString('ascii', 8, 12) !== 'WEBP') {
+        throw new Boom('writeExifToWebp: not a valid webp buffer', { statusCode: 400 });
+    }
+    const chunks = readChunks(webpBuffer);
+    const exifData = buildExifChunkData({
+        'sticker-pack-id': packId || randomUUID(),
+        'sticker-pack-name': packName,
+        'sticker-pack-publisher': publisher,
+        emojis: emojis.length ? emojis : ['🤖'],
+        'is-avatar-sticker': isAvatar ? 1 : 0
+    });
+    let vp8x = chunks.find(c => c.fourCC === 'VP8X');
+    const otherChunks = chunks.filter(c => c.fourCC !== 'VP8X' && c.fourCC !== 'EXIF');
+    if (!vp8x) {
+        const img = otherChunks.find(c => c.fourCC === 'VP8 ' || c.fourCC === 'VP8L');
+        if (!img) {
+            throw new Boom('writeExifToWebp: no VP8/VP8L image data found', { statusCode: 400 });
+        }
+        let width;
+        let height;
+        if (img.fourCC === 'VP8 ') {
+            width = (img.data.readUInt16LE(6) & 0x3fff);
+            height = (img.data.readUInt16LE(8) & 0x3fff);
+        }
+        else {
+            const b = img.data;
+            width = 1 + (((b[2] & 0x3f) << 8) | b[1]);
+            height = 1 + (((b[4] & 0xf) << 10) | (b[3] << 2) | ((b[2] & 0xc0) >> 6));
+        }
+        const flags = Buffer.alloc(4);
+        flags[0] = 0x08;
+        const dims = Buffer.alloc(6);
+        dims.writeUIntLE(width - 1, 0, 3);
+        dims.writeUIntLE(height - 1, 3, 3);
+        vp8x = { fourCC: 'VP8X', data: Buffer.concat([flags, dims]) };
+    }
+    else {
+        const flagsByte = vp8x.data[0] | 0x08;
+        vp8x = { fourCC: 'VP8X', data: Buffer.concat([Buffer.from([flagsByte]), vp8x.data.subarray(1)]) };
+    }
+    const rebuilt = [vp8x, ...otherChunks, { fourCC: 'EXIF', data: exifData }];
+    const chunkBuffers = rebuilt.map(c => buildChunk(c.fourCC, c.data));
+    const payload = Buffer.concat(chunkBuffers);
+    const riffSize = 4 + payload.length;
+    const out = Buffer.alloc(8 + 4 + payload.length);
+    out.write('RIFF', 0, 4, 'ascii');
+    out.writeUInt32LE(riffSize, 4);
+    out.write('WEBP', 8, 4, 'ascii');
+    payload.copy(out, 12);
+    return out;
+};
+export const makeSticker = async (buffer, { pack = '', author = '', emojis = [], isPrivate = false, animated = false, quality = 60 } = {}) => {
+    const webp = await convertToWebp(buffer, { animated, quality });
+    return writeExifToWebp(webp, { packName: pack, publisher: author, emojis, isAvatar: isPrivate });
+};

package/lib/Utils/sync-action-utils.js

@@ -1,54 +1,49 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.emitSyncActionResults = exports.processContactAction = void 0
-const WABinary_1 = require('../WABinary')
+import { proto } from '../../WAProto/index.js';
+import { isLidUser, isPnUser } from '../WABinary/index.js';
 /**
  * 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
+export 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 = 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 && isLidUser(lidJid) && idIsPn) {
+        results.push({
+            event: 'lid-mapping.update',
+            data: { lid: lidJid, pn: id }
+        });
+    }
+    return results;
+};
+export 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);
+        }
+    }
+};
+//# sourceMappingURL=sync-action-utils.js.map