@areumtecnologia/baileys 1.0.0 → 1.0.1

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

@@ -245,6 +245,7 @@ class MessageHandler {
         return this.client.sock.readMessages([messageKey]);
     }
 
+    /** 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 +256,7 @@ class MessageHandler {
         }
     }
 
-    /** Envia uma mensagem com botões interativos. */
+    /** 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,18 +268,30 @@ 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 messageContent = message.message[type];
-        if (!messageContent.url) throw new Error('Mensagem não contém mídia para download.');
+        if (!messageContent.url)
+            return null;
 
         const stream = await this.client.downloadContentFromMessage(messageContent, type.replace('Message', ''));
         let buffer = Buffer.from([]);
         for await (const chunk of stream) {
             buffer = Buffer.concat([buffer, chunk]);
         }
-        return buffer;
+        return {
+            type: messageContent.mimetype,
+            buffer,
+            save: async (path) => {
+                const mime = message.message.imageMessage.mimetype;
+                const extension = mime.split('/')[1];
+                const filename = `${message.from}-${Date.now()}.${extension}`;
+                const filepath = path ? path : this.client.sessionPath + '/media/' + filename;
+                await fs.writeFile(filepath, buffer);
+                return { filename, filepath };
+            }
+        };
     }
 }
 

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
+    async 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.1",
   "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 : null,
                 pushName: rawMessage.pushName || ''
             },
             type,
@@ -65,6 +66,9 @@ class MessageNormalizer {
             reaction: this._extractReaction(rawMessage.message),
             pollUpdate: await this._extractPollUpdate(rawMessage, client),
             poll: this._extractPollCreation(rawMessage),
+            getAttachments: async () => {
+                return await client.messages.getAttachments(rawMessage);
+            },
             raw: rawMessage // Referência ao objeto original para acesso avançado
         };
 

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();