@leonoremods/baileys 0.0.0-stage → 1.2.9

package/src/Utils/socket-tools.js

@@ -0,0 +1,252 @@
+'use strict';
+
+/**
+ * Creates an opt-in outbound message queue around an existing Baileys socket.
+ * It does not retry failed sends automatically because a timeout can happen
+ * after WhatsApp has already accepted a message, and retrying could duplicate it.
+ */
+const createSendQueue = (sock, options = {}) => {
+    if (!sock || typeof sock.sendMessage !== 'function') {
+        throw new TypeError('createSendQueue requires a socket with sendMessage()');
+    }
+
+    const concurrency = Math.max(1, Math.floor(Number(options.concurrency) || 1));
+    const intervalMs = Math.max(0, Math.floor(Number(options.intervalMs) || 0));
+    const maxPending = Math.max(1, Math.floor(Number(options.maxPending) || 100));
+    const queue = [];
+    const idleWaiters = [];
+    let active = 0;
+    let closed = false;
+    let lastStartedAt = 0;
+    let timer = null;
+
+    const settleIdle = () => {
+        if (active === 0 && queue.length === 0) {
+            while (idleWaiters.length) idleWaiters.shift()();
+        }
+    };
+
+    const drain = () => {
+        if (closed || timer) return;
+
+        while (active < concurrency && queue.length > 0) {
+            const waitMs = Math.max(0, intervalMs - (Date.now() - lastStartedAt));
+            if (waitMs > 0) {
+                timer = setTimeout(() => {
+                    timer = null;
+                    drain();
+                }, waitMs);
+                timer.unref?.();
+                return;
+            }
+
+            const task = queue.shift();
+            active += 1;
+            lastStartedAt = Date.now();
+
+            Promise.resolve()
+                .then(() => sock.sendMessage(task.jid, task.content, task.sendOptions))
+                .then(task.resolve, task.reject)
+                .finally(() => {
+                    active -= 1;
+                    drain();
+                    settleIdle();
+                });
+        }
+
+        settleIdle();
+    };
+
+    return {
+        sendMessage(jid, content, sendOptions) {
+            if (closed) {
+                return Promise.reject(new Error('Send queue is closed'));
+            }
+            if (active + queue.length >= maxPending) {
+                return Promise.reject(new Error(`Send queue limit reached (${maxPending})`));
+            }
+
+            return new Promise((resolve, reject) => {
+                queue.push({ jid, content, sendOptions, resolve, reject });
+                drain();
+            });
+        },
+
+        onIdle() {
+            if (active === 0 && queue.length === 0) return Promise.resolve();
+            return new Promise(resolve => idleWaiters.push(resolve));
+        },
+
+        close(reason = new Error('Send queue closed')) {
+            if (closed) return 0;
+            closed = true;
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            const cancelled = queue.length;
+            while (queue.length) {
+                queue.shift().reject(reason);
+            }
+            settleIdle();
+            return cancelled;
+        },
+
+        get pending() {
+            return active + queue.length;
+        },
+
+        get size() {
+            return queue.length;
+        },
+
+        get isClosed() {
+            return closed;
+        }
+    };
+};
+
+/**
+ * Opt-in reconnect supervisor. Pass a callback that creates a fresh socket
+ * using the same persisted auth state. Logged-out sessions are not retried by
+ * default. stop() cancels future reconnect attempts but does not close the
+ * currently active socket.
+ */
+const createReconnectManager = (connect, options = {}) => {
+    if (typeof connect !== 'function') {
+        throw new TypeError('createReconnectManager requires a connect() function');
+    }
+
+    const minDelayMs = Math.max(100, Number(options.minDelayMs) || 1000);
+    const maxDelayMs = Math.max(minDelayMs, Number(options.maxDelayMs) || 30000);
+    const factor = Math.max(1, Number(options.factor) || 2);
+    const jitter = Math.min(1, Math.max(0, Number(options.jitter) || 0.2));
+    const loggedOutStatusCode = options.loggedOutStatusCode ?? 401;
+    const shouldReconnect = typeof options.shouldReconnect === 'function'
+        ? options.shouldReconnect
+        : ({ statusCode }) => statusCode !== loggedOutStatusCode;
+
+    let socket = null;
+    let attempts = 0;
+    let stopped = false;
+    let retryTimer = null;
+    let connectingPromise = null;
+    let updateListener = null;
+
+    const reportError = error => {
+        try {
+            options.onError?.(error);
+        } catch {
+            // User-provided error callbacks must not break reconnect management.
+        }
+    };
+
+    const detach = () => {
+        if (socket?.ev?.off && updateListener) {
+            socket.ev.off('connection.update', updateListener);
+        }
+        updateListener = null;
+    };
+
+    const scheduleReconnect = update => {
+        if (stopped || retryTimer) return;
+
+        const statusCode =
+            update?.lastDisconnect?.error?.output?.statusCode ??
+            update?.error?.output?.statusCode ??
+            update?.statusCode;
+
+        const details = { ...update, statusCode, attempt: attempts + 1 };
+        let allowed = false;
+        try {
+            allowed = Boolean(shouldReconnect(details));
+        } catch (error) {
+            reportError(error);
+            return;
+        }
+        if (!allowed) {
+            options.onGiveUp?.(details);
+            return;
+        }
+
+        const baseDelay = Math.min(maxDelayMs, minDelayMs * Math.pow(factor, attempts));
+        const delayMs = Math.min(
+            maxDelayMs,
+            Math.round(baseDelay + (Math.random() * baseDelay * jitter))
+        );
+        attempts += 1;
+        options.onRetry?.({ ...details, delayMs });
+
+        retryTimer = setTimeout(() => {
+            retryTimer = null;
+            start().catch(reportError);
+        }, delayMs);
+        retryTimer.unref?.();
+    };
+
+    const start = () => {
+        if (stopped) return Promise.reject(new Error('Reconnect manager is stopped'));
+        if (connectingPromise) return connectingPromise;
+        if (retryTimer) {
+            clearTimeout(retryTimer);
+            retryTimer = null;
+        }
+
+        connectingPromise = Promise.resolve()
+            .then(() => connect())
+            .then(nextSocket => {
+                if (!nextSocket?.ev?.on) {
+                    throw new TypeError('connect() must return a Baileys socket with ev.on()');
+                }
+                detach();
+                socket = nextSocket;
+                updateListener = update => {
+                    if (update?.connection === 'open') {
+                        attempts = 0;
+                    } else if (update?.connection === 'close') {
+                        scheduleReconnect(update);
+                    }
+                };
+                socket.ev.on('connection.update', updateListener);
+                return socket;
+            })
+            .catch(error => {
+                reportError(error);
+                scheduleReconnect({ error });
+                throw error;
+            })
+            .finally(() => {
+                connectingPromise = null;
+            });
+
+        return connectingPromise;
+    };
+
+    const stop = () => {
+        stopped = true;
+        if (retryTimer) {
+            clearTimeout(retryTimer);
+            retryTimer = null;
+        }
+        detach();
+    };
+
+    return {
+        start,
+        stop,
+        get socket() {
+            return socket;
+        },
+        get attempts() {
+            return attempts;
+        },
+        get stopped() {
+            return stopped;
+        }
+    };
+};
+
+module.exports = {
+    createSendQueue,
+    createReconnectManager
+};

package/src/Utils/stanza-ack.js

@@ -0,0 +1,30 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.buildAckStanza = buildAckStanza;
+function buildAckStanza(node, errorCode, meId) {
+    const { tag, attrs } = node;
+    const stanza = {
+        tag: 'ack',
+        attrs: {
+            id: attrs.id,
+            to: attrs.from,
+            class: tag
+        }
+    };
+    if (errorCode) {
+        stanza.attrs.error = errorCode.toString();
+    }
+    if (attrs.participant) {
+        stanza.attrs.participant = attrs.participant;
+    }
+    if (attrs.recipient) {
+        stanza.attrs.recipient = attrs.recipient;
+    }
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type;
+    }
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId;
+    }
+    return stanza;
+}

package/src/Utils/sticker.d.ts

@@ -0,0 +1,13 @@
+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/src/Utils/sticker.js

@@ -0,0 +1,123 @@
+'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');
+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');
+    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') {
+            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;
+    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);
+    return Buffer.concat([Buffer.from('RIFF', 'ascii'), fileSize, Buffer.from('WEBP', 'ascii'), body]);
+};
+exports.addExifToWebp = addExifToWebp;
+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;
+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/src/Utils/sync-action-utils.js

@@ -0,0 +1,45 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.emitSyncActionResults = exports.processContactAction = void 0;
+const WABinary_1 = require('../WABinary');
+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);
+    const phoneNumber = idIsPn ? id : action.pnJid || undefined;
+    results.push({
+        event: 'contacts.upsert',
+        data: [
+            {
+                id,
+                name: action.fullName || action.firstName || action.username || undefined,
+                username: action.username || undefined,
+                lid: lidJid || undefined,
+                phoneNumber
+            }
+        ]
+    });
+    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/src/Utils/tc-token-utils.js

@@ -0,0 +1,158 @@
+'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');
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+function isRegularUser(jid) {
+    if (!jid)
+        return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0')
+        return false;
+    if (BOT_PHONE_REGEX.test(user))
+        return false;
+    if ((0, WABinary_1.isJidMetaAI)(jid))
+        return false;
+    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;
+const TC_TOKEN_NUM_BUCKETS = 4;
+exports.TC_TOKEN_INDEX_KEY = '__index';
+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 [];
+    }
+}
+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])) }
+    };
+}
+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;
+}
+async function resolveTcTokenJid(jid, getLIDForPN) {
+    if ((0, WABinary_1.isLidUser)(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+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) {
+                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;
+        }
+        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;
+        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);
+    }
+}