@areumtecnologia/baileys 1.0.0 → 1.0.2

package/handlers/baileys.js

@@ -0,0 +1,27 @@
+const wb = require('@whiskeysockets/baileys');
+const {
+    Browsers,
+    makeWASocket,
+    decryptPollVote,
+    DisconnectReason,
+    jidNormalizedUser,
+    downloadContentFromMessage,
+    downloadMediaMessage,
+    getContentType,
+    useMultiFileAuthState,
+    fetchLatestBaileysVersion,
+} = require('@itsukichan/baileys');
+
+module.exports = {
+    whiskeysocketsMakeWASocket: wb.makeWASocket,
+    itsukichanMakeWASocket: makeWASocket,
+    Browsers,
+    decryptPollVote,
+    DisconnectReason,
+    jidNormalizedUser,
+    downloadContentFromMessage,
+    downloadMediaMessage,
+    getContentType,
+    useMultiFileAuthState,
+    fetchLatestBaileysVersion,
+};

package/handlers/calls.js

@@ -0,0 +1,58 @@
+
+/**
+ * @copyright Áreum Tecnologia
+ * @author Áreum Tecnologia
+ * @license Proprietary
+ * 
+ * Manipula o envio e recebimento de chamadas via WhatsApp utilizando Baileys.
+ * Fornece métodos para envio de texto, mídia, localização, contatos, enquetes, ações de mensagem e interatividade.
+ * 
+ * @class CallHandler
+ * @classdesc Classe central para manipulação de chamadas no WhatsApp.
+ * 
+ * @property {import('../client').default} client - Instância principal do cliente Baileys.
+ * 
+ * @example
+ * const CallHandler = require('./handlers/calls');
+ * const handler = new CallHandler(client);
+ * await handler.callReject('5511999999999@s.whatsapp.net');
+ */
+// const { sendButtons, sendInteractiveMessage } = require('baileys_helper');
+const { Utils, MessageNormalizer } = require('../utils');
+
+class CallHandler {
+    /**
+     * @param {import('../../../client').default} client - A instância principal do cliente.
+     */
+    constructor(client) {
+        this.client = client;
+    }
+
+    /** 
+     * Rejeita uma chamada.
+     * @param {string} jid - O JID do destinatário.
+     */
+    async reject(call) {
+        this.client._validateConnection();
+        return this.client.sock.rejectCall(call.id, call.from);
+
+    }
+
+    normalizeCall(call) {
+        return {
+            id: call.id,
+            from: call.from,
+            status: call.status,
+            isVideo: call.isVideo,
+            isGroup: call.isGroup,
+            groupJid: call.groupJid,
+            date: call.date,
+            offline: call.offline,
+            chatId: call.chatId,
+            reject: this.reject.bind(this, call)
+        };
+    }
+
+}
+
+module.exports = CallHandler;

package/handlers/messages.js

@@ -174,7 +174,6 @@ class MessageHandler {
      * @param {object} [options={}] - Opções adicionais.
      */
     async sendLink(jid, url, options = {}) {
-
         return this.sendMessage(jid, { text: url }, options);
     }
 
@@ -245,6 +244,7 @@ class MessageHandler {
         return this.client.sock.readMessages([messageKey]);
     }
 
+    /** Deprecated - Funcional apenas usando baileys e baileys_helper - Envia uma mensagem com botões interativos. */
     async sendInteractiveMessage(jid, interactiveMessage, more) {
         const verifiedJid = await this.client.users.isOnWhatsApp(jid);
         if (verifiedJid && verifiedJid.exists) {
@@ -255,7 +255,7 @@ class MessageHandler {
         }
     }
 
-    /** Envia uma mensagem com botões interativos. */
+    /** Deprecated - Funcional apenas usando baileys e baileys_helper - Envia uma mensagem com botões interativos. */
     async sendButtons(jid, messageButton) {
         const verifiedJid = await this.client.users.isOnWhatsApp(jid);
         if (verifiedJid && verifiedJid.exists) {
@@ -267,19 +267,98 @@ class MessageHandler {
     }
 
     /** Faz o download de mídia de uma mensagem. */
-    async download(message) {
+    async getAttachments(message) {
         this.client._validateConnection();
-        const type = Object.keys(message.message)[0];
+
+        const type = Object.keys(message.message)[0]; // ex: imageMessage
         const messageContent = message.message[type];
-        if (!messageContent.url) throw new Error('Mensagem não contém mídia para download.');
 
-        const stream = await this.client.downloadContentFromMessage(messageContent, type.replace('Message', ''));
+        if (!messageContent?.url) return null;
+
+        // baixa o stream
+        const stream = await this.client.downloadContentFromMessage(
+            messageContent,
+            type.replace('Message', '') // imageMessage → image
+        );
+
+        // monta o buffer
         let buffer = Buffer.from([]);
         for await (const chunk of stream) {
             buffer = Buffer.concat([buffer, chunk]);
         }
-        return buffer;
+
+        const mimetype = messageContent.mimetype;
+        const extension = mimetype.split('/')[1] || 'bin';
+
+        // conversões
+        const toBase64 = () => buffer.toString('base64');
+
+        const toDataUri = () =>
+            `data:${mimetype};base64,${buffer.toString('base64')}`;
+
+        const toArrayBuffer = () =>
+            buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+
+        const toBlob = () => {
+            const arrayBuffer = toArrayBuffer();
+            return new Blob([arrayBuffer], { type: mimetype });
+        };
+
+        const toImageUrl = () => {
+            const blob = toBlob();
+            return URL.createObjectURL(blob);
+        };
+
+        const toImageBitmap = async () => {
+            const blob = toBlob();
+            return await createImageBitmap(blob);
+        };
+
+        const toStream = () => {
+            const { Readable } = require('stream');
+            return Readable.from(buffer);
+        };
+
+        const toSharp = () => {
+            const sharp = require('sharp');
+            return sharp(buffer); // o usuário pode continuar com .resize().png()...
+        };
+
+        const detectType = async () => {
+            const { fileTypeFromBuffer } = await import('file-type');
+            return await fileTypeFromBuffer(buffer);
+        };
+
+        const save = async (path) => {
+            const filename = `${message.from}-${Date.now()}.${extension}`;
+            const filepath = path
+                ? path
+                : `${this.client.sessionPath}/media/${filename}`;
+
+            await fs.writeFile(filepath, buffer);
+
+            return { filename, filepath };
+        };
+
+        return {
+            type: mimetype,
+            extension,
+            buffer,
+
+            // 🔥 todas as funções utilitárias
+            toBase64,
+            toDataUri,
+            toArrayBuffer,
+            toBlob,
+            toImageUrl,
+            toImageBitmap,
+            toStream,
+            toSharp,
+            detectType,
+            save,
+        };
     }
+
 }
 
 module.exports = MessageHandler;

package/index.js

@@ -1,24 +1,30 @@
-// Biblioteca chamada synapse-b
-const wb = require('@whiskeysockets/baileys');
+// Biblioteca chamada @areumtecnologia/baileys
+
 const {
     Browsers,
-    makeWASocket,
+    itsukichanMakeWASocket,
+    whiskeysocketsMakeWASocket,
     decryptPollVote,
     DisconnectReason,
     jidNormalizedUser,
     downloadContentFromMessage,
+    downloadMediaMessage,
+    getContentType,
     useMultiFileAuthState,
     fetchLatestBaileysVersion,
-} = require('@itsukichan/baileys');
+} = require('./handlers/baileys');
 const { Boom } = require('@hapi/boom');
 const EventEmitter = require('events');
 const fs = require('fs/promises');
 const { constants } = require('fs');
 const path = require('path');
 const pino = require('pino');
+const QRCode = require('qrcode');
+const qrcodeTerminal = require('qrcode-terminal');
 // Importa os handlers de responsabilidades específicas
 const MessageHandler = require('./handlers/messages');
 const GroupHandler = require('./handlers/groups');
+const CallHandler = require('./handlers/calls');
 const { UserHandler, PresenceStatus } = require('./handlers/users');
 const { MessageNormalizer, MessageStore } = require('./utils');
 const { InteractiveMessage, CallButton, CopyCodeButton, ListButton, ListRow, ListSection, QuickReplyButton, UrlButton, LocationButton } = require('./types/interactive-messages');
@@ -56,10 +62,10 @@ class Client extends EventEmitter {
     constructor(options = {}) {
         super();
         this.sock = null;
-        this.dataPath = options.dataPath || ".synapse-b/auth_data";
+        this.dataPath = options.dataPath || ".baileys/sessions";
         this.sessionName = options.sessionName;
-        this.authPath = [this.dataPath, this.sessionName].join('/');
-        this.store = options.store ? options.store : new MessageStore(this.authPath);
+        this.sessionPath = [this.dataPath, this.sessionName].join('/');
+        this.store = options.store ? options.store : new MessageStore(this.sessionPath);
         this.isOnline = false;
         this.connected = false;
         this.manualDisconnect = false;
@@ -69,6 +75,7 @@ class Client extends EventEmitter {
         this.status = ClientEvent.DISCONNECTED;
         this.markOnlineOnConnect = options.markOnlineOnConnect || false;
         this.enviroment = options.enviroment ? options.enviroment : null;
+        this.printQRInTerminal = options.printQRInTerminal || false;
         this.qrCode = null;
         // =================================================================================================
         //                                     INTEGRAÇÃO DOS HANDLERS
@@ -78,6 +85,7 @@ class Client extends EventEmitter {
         this.messages = new MessageHandler(this);
         this.groups = new GroupHandler(this);
         this.users = new UserHandler(this);
+        this.calls = new CallHandler(this);
     }
 
     /**
@@ -87,17 +95,16 @@ class Client extends EventEmitter {
      */
     async connect() {
         this.status = ClientEvent.INIT;
-        const { state, saveCreds } = await useMultiFileAuthState(this.authPath);
+        const { state, saveCreds } = await useMultiFileAuthState(this.sessionPath);
         const { version } = await fetchLatestBaileysVersion();
-        const credsPath = path.resolve(process.cwd(), this.authPath, "creds.json");
+        const credsPath = path.resolve(process.cwd(), this.sessionPath, "creds.json");
         const creds = await this.fileExists(credsPath);
         if (creds) {
             // Conecta usando @itsukichan/baileys
-            this.sock = makeWASocket({
+            this.sock = itsukichanMakeWASocket({
                 auth: state,
                 version,
                 browser: this.enviroment ? this.enviroment : Browsers.macOS("Desktop"),
-                printQRInTerminal: false, // Desabilitamos para controlar via evento
                 logger: pino({ level: this.loggerLevel }),
                 markOnlineOnConnect: this.markOnlineOnConnect || false,
                 keepAliveIntervalMs: 15000,
@@ -111,11 +118,10 @@ class Client extends EventEmitter {
             });
         } else {
             // Conecta usando Baileys
-            this.sock = wb.makeWASocket({
+            this.sock = whiskeysocketsMakeWASocket({
                 auth: state,
                 version,
                 browser: this.enviroment ? this.enviroment : Browsers.macOS("Desktop"),
-                printQRInTerminal: false, // Desabilitamos para controlar via evento
                 logger: pino({ level: this.loggerLevel }),
                 markOnlineOnConnect: this.markOnlineOnConnect || false,
                 cachedGroupMetadata: async (jid) => groupCache.get(jid),
@@ -153,9 +159,13 @@ class Client extends EventEmitter {
 
             if (qr) {
                 this.qrCode = qr;
+                const base64 = await QRCode.toDataURL(qr);
+                this.qrCodeAttempts = (this.qrCodeAttempts || 0) + 1;
+                this.qrCode = { base64, qr, attempts: this.qrCodeAttempts };
                 this.status = ClientEvent.PAIRING_CODE;
-                this.emit(ClientEvent.PAIRING_CODE, update);
+                this.emit(ClientEvent.PAIRING_CODE, this.qrCode);
                 this.emit(ClientEvent.STATUS_CHANGE, this.status);
+                this.printQRInTerminal ? qrcodeTerminal.generate(qr, { small: true }) : null;
                 return;
             }
 
@@ -177,10 +187,12 @@ class Client extends EventEmitter {
                     break;
 
                 case 'open':
+                    this.user = this.sock.user;
+                    this.qrCode = null; // Limpa o QR code após a conexão
                     this.connected = true;
                     this.manualDisconnect = false;
                     this.status = ClientEvent.CONNECTED;
-                    this.emit(ClientEvent.CONNECTED, update);
+                    this.emit(ClientEvent.CONNECTED, this.user);
                     this.emit(ClientEvent.STATUS_CHANGE, this.status);
                     this.presenceSetInterval = setInterval(() => {
                         if (this.sock?.sendPresenceUpdate) {
@@ -217,7 +229,7 @@ class Client extends EventEmitter {
                         statusType = DisconnectReasons.LOGGED_OUT;
                         disconnectReason = { statusCode, statusType, reason: reasonType, details: boomError.data };
                         try {
-                            await fs.rm(this.authPath, { recursive: true, force: true });
+                            await fs.rm(this.sessionPath, { recursive: true, force: true });
                             // if (this.restartOnClose) this.connect();
                         } catch (err) {
                             this.emit(ClientEvent.ERROR, err);
@@ -256,7 +268,9 @@ class Client extends EventEmitter {
         //                                    OUTROS EVENTOS DE INTERAÇÃO
         // =================================================================================================
 
-        this.sock.ev.on('call', (calls) => this.emit(ClientEvent.CALL, calls[0]));
+        this.sock.ev.on('call', ([call]) => {
+            this.emit(ClientEvent.CALL, this.calls.normalizeCall(call));
+        });
         this.sock.ev.on('groups.update', async ([event]) => {
             this.emit(ClientEvent.GROUP_UPDATE, event);
             const metadata = await this.sock.groupMetadata(event.id);
@@ -268,8 +282,7 @@ class Client extends EventEmitter {
             const metadata = await this.sock.groupMetadata(event.id)
             groupCache.set(event.id, metadata)
         });
-        // this.sock.ev.on('groups.update', (updates) => this.emit(ClientEvent.GROUP_UPDATE, updates));
-        // this.sock.ev.on('group-participants.update', (update) => this.emit(ClientEvent.GROUP_PARTICIPANTS_UPDATE, update));
+
         this.sock.ev.on('presence.update', (update) => this.emit(ClientEvent.PRESENCE_UPDATE, update));
         this.sock.ev.on('contacts.update', (updates) => this.emit(ClientEvent.CONTACT_UPDATE, updates));
         this.sock.ev.on('blocklist.update', (update) => this.emit(ClientEvent.BLOCKLIST_UPDATE, update));
@@ -284,7 +297,7 @@ class Client extends EventEmitter {
                     const messages = history.messages.filter(m => m.key.remoteJid === chatId);
                     for (const msg of messages) {
                         const nmsg = MessageNormalizer.normalize(msg, this);
-                        if (nmsg && this.store && this.store.setMessage) this.store.setMessage(chatId, nmsg);
+                        if (nmsg && this.store && this.store?.setMessage) this.store?.setMessage(chatId, nmsg);
                     }
                 }
                 this.emit(ClientEvent.MESSAGES_HISTORY_SYNC_DONE, history);
@@ -308,7 +321,9 @@ class Client extends EventEmitter {
                         this.emit(ClientEvent.BROADCAST_MESSAGE, msg);
                     } else {
                         const nmsg = await MessageNormalizer.normalize(msg, this);
-                        this.store.setMessage(nmsg.chatId, nmsg);
+                        if (nmsg && this.store && this.store?.setMessage) {
+                            this.store?.setMessage(nmsg.chatId, nmsg);
+                        }
                         // Mensagens de conversacao
                         switch (type) {
                             case 'append':
@@ -373,18 +388,26 @@ class Client extends EventEmitter {
         }
     }
 
+    // Metodos usados pelos handlers
     async decryptPollVote(vote, voteParams) {
         return await decryptPollVote(vote, voteParams);
     }
 
+    // Metodos usados pelos handlers
     jidNormalizedUser(id) {
         return jidNormalizedUser(id);
     }
 
+    // Metodos usados pelos handlers
     async downloadContentFromMessage(content, type) {
         return await downloadContentFromMessage(content, type);
     }
 
+    // Metodos usados pelos handlers
+    getContentType(message) {
+        return getContentType(message);
+    }
+
     async fileExists(path) {
         try {
             await fs.access(path, constants.F_OK);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@areumtecnologia/baileys",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "More baileys fork",
   "license": "ISC",
   "author": "Áreum Tecnologia",
@@ -11,6 +11,10 @@
   },
   "dependencies": {
     "@itsukichan/baileys": "^7.3.2",
-    "baileys": "^7.0.0-rc.9"
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "crypto-digest-sync": "^1.0.0",
+    "node-cache": "^5.1.2",
+    "qrcode": "^1.5.4",
+    "qrcode-terminal": "^0.12.0"
   }
-}
+}

package/utils/message-normalizer.js

@@ -1,5 +1,4 @@
 const digestSync = require('crypto-digest-sync');
-
 /**
  * Classe utilitária estática para normalizar o objeto de mensagem do Baileys
  * em uma estrutura rica, consistente e completa. (Versão 3 - Final)
@@ -35,17 +34,19 @@ class MessageNormalizer {
         const chatId = rawMessage.key.remoteJid.includes('@lid') ? rawMessage.key.remoteJidAlt : rawMessage.key.remoteJid;
         const isGroup = chatId.endsWith('@g.us');
         const clientJid = client.jidNormalizedUser(client.sock.user.id);
-
+        const from = isGroup ? rawMessage.key.participant : rawMessage.key.fromMe ? clientJid : chatId;
+        const to = isGroup ? rawMessage.key.participant : rawMessage.key.fromMe ? chatId : clientJid;
         const normalized = {
             id: rawMessage.key.id,
-            from: isGroup ? rawMessage.key.participant : rawMessage.key.fromMe ? clientJid : chatId,
-            to: isGroup ? rawMessage.key.participant : rawMessage.key.fromMe ? chatId : clientJid,
+            from: from,
+            to: to,
             chatId: chatId,
             timestamp: new Date(Number(rawMessage.messageTimestamp) * 1000),
             fromMe: rawMessage.key.fromMe,
             isGroup: isGroup,
             sender: {
-                id: isGroup ? rawMessage.key.participant : rawMessage.key.fromMe ? clientJid : chatId,
+                id: from,
+                lid: rawMessage.key.remoteJid.includes('@lid') ? rawMessage.key.remoteJid : rawMessage.key.remoteJidAlt && rawMessage.key.remoteJidAlt.includes('@lid') ? rawMessage.key.remoteJidAlt : null,
                 pushName: rawMessage.pushName || ''
             },
             type,
@@ -135,7 +136,7 @@ class MessageNormalizer {
                 isPtt: messageContent.ptt || false,
                 isGif: messageContent.gifPlayback || false,
                 isViewOnce: messageContent.viewOnce || false,
-                download: () => client.messages.download(rawMessage)
+                getAttachments: () => client.messages.getAttachments(rawMessage)
             };
         }
 

package/baileys.code-workspace

@@ -1,8 +0,0 @@
-{
-	"folders": [
-		{
-			"path": "."
-		}
-    ],
-    "settings": {}
-}

package/tests/app.js

@@ -1,68 +0,0 @@
-const { Client, ClientEvent } = require('../index'); // Caminho para sua classe Client
-// 1. Instanciação do Cliente atualizada para usar a nova classe
-const client = new Client({
-    sessionName: sessionId,
-    restartOnClose: true,
-    markOnlineOnConnect: false,
-    enviroment: [account.name || 'MacOS', 'Chrome', '118.0.0.0'],
-    store: {
-        // getMessage: async (chatId, mid) => {
-        //     const msg = (await messages.select([{ chat_id: chatId }, AND, { mid }]))[0];
-        //     return msg;
-        // },
-        // setMessage: async (chatId, msg) => {
-        //     // Nao implementa pois ja registra as mensagens nos eventos message_received e message_sent
-        // }
-    }
-});
-
-client.on(ClientEvent.STATUS_CHANGE, async (status) => {
-    console.log(new Date().toLocaleDateString('pt-br'), `[${sessionId}] Status alterado para: ${status}`);
-});
-
-client.on(ClientEvent.PAIRING_CODE, async ({ qr }) => {
-    console.log(new Date().toLocaleDateString('pt-br'), `[${sessionId}] QR Code recebido. Enviando via webhook...`);
-    const base64 = await QRCode.toDataURL(qr);
-    client.qrCodeAttempts = (client.qrCodeAttempts || 0) + 1;
-    client.qrCode = { base64, url: qr, attempts: client.qrCodeAttempts, status: 'waiting' };
-});
-
-client.on(ClientEvent.PAIRING_SUCCESS, async (event) => {
-    console.log(new Date().toLocaleDateString('pt-br'), `[${sessionId}] QR Code lido com sucesso. Enviando via webhook...`);
-});
-
-client.on(ClientEvent.CONNECTED, async () => {
-    console.log(new Date().toLocaleDateString('pt-br'), `[${sessionId}] Conectado com sucesso.`);
-    client.qrCode = null; // Limpa o QR code após a conexão
-
-    // Envia mensagem de boas-vindas usando o novo handler
-    const user = client.sock.user;
-    const welcomeMessage = `🤖 Olá, ${user.name || 'usuário'}!\nSua sessão (${sessionId}) foi conectada com sucesso.`;
-    await client.messages.sendTextMessage(user.id, welcomeMessage);
-
-});
-
-client.on(ClientEvent.DISCONNECTED, async (reason) => {
-    console.log(new Date().toLocaleDateString('pt-br'), `[${sessionId}] Desconectado. Motivo: ${reason.statusType}`, reason.details || '');
-});
-
-client.on(ClientEvent.MESSAGE_RECEIVED, async (msg) => {
-    console.log(new Date().toLocaleDateString('pt-br'), `[${sessionId}] Mensagem recebida de ${msg.from}`);
-});
-
-client.on(ClientEvent.MESSAGE_SENT, async (msg) => {
-    console.log(new Date().toLocaleDateString('pt-br'), `[${sessionId}] Mensagem enviada para ${msg.to}`);
-});
-
-client.on(ClientEvent.CALL, async (call) => {
-    console.log(new Date().toLocaleDateString('pt-br'), `[${sessionId}] Chamada recebida de ${call.from}`);
-
-});
-
-client.on(ClientEvent.ERROR, (error) => {
-    console.error(new Date().toLocaleDateString('pt-br'), `[${sessionId}] Ocorreu um erro na instância do cliente:`, error, error?.lastDisconnect?.output);
-});
-
-
-// Inicia a conexão
-await client.connect();