@systemzero/baileys 1.0.4 → 1.0.6

package/lib/Socket/messages-send.js

@@ -568,7 +568,7 @@ export const makeMessagesSocket = (config) => {
             if (isNewsletter) {
                 const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
                 const bytes = encodeNewsletterMessage(patched);
-                binaryNodeContent.push({ tag: 'plaintext', attrs: {}, content: bytes });
+                binaryNodeContent.push({ tag: 'plaintext', attrs: extraAttrs, content: bytes });
                 const stanza = {
                     tag: 'message',
                     attrs: { to: jid, id: msgId, type: getMessageType(message), ...(additionalAttributes || {}) },
@@ -782,6 +782,7 @@ export const makeMessagesSocket = (config) => {
         else if (message.contactsArrayMessage) return 'contact_array';
         else if (message.liveLocationMessage) return 'livelocation';
         else if (message.stickerMessage) return 'sticker';
+        else if (message.lottieStickerMessage) return 'sticker';
         else if (message.listMessage) return 'list';
         else if (message.listResponseMessage) return 'list_response';
         else if (message.buttonsResponseMessage) return 'buttons_response';

package/lib/Types/Message.js

@@ -1,4 +1,11 @@
 import { proto } from '../../WAProto/index.js';
+export const ButtonHeaderType = proto.Message.ButtonsMessage.HeaderType;
+export const ButtonType = proto.Message.ButtonsMessage.Button.Type;
+export const CarouselCardType = proto.Message.InteractiveMessage.CarouselMessage.CarouselCardType;
+export const ListType = proto.Message.ListMessage.ListType;
+export const ProtocolType = proto.Message.ProtocolMessage.Type;
+export const AssociationType = proto.MessageAssociation?.AssociationType;
+
 // export the WAMessage Prototypes
 export { proto as WAProto };
 export const WAMessageStubType = proto.WebMessageInfo.StubType;

package/lib/Utils/bad-mac-handler.js

@@ -0,0 +1,158 @@
+/**
+ * Utilitário para lidar com erros "Bad MAC", comuns em bots WhatsApp usando
+ * Baileys quando a sessão Signal de um par fica desincronizada (ex: o
+ * outro lado reinstalou o WhatsApp, trocou de aparelho, ou houve perda de
+ * mensagens na troca de chaves). Não é uma falha do bot — é esperado que
+ * aconteça ocasionalmente em qualquer cliente Signal Protocol.
+ *
+ * Este módulo fornece funções para detectar, contar e lidar graciosamente
+ * com esses erros, sem derrubar o processo do bot.
+ *
+ * @author Dev Gui (original), integrado na lib para System Zero. By Josué </>
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { errorLog, warningLog } from './logger.js';
+
+export class BadMacHandler {
+    constructor(options = {}) {
+        this.errorCount = 0;
+        this.maxRetries = options.maxRetries ?? 5;
+        this.resetInterval = options.resetInterval ?? 300000; // 5 min
+        this.lastReset = Date.now();
+        // pasta de auth configurável — por padrão segue o padrão Baileys comum
+        this.authFolder = options.authFolder ?? path.resolve(process.cwd(), 'assets', 'auth', 'baileys');
+    }
+
+    isBadMacError(error) {
+        const errorMessage = error?.message || error?.toString() || '';
+        return (
+            errorMessage.includes('Bad MAC') ||
+            errorMessage.includes('MAC verification failed') ||
+            errorMessage.includes('decryption failed')
+        );
+    }
+
+    isSessionError(error) {
+        const errorMessage = error?.message || error?.toString() || '';
+        return (
+            errorMessage.includes('Session') ||
+            errorMessage.includes('signal protocol') ||
+            errorMessage.includes('decrypt') ||
+            this.isBadMacError(error)
+        );
+    }
+
+    /**
+     * Remove arquivos de sessão Signal problemáticos, preservando SEMPRE as
+     * credenciais principais (creds.json, app-state-sync-key/version) — só
+     * descarta arquivos de sessão por par (que serão renegociados
+     * automaticamente na próxima troca de chaves).
+     */
+    clearProblematicSessionFiles() {
+        try {
+            if (!fs.existsSync(this.authFolder)) {
+                return false;
+            }
+
+            const PRESERVE_PATTERNS = ['app-state-sync-key', 'creds.json', 'app-state-sync-version'];
+            const files = fs.readdirSync(this.authFolder);
+            let removedCount = 0;
+
+            for (const file of files) {
+                const filePath = path.join(this.authFolder, file);
+                if (!fs.statSync(filePath).isFile()) continue;
+
+                const mustPreserve = PRESERVE_PATTERNS.some((pattern) => file.includes(pattern));
+                if (mustPreserve) continue;
+
+                // só remove arquivos de sessão por par (ex: session-*.json)
+                if (file.startsWith('session-') || file.includes('sender-key')) {
+                    fs.unlinkSync(filePath);
+                    removedCount++;
+                }
+            }
+
+            if (removedCount > 0) {
+                warningLog(`${removedCount} arquivo(s) de sessão problemáticos removidos. Credenciais principais preservadas.`);
+                return true;
+            }
+
+            return false;
+        } catch (error) {
+            errorLog(`Erro ao limpar arquivos de sessão: ${error.message}`);
+            return false;
+        }
+    }
+
+    incrementErrorCount() {
+        this.errorCount++;
+        errorLog(`Bad MAC error count: ${this.errorCount}/${this.maxRetries}`);
+
+        const now = Date.now();
+        if (now - this.lastReset > this.resetInterval) {
+            this.resetErrorCount();
+        }
+    }
+
+    resetErrorCount() {
+        const previousCount = this.errorCount;
+        this.errorCount = 0;
+        this.lastReset = Date.now();
+
+        if (previousCount > 0) {
+            warningLog(`Reset do contador de Bad MAC errors. Contador anterior: ${previousCount}`);
+        }
+    }
+
+    hasReachedLimit() {
+        return this.errorCount >= this.maxRetries;
+    }
+
+    /**
+     * @returns {boolean} true se o erro foi tratado (Bad MAC engolido),
+     *                     false se NÃO era Bad MAC (deve ser relançado pelo caller)
+     */
+    handleError(error, context = 'unknown') {
+        if (!this.isBadMacError(error)) {
+            return false;
+        }
+
+        errorLog(`Bad MAC error detectado em ${context}: ${error.message}`);
+        this.incrementErrorCount();
+
+        if (this.hasReachedLimit()) {
+            warningLog(`Limite de Bad MAC errors atingido (${this.maxRetries}). Considere reiniciar o bot ou limpar sessões com clearProblematicSessionFiles().`);
+            return true;
+        }
+
+        warningLog(`Ignorando Bad MAC error e continuando operação... (${this.errorCount}/${this.maxRetries})`);
+        return true;
+    }
+
+    /** Envolve uma função async — engole Bad MAC, relança qualquer outro erro. */
+    createSafeWrapper(fn, context) {
+        return async (...args) => {
+            try {
+                return await fn(...args);
+            } catch (error) {
+                if (this.handleError(error, context)) {
+                    return null;
+                }
+                throw error;
+            }
+        };
+    }
+
+    getStats() {
+        return {
+            errorCount: this.errorCount,
+            maxRetries: this.maxRetries,
+            lastReset: new Date(this.lastReset).toISOString(),
+            timeUntilReset: Math.max(0, this.resetInterval - (Date.now() - this.lastReset)),
+        };
+    }
+}
+
+export const badMacHandler = new BadMacHandler();

package/lib/Utils/get-best-version.js

@@ -0,0 +1,41 @@
+// lib/Utils/get-best-version.js
+//
+// fetchLatestWaWebVersion() e fetchLatestBaileysVersion() SEMPRE retornam um
+// objeto com `version` preenchido, mesmo quando a busca falha — nesse caso
+// devolvem isLatest:false e um valor antigo fixo embutido na lib. Checar só
+// `if (result.version)` nunca detecta a falha, porque version sempre existe.
+//
+// Este helper tenta as duas fontes, na ordem, e só aceita um resultado se
+// `isLatest === true` (ou seja, se realmente buscou fresco da rede). Só cai
+// no valor fixo antigo se AMBAS as fontes falharem de verdade.
+
+import { fetchLatestWaWebVersion } from './generics.js';
+import { fetchLatestBaileysVersion } from './generics.js';
+
+/**
+ * @param {object} [options] - passado direto pras duas funções de fetch
+ * @returns {Promise<{ version: number[], isLatest: boolean, source: string }>}
+ */
+export const getBestWaVersion = async (options = {}) => {
+    try {
+        const web = await fetchLatestWaWebVersion(options);
+        if (web?.isLatest && web?.version) {
+            return { version: web.version, isLatest: true, source: 'web.whatsapp.com' };
+        }
+    } catch {
+        // segue pra próxima fonte
+    }
+
+    try {
+        const github = await fetchLatestBaileysVersion(options);
+        if (github?.isLatest && github?.version) {
+            return { version: github.version, isLatest: true, source: 'github' };
+        }
+    } catch {
+        // segue pro fallback fixo
+    }
+
+    // as duas fontes falharam de verdade — usa o valor fixo embutido,
+    // mas avisa explicitamente que NÃO é a versão mais atual
+    return { version: [2, 3000, 1027934701], isLatest: false, source: 'fallback-fixo' };
+};

package/lib/Utils/get-name.d.ts

@@ -0,0 +1 @@
+export declare const getName: (msg: any, contactStore?: Record<string, { name?: string; notify?: string; verifiedName?: string }>) => string;

package/lib/Utils/get-name.js

@@ -0,0 +1,54 @@
+// lib/Utils/get-name.js
+// Resolve o nome do remetente com cobertura total (nunca retorna vazio).
+// Ordem de prioridade:
+//   1) Nome salvo localmente (store/contatos) — mais confiável
+//   2) verifiedName (conta business confirmada pela Meta)
+//   3) notify / pushName da própria mensagem
+//   4) Nome resolvido via cache LID -> JID (se sender for @lid)
+//   5) Número de telefone formatado (fallback final, nunca undefined)
+
+import { jidDecode, isLidUser, sharedLidPhoneCache, lidToJid } from '../WABinary/jid-utils.js';
+
+/**
+ * @param {object} msg - mensagem completa do Baileys (proto.IWebMessageInfo)
+ * @param {object} [contactStore] - opcional: { [jid]: { name, notify, verifiedName } }
+ * @returns {string} nome final, garantido não-vazio
+ */
+export const getName = (msg, contactStore) => {
+    try {
+        const key = msg?.key || {};
+        let sender = key.participant || key.remoteJid || '';
+
+        // se vier @lid, tenta resolver pro JID real (telefone) primeiro,
+        // pois o contactStore normalmente é indexado por @s.whatsapp.net
+        let resolvedSender = sender;
+        if (isLidUser(sender)) {
+            const phone = sharedLidPhoneCache.getPhoneForLid(sender) || lidToJid(sender);
+            if (phone && phone !== sender) resolvedSender = phone;
+        }
+
+        // 1) contato salvo localmente
+        const contact = contactStore?.[resolvedSender] || contactStore?.[sender];
+        if (contact?.name && contact.name.trim()) return contact.name.trim();
+
+        // 2) verifiedName (conta business)
+        if (contact?.verifiedName && contact.verifiedName.trim()) return contact.verifiedName.trim();
+
+        // 3) pushName / notify da mensagem em si
+        const pushName = msg?.pushName || contact?.notify;
+        if (pushName && pushName.trim() && pushName.trim() !== 'WhatsApp User') {
+            return pushName.trim();
+        }
+
+        // 4) fallback: número de telefone formatado a partir do JID resolvido
+        const decoded = jidDecode(resolvedSender);
+        if (decoded?.user) {
+            return `+${decoded.user}`;
+        }
+
+        // 5) último recurso absoluto — nunca undefined/empty
+        return 'Usuário desconhecido';
+    } catch {
+        return 'Usuário desconhecido';
+    }
+};

package/lib/Utils/group-status-detection.js

@@ -0,0 +1,113 @@
+/**
+ * Detecção robusta de mensagens de status-em-grupo (marcação de status no grupo).
+ *
+ * Cobre:
+ *  - groupStatusMentionMessage / groupStatusMessage / groupStatusMessageV2
+ *  - isGroupStatus: true | 1 em qualquer nível
+ *  - statusAttributions com type GROUP_STATUS / type 5 / groupStatus: true
+ *  - mensagens aninhadas em wrappers (ephemeral, viewOnce, etc)
+ *
+ * @author Dev Gui (original), integrado na lib para System Zero. By Josué </>
+ */
+
+const MAX_MESSAGE_UNWRAP_DEPTH = 5;
+const MAX_FLAG_SCAN_DEPTH = 8;
+
+const STRONG_GROUP_STATUS_MESSAGE_KEYS = new Set([
+    'groupStatusMentionMessage',
+    'groupStatusMessage',
+    'groupStatusMessageV2',
+]);
+
+const WRAPPED_MESSAGE_KEYS = [
+    'ephemeralMessage',
+    'viewOnceMessage',
+    'viewOnceMessageV2',
+    'viewOnceMessageV2Extension',
+    'documentWithCaptionMessage',
+    'statusMentionMessage',
+    'groupStatusMentionMessage',
+    'groupStatusMessage',
+    'groupStatusMessageV2',
+];
+
+export function isGroupStatusValue(value) {
+    return value === true || value === 1;
+}
+
+function canScanObject(value) {
+    return value && typeof value === 'object' && !(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value);
+}
+
+function hasGroupStatusAttribution(statusAttributions) {
+    if (!Array.isArray(statusAttributions)) return false;
+
+    return statusAttributions.some(
+        (sa) =>
+            canScanObject(sa) &&
+            (Boolean(sa.groupStatus) || sa.attributionData === 'groupStatus' || sa.type === 'GROUP_STATUS' || sa.type === 5)
+    );
+}
+
+function hasGroupStatusContextInfo(contextInfo) {
+    return (
+        canScanObject(contextInfo) &&
+        (isGroupStatusValue(contextInfo.isGroupStatus) || hasGroupStatusAttribution(contextInfo.statusAttributions))
+    );
+}
+
+export function hasGroupStatusFlag(value, depth = 0, seenObjects = new WeakSet()) {
+    if (!canScanObject(value) || depth > MAX_FLAG_SCAN_DEPTH || seenObjects.has(value)) {
+        return false;
+    }
+
+    seenObjects.add(value);
+
+    for (const [key, childValue] of Object.entries(value)) {
+        if (key === 'quotedMessage') continue;
+
+        if (STRONG_GROUP_STATUS_MESSAGE_KEYS.has(key) && canScanObject(childValue)) {
+            return true;
+        }
+
+        if (key === 'isGroupStatus' && isGroupStatusValue(childValue)) {
+            return true;
+        }
+
+        if (key === 'statusAttributions' && hasGroupStatusAttribution(childValue)) {
+            return true;
+        }
+
+        if (key === 'contextInfo' && hasGroupStatusContextInfo(childValue)) {
+            return true;
+        }
+
+        if (hasGroupStatusFlag(childValue, depth + 1, seenObjects)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+export function getCurrentMessageContentVariants(message, depth = 0, seenObjects = new WeakSet()) {
+    if (!canScanObject(message) || depth > MAX_MESSAGE_UNWRAP_DEPTH || seenObjects.has(message)) {
+        return [];
+    }
+
+    seenObjects.add(message);
+
+    const variants = [message];
+
+    for (const key of WRAPPED_MESSAGE_KEYS) {
+        const wrappedMessage = message[key]?.message;
+        variants.push(...getCurrentMessageContentVariants(wrappedMessage, depth + 1, seenObjects));
+    }
+
+    return variants;
+}
+
+/** Verifica se a webMessage é uma marcação de status em grupo, inclusive em wrappers ou níveis profundos. */
+export function hasGroupStatusMessage(webMessage) {
+    return getCurrentMessageContentVariants(webMessage?.message).some((message) => hasGroupStatusFlag(message));
+}

package/lib/Utils/index.js

@@ -16,4 +16,11 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './message-retry-manager.js';
 export * from './browser-utils.js';
+export * from './get-name.js';
+export * from './payment-guard.js';
+export * from './payment-detection.js';
+export * from './group-status-detection.js';
+export * from './bad-mac-handler.js';
+export * from './resolve-lid-phone.js';
+export * from './get-best-version.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/logger.js

@@ -1,3 +1,6 @@
 import P from 'pino';
-export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+const logger = P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+export const errorLog = (msg) => logger.error(msg);
+export const warningLog = (msg) => logger.warn(msg);
+export default logger;
 //# sourceMappingURL=logger.js.map

package/lib/Utils/messages-media.js

@@ -7,13 +7,51 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { Readable, Transform } from 'stream';
 import { URL } from 'url';
+import { promisify } from 'util';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_ORIGIN, MEDIA_HKDF_KEY_MAPPING, MEDIA_PATH_MAP } from '../Defaults/index.js';
 import { getBinaryNodeChild, getBinaryNodeChildBuffer, jidNormalizedUser } from '../WABinary/index.js';
 import { aesDecryptGCM, aesEncryptGCM, hkdf } from './crypto.js';
 import { generateMessageIDV2 } from './generics.js';
 const getTmpFilesDirectory = () => tmpdir();
-const getImageProcessingLibrary = async () => {
+const execAsync = promisify(exec);
+
+/**
+ * Converte QUALQUER áudio de entrada pra opus/ogg mono 16kHz — o formato
+ * exato que o player de PTT do WhatsApp espera. Sem isso, marcar `ptt: true`
+ * num mp3/m4a só troca o RÓTULO do mimetype sem mudar os bytes reais, e o
+ * WhatsApp mostra "algo errado com o arquivo de áudio" ao tentar decodificar.
+ *
+ * @param {string | Buffer} input - caminho de arquivo local, URL http(s), ou Buffer já em memória
+ * @returns {Promise<string>} caminho do arquivo .ogg convertido (temporário — chame fs.unlink depois de usar)
+ */
+export async function transcodeAudioToOpus(input) {
+    const outputPath = join(getTmpFilesDirectory(), 'ptt-' + generateMessageIDV2() + '.ogg');
+    let inputPath = input;
+    let tempInputPath;
+
+    try {
+        if (Buffer.isBuffer(input)) {
+            tempInputPath = join(getTmpFilesDirectory(), 'ptt-src-' + generateMessageIDV2());
+            await fs.writeFile(tempInputPath, input);
+            inputPath = tempInputPath;
+        }
+
+        // -vn: ignora qualquer vídeo/capa embutida (mp3 com artwork, por exemplo)
+        // -ac 1 -ar 16000: mono 16kHz — espec exata do PTT nativo do WhatsApp
+        // -c:a libopus -b:a 32k: codec real opus, não só o rótulo
+        const cmd = `ffmpeg -i "${inputPath}" -y -vn -ac 1 -ar 16000 -c:a libopus -b:a 32k -f ogg "${outputPath}"`;
+        await execAsync(cmd);
+
+        return outputPath;
+    } finally {
+        if (tempInputPath) {
+            await fs.unlink(tempInputPath).catch(() => {});
+        }
+    }
+}
+
+export const getImageProcessingLibrary = async () => {
     //@ts-ignore
     const [jimp, sharp] = await Promise.all([import('jimp').catch(() => { }), import('sharp').catch(() => { })]);
     if (sharp) {
@@ -210,7 +248,8 @@ export async function getAudioWaveform(buffer, logger) {
         }
         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 samples = 64;
+        const minHeight = 0.05;
         const blockSize = Math.floor(rawData.length / samples); // the number of samples in each subdivision
         const filteredData = [];
         for (let i = 0; i < samples; i++) {
@@ -225,7 +264,7 @@ export async function getAudioWaveform(buffer, logger) {
         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)));
+        const waveform = new Uint8Array(normalizedData.map(n => Math.max(minHeight, n)).map(n => Math.floor(100 * n)));
         return waveform;
     }
     catch (e) {