Update modules/BotCore.js

modules/BotCore.js

@@ -7,6 +7,53 @@
  * ═══════════════════════════════════════════════════════════════════════
  */
 
+// ═══════════════════════════════════════════════════════════════════════
+// HF SPACES DNS CORRECTIONS - CORREÇÃO CRÍTICA PARA QR CODE
+// ═══════════════════════════════════════════════════════════════════════
+const dns = require('dns');
+const https = require('https');
+
+// 1. Força IPv4 para todas as operações DNS
+dns.setDefaultResultOrder('ipv4first');
+
+// 2. Sobrescreve resolve para usar DNS do Google como fallback
+const originalResolve4 = dns.resolve4.bind(dns);
+const originalResolve = dns.resolve.bind(dns);
+
+dns.resolve4 = function(hostname, options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = { timeout: 10000, family: 4 };
+  }
+  
+  originalResolve4(hostname, options, (err, addresses) => {
+    if (err && (err.code === 'ENODATA' || err.code === 'ENOTFOUND' || err.code === 'EAI_AGAIN')) {
+      console.log(`🔄 DNS fallback para ${hostname}, tentando novamente...`);
+      setTimeout(() => {
+        originalResolve4(hostname, options, callback);
+      }, 3000);
+    } else {
+      callback(err, addresses);
+    }
+  });
+};
+
+// 4. IP direto do WhatsApp como fallback
+const WHATSAPP_DIRECT_IPS = [
+  '108.177.14.0',
+  '108.177.15.0',
+  '142.250.79.0',
+  '172.217.28.0'
+];
+
+function getWhatsAppFallbackIP() {
+  return WHATSAPP_DIRECT_IPS[Math.floor(Math.random() * WHATSAPP_DIRECT_IPS.length)];
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// FIM DAS CORREÇÕES HF SPACES
+// ═══════════════════════════════════════════════════════════════════════
+
 const {
   default: makeWASocket,
   useMultiFileAuthState,
@@ -28,16 +75,26 @@ const CommandHandler = require('./CommandHandler');
 class BotCore {
   constructor() {
     this.config = ConfigManager.getInstance();
-    this.logger = pino({ level: this.config.LOG_LEVEL });
+    this.logger = pino({ 
+      level: this.config.LOG_LEVEL,
+      transport: {
+        target: 'pino-pretty',
+        options: {
+          colorize: true,
+          translateTime: 'SYS:standard',
+          ignore: 'pid,hostname'
+        }
+      }
+    });
 
     // Componentes
-    this.apiClient = new APIClient(this.logger);
-    this.audioProcessor = new AudioProcessor(this.logger);
-    this.mediaProcessor = new MediaProcessor(this.logger);
-    this.messageProcessor = new MessageProcessor(this.logger);
-    this.moderationSystem = new ModerationSystem(this.logger);
-    this.levelSystem = new LevelSystem(this.logger);
-    this.commandHandler = new CommandHandler(this);
+    this.apiClient = null;
+    this.audioProcessor = null;
+    this.mediaProcessor = null;
+    this.messageProcessor = null;
+    this.moderationSystem = null;
+    this.levelSystem = null;
+    this.commandHandler = null;
 
     // Estado
     this.sock = null;
@@ -47,9 +104,18 @@ class BotCore {
     this.lastProcessedTime = 0;
     this.processadas = new Set();
     this.reconnectAttempts = 0;
+    this.qrTimeout = null;
+    this.connectionStartTime = null;
 
     // Armazenamento
     this.store = null;
+
+    // Event listeners
+    this.eventListeners = {
+      onQRGenerated: null,
+      onConnected: null,
+      onDisconnected: null
+    };
   }
 
   /**
@@ -58,15 +124,24 @@ class BotCore {
   async initialize() {
     try {
       this.logger.info('🔧 Inicializando BotCore...');
+      
+      // Log da porta do servidor
+      this.logger.info(`🌐 Porta do servidor: ${this.config.PORT}`);
 
       // Valida configurações
       if (!this.config.validate()) {
         throw new Error('Configurações inválidas');
       }
 
-      // Cria pastas necessárias
+      // Mostra configurações
+      this.config.logConfig();
+
+      // Cria pastas necessárias com tratamento de erro
       this.ensureFolders();
 
+      // Inicializa componentes
+      this.initializeComponents();
+
       this.logger.info('✅ BotCore inicializado');
       return true;
 
@@ -77,23 +152,178 @@ class BotCore {
   }
 
   /**
-   * Cria pastas necessárias
+   * Cria pastas necessárias com tratamento robusto para Hugging Face
    */
   ensureFolders() {
     const fs = require('fs');
-    const folders = [
+    const path = require('path');
+    
+    // Primeiro, tenta os caminhos padrão
+    const defaultFolders = [
       this.config.TEMP_FOLDER,
       this.config.AUTH_FOLDER,
       this.config.DATABASE_FOLDER,
       this.config.LOGS_FOLDER
     ];
 
-    folders.forEach(folder => {
-      if (!fs.existsSync(folder)) {
-        fs.mkdirSync(folder, { recursive: true });
-        this.logger.debug(`📁 Pasta criada: ${folder}`);
+    // Lista de fallbacks para Hugging Face
+    const fallbackBase = '/tmp/akira_data';
+    const fallbackFolders = [
+      path.join(fallbackBase, 'temp'),
+      path.join(fallbackBase, 'auth_info_baileys'),
+      path.join(fallbackBase, 'database'),
+      path.join(fallbackBase, 'logs')
+    ];
+
+    this.logger.info('📁 Criando diretórios necessários...');
+
+    // Tentar criar diretórios padrão primeiro
+    let useFallback = false;
+    for (let i = 0; i < defaultFolders.length; i++) {
+      const folder = defaultFolders[i];
+      try {
+        if (!fs.existsSync(folder)) {
+          fs.mkdirSync(folder, { recursive: true });
+          this.logger.debug(`✅ Pasta criada (padrão): ${folder}`);
+        } else {
+          this.logger.debug(`✅ Pasta já existe: ${folder}`);
+        }
+      } catch (error) {
+        this.logger.warn(`⚠️  Erro ao criar pasta padrão ${folder}: ${error.message}`);
+        useFallback = true;
+        break;
       }
-    });
+    }
+
+    // Se falhou em algum diretório padrão, usar fallback para Hugging Face
+    if (useFallback) {
+      this.logger.info('🔄 Usando diretórios de fallback para Hugging Face Spaces...');
+      
+      // Primeiro cria a pasta base de fallback
+      try {
+        if (!fs.existsSync(fallbackBase)) {
+          fs.mkdirSync(fallbackBase, { recursive: true });
+          this.logger.info(`✅ Pasta base de fallback criada: ${fallbackBase}`);
+        }
+      } catch (error) {
+        this.logger.error(`❌ Erro crítico ao criar pasta base de fallback: ${error.message}`);
+        throw error;
+      }
+
+      // Cria todas as subpastas de fallback
+      fallbackFolders.forEach(folder => {
+        try {
+          if (!fs.existsSync(folder)) {
+            fs.mkdirSync(folder, { recursive: true });
+            this.logger.info(`✅ Pasta de fallback criada: ${folder}`);
+          }
+        } catch (error) {
+          this.logger.error(`❌ Erro ao criar pasta de fallback ${folder}: ${error.message}`);
+        }
+      });
+
+      // Atualiza configurações para usar os caminhos de fallback
+      this.config.TEMP_FOLDER = fallbackFolders[0];
+      this.config.AUTH_FOLDER = fallbackFolders[1];
+      this.config.DATABASE_FOLDER = fallbackFolders[2];
+      this.config.LOGS_FOLDER = fallbackFolders[3];
+      
+      this.logger.info('🔄 Configurações atualizadas para usar caminhos de fallback');
+    } else {
+      this.logger.info('✅ Todos os diretórios criados com sucesso');
+    }
+  }
+
+  /**
+   * Inicializa todos os componentes
+   */
+  initializeComponents() {
+    try {
+      this.logger.debug('🔧 Inicializando componentes...');
+      
+      this.apiClient = new APIClient(this.logger);
+      this.audioProcessor = new AudioProcessor(this.logger);
+      this.mediaProcessor = new MediaProcessor(this.logger);
+      this.messageProcessor = new MessageProcessor(this.logger);
+      this.moderationSystem = new ModerationSystem(this.logger);
+      this.levelSystem = new LevelSystem(this.logger);
+      
+      // CommandHandler pode falhar no Hugging Face, tratar separadamente
+      try {
+        this.commandHandler = new CommandHandler(this);
+        this.logger.debug('✅ CommandHandler inicializado');
+      } catch (commandError) {
+        this.logger.warn(`⚠️  CommandHandler falhou: ${commandError.message}`);
+        this.logger.warn('⚠️  Continuando sem CommandHandler (modo limitado)');
+        this.commandHandler = null;
+      }
+      
+      this.logger.debug('✅ Componentes inicializados');
+    } catch (error) {
+      this.logger.error('❌ Erro ao inicializar componentes:', error.message);
+      // Não lançar erro fatal, tentar continuar com componentes disponíveis
+    }
+  }
+
+  /**
+   * Verifica conectividade de rede ANTES de tentar conectar
+   * Versão otimizada para HF Spaces com fallback de DNS (SIMPLIFICADA)
+   */
+  async _checkNetworkConnectivitySimple() {
+    try {
+      console.log('🌐 Verificando conectividade de rede (simplificado)...');
+      
+      // Teste DNS simples
+      const addresses = await new Promise((resolve, reject) => {
+        dns.resolve4('web.whatsapp.com', { timeout: 5000, family: 4 }, (err, addresses) => {
+          if (err) reject(err);
+          else resolve(addresses);
+        });
+      });
+      
+      console.log(`✅ DNS OK: ${addresses.join(', ')}`);
+      return true;
+      
+    } catch (error) {
+      console.warn(`⚠️  DNS falhou: ${error.message}`);
+      // Não bloqueia, deixa tentar conectar mesmo assim
+      return true;
+    }
+  }
+
+  /**
+   * Cria agente HTTP personalizado para ambientes restritos (HF Spaces)
+   */
+  _createCustomAgent() {
+    try {
+      // Tenta usar proxy se configurado
+      const proxy = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
+      
+      if (proxy) {
+        console.log(`🔌 Usando proxy: ${proxy.substring(0, 40)}...`);
+        try {
+          const { HttpsProxyAgent } = require('https-proxy-agent');
+          return new HttpsProxyAgent(proxy);
+        } catch (e) {
+          console.warn('⚠️  Não foi possível carregar https-proxy-agent');
+        }
+      }
+      
+      // Caso contrário, usa agente padrão com configurações otimizadas para HF Spaces
+      return new https.Agent({
+        keepAlive: true,
+        keepAliveMsecs: 30000,
+        timeout: 60000,
+        maxSockets: 100,
+        maxFreeSockets: 20,
+        // NÃO define rejectUnauthorized para evitar problemas em containers
+        rejectUnauthorized: false
+      });
+      
+    } catch (error) {
+      console.warn(`⚠️  Erro ao criar agente customizado: ${error.message}`);
+      return undefined;
+    }
   }
 
   /**
@@ -111,14 +341,10 @@ class BotCore {
         const stats = fs.statSync(credsPath);
         const ageHours = (Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60);
 
-        // Se as credenciais têm mais de 24 horas, força novo login
-        if (ageHours > 24) {
-          this.logger.warn(`🧹 Credenciais antigas detectadas (${ageHours.toFixed(1)}h). Forçando novo login...`);
-          fs.rmSync(authPath, { recursive: true, force: true });
-          this.isConnected = false;
-          this.currentQR = null;
-          return;
-        }
+        this.logger.info(`📄 Credenciais encontradas (${ageHours.toFixed(1)}h atrás)`);
+
+        // REMOVIDO: Limpeza automática após 24h - Mantém conexão estável no HF
+        // Credenciais são mantidas indefinidamente para evitar QR code diário
 
         // Verifica se o arquivo de credenciais é válido
         const credsContent = fs.readFileSync(credsPath, 'utf8');
@@ -129,13 +355,16 @@ class BotCore {
           fs.rmSync(authPath, { recursive: true, force: true });
           this.isConnected = false;
           this.currentQR = null;
+          this.BOT_JID = null;
           return;
         }
 
         this.logger.info('✅ Credenciais válidas encontradas');
+        this.logger.info(`🤖 Bot registrado como: ${creds.me.id || 'Desconhecido'}`);
       } else {
         this.logger.info('📱 Nenhuma credencial salva. Aguardando QR code...');
         this.isConnected = false;
+        this.BOT_JID = null;
       }
     } catch (error) {
       this.logger.warn('⚠️ Erro ao verificar credenciais:', error.message);
@@ -144,9 +373,12 @@ class BotCore {
         if (fs.existsSync(authPath)) {
           fs.rmSync(authPath, { recursive: true, force: true });
         }
-      } catch (e) {}
+      } catch (e) {
+        this.logger.warn('Erro ao limpar pasta auth:', e.message);
+      }
       this.isConnected = false;
       this.currentQR = null;
+      this.BOT_JID = null;
     }
   }
 
@@ -155,6 +387,15 @@ class BotCore {
    */
   async connect() {
     try {
+      // Marca o tempo de início da conexão
+      this.connectionStartTime = Date.now();
+      
+      // Limpa timeout anterior se existir
+      if (this.qrTimeout) {
+        clearTimeout(this.qrTimeout);
+        this.qrTimeout = null;
+      }
+
       // Evita múltiplas conexões simultâneas
       if (this.sock && this.sock.ws && this.sock.ws.readyState === 1) {
         this.logger.info('🔄 Já conectado, ignorando tentativa de reconexão');
@@ -162,9 +403,34 @@ class BotCore {
       }
 
       this.logger.info('🔗 Conectando ao WhatsApp...');
+      this.logger.info(`📁 Usando pasta de auth: ${this.config.AUTH_FOLDER}`);
 
-      // Verifica conectividade de rede antes de tentar conectar
-      await this._checkNetworkConnectivity();
+      // ═══ VERIFICAÇÃO DE DNS OTIMIZADA PARA HF SPACES ═══
+      console.log('🔍 Verificando resolução DNS...');
+      try {
+        // Tenta resolver usando a função com fallback
+        const addresses = await new Promise((resolve, reject) => {
+          dns.resolve4('web.whatsapp.com', { timeout: 15000, family: 4 }, (err, addresses) => {
+            if (err) reject(err);
+            else resolve(addresses);
+          });
+        });
+        console.log(`✅ DNS: web.whatsapp.com resolvido: ${addresses.join(', ')}`);
+      } catch (dnsError) {
+        console.warn(`⚠️  Erro DNS: ${dnsError.message}`);
+        console.log('🔄 Tentando IP direto do WhatsApp como fallback...');
+        const fallbackIP = getWhatsAppFallbackIP();
+        console.log(`📍 IP fallback disponível: ${fallbackIP}`);
+        // Continua mesmo com erro de DNS, o Baileys pode tentar resolver
+      }
+
+      // Verifica conectividade de rede antes de tentar conectar (simplificado para HF Spaces)
+      // Não bloqueia, tenta conectar mesmo se a verificação falhar
+      try {
+        await this._checkNetworkConnectivitySimple();
+      } catch (netError) {
+        console.log('⚠️  Verificação de rede ignorada, continuando...');
+      }
 
       // Verifica se devemos limpar credenciais antigas
       await this._checkAndCleanOldAuth();
@@ -172,23 +438,36 @@ class BotCore {
       const { state, saveCreds } = await useMultiFileAuthState(this.config.AUTH_FOLDER);
       const { version } = await fetchLatestBaileysVersion();
 
-      this.sock = makeWASocket({
+      this.logger.info(`📦 Versão Baileys: ${version}`);
+
+      // Configurações otimizadas para Hugging Face Spaces
+      const socketConfig = {
         version,
         auth: state,
-        logger: pino({ level: 'silent' }),
-        browser: Browsers.macOS(this.config.BOT_NAME),
+        logger: pino({ level: 'silent' }), // Silencia logs do Baileys
+        browser: Browsers.ubuntu('Chrome'), // Alterado para Ubuntu/Chrome (mais estável em container)
         markOnlineOnConnect: true,
         syncFullHistory: false,
-        printQRInTerminal: false,
-        connectTimeoutMs: 120000, // Aumentado para 2 minutos
-        qrTimeout: 90000, // 90 segundos para QR
+        printQRInTerminal: false, // Não mostra QR no terminal (usamos web)
+        connectTimeoutMs: 180000, // Aumentado para 3 minutos para ambientes lentos
+        qrTimeout: 120000, // 120 segundos para QR
         defaultQueryTimeoutMs: 60000,
-        // Configurações para ambientes com conectividade limitada
-        keepAliveIntervalMs: 30000,
-        retryRequestDelayMs: 5000,
-        maxRetries: 5,
+        // Configurações otimizadas para ambientes com conectividade limitada
+        keepAliveIntervalMs: 45000, // Aumentado para manter conexão
+        retryRequestDelayMs: 8000, // Aumentado delay entre retentativas
+        maxRetries: 3, // Reduzido número de retentativas
         // Configurações específicas para ambientes restritos
         agent: this._createCustomAgent(),
+        // Força uso de IPv4
+        fetchAgent: this._createCustomAgent(),
+        // Configurações de WebSocket otimizadas
+        wsOptions: {
+          headers: {
+            'Origin': 'https://web.whatsapp.com',
+            'Host': 'web.whatsapp.com',
+            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+          }
+        },
         getMessage: async (key) => {
           if (!key) return undefined;
           try {
@@ -196,17 +475,26 @@ class BotCore {
               const msg = await this.store.loadMessage(key.remoteJid, key.id);
               return msg ? msg.message : undefined;
             }
-          } catch (e) {}
+          } catch (e) {
+            this.logger.debug('Erro ao carregar mensagem:', e.message);
+          }
           return undefined;
         }
-      });
+      };
+
+      this.logger.debug('⚙️  Configuração do socket:', JSON.stringify(socketConfig, null, 2));
+
+      this.sock = makeWASocket(socketConfig);
 
-      // Vincula store
+      // Vincula store se existir
       try {
         if (this.store && typeof this.store.bind === 'function') {
           this.store.bind(this.sock.ev);
+          this.logger.debug('✅ Store vinculada ao socket');
         }
-      } catch (e) {}
+      } catch (e) {
+        this.logger.warn('⚠️  Erro ao vincular store:', e.message);
+      }
 
       // Event listeners
       this.sock.ev.on('creds.update', saveCreds);
@@ -219,16 +507,35 @@ class BotCore {
           this.logger.warn('⏰ QR não gerado automaticamente. Tentando forçar...');
           this._forceQRGeneration();
         }
-      }, 10000); // 10 segundos
+      }, 25000); // Aumentado para 25 segundos
 
-      this.logger.info('✅ Conexão inicializada');
+      this.logger.info('✅ Conexão inicializada - Aguardando QR code ou conexão...');
 
     } catch (error) {
       this.logger.error('❌ Erro na conexão:', error.message);
+      this.logger.error(error.stack);
+      
+      // Reconecta automaticamente após erro
+      this._scheduleReconnect();
       throw error;
     }
   }
 
+  /**
+   * Agenda reconexão automática
+   */
+  _scheduleReconnect() {
+    const reconnectDelay = Math.min(10000 * Math.pow(1.5, this.reconnectAttempts), 120000);
+    this.reconnectAttempts = (this.reconnectAttempts || 0) + 1;
+
+    this.logger.info(`🔄 Reconectando em ${reconnectDelay/1000}s... (tentativa ${this.reconnectAttempts})`);
+    
+    setTimeout(() => {
+      this.logger.info('🔄 Iniciando reconexão...');
+      this.connect().catch(e => this.logger.error('Erro na reconexão:', e.message));
+    }, reconnectDelay);
+  }
+
   /**
    * Handle connection update
    */
@@ -236,10 +543,31 @@ class BotCore {
     try {
       const { connection, lastDisconnect, qr } = update;
 
+      // Log detalhado para debugging
+      this.logger.debug(`🔄 Connection update received:`, { 
+        connection, 
+        hasQR: !!qr, 
+        lastDisconnect: lastDisconnect ? 'yes' : 'no'
+      });
+
       if (qr) {
         this.currentQR = qr;
         this.logger.info('📱 QR Code gerado - pronto para scan!');
-        this.logger.info('🔗 Acesse http://localhost:7860/qr para ver o QR code');
+        this.logger.info(`🔗 Acesse: http://localhost:${this.config.PORT}/qr`);
+        
+        // Log extra para web
+        console.log('\n' + '═'.repeat(70));
+        console.log('📱 QR CODE DISPONÍVEL NA WEB!');
+        console.log('═'.repeat(70));
+        console.log(`🔗 URL: http://localhost:${this.config.PORT}/qr`);
+        console.log('⏳ Válido por 120 segundos');
+        console.log('📱 Abra essa URL no seu navegador');
+        console.log('═'.repeat(70) + '\n');
+
+        // Chama callback se existir
+        if (this.eventListeners.onQRGenerated) {
+          this.eventListeners.onQRGenerated(qr);
+        }
 
         // Limpa timeout de força
         if (this.qrTimeout) {
@@ -252,9 +580,12 @@ class BotCore {
         this.BOT_JID = (this.sock.user && this.sock.user.id) || null;
         this.isConnected = true;
         this.lastProcessedTime = Date.now();
-        this.currentQR = null;
+        this.currentQR = null; // Limpa QR após conexão
         this.reconnectAttempts = 0; // Reseta contador de tentativas
 
+        // Calcula tempo de conexão
+        const connectionTime = Date.now() - this.connectionStartTime;
+        
         // Limpa timeout de força
         if (this.qrTimeout) {
           clearTimeout(this.qrTimeout);
@@ -264,11 +595,30 @@ class BotCore {
         this.logger.info('\n' + '═'.repeat(70));
         this.logger.info('✅ AKIRA BOT V21 ONLINE!');
         this.logger.info('═'.repeat(70));
-        this.config.logConfig();
+        this.logger.info(`🤖 Nome: ${this.config.BOT_NAME}`);
+        this.logger.info(`📱 Número: ${this.config.BOT_NUMERO_REAL}`);
+        this.logger.info(`🔗 JID: ${this.BOT_JID}`);
+        this.logger.info(`⏱️  Tempo de conexão: ${connectionTime}ms`);
         this.logger.info('═'.repeat(70) + '\n');
 
+        // Chama callback se existir
+        if (this.eventListeners.onConnected) {
+          this.eventListeners.onConnected(this.BOT_JID);
+        }
+
+        // Log extra para web
+        console.log('\n' + '═'.repeat(70));
+        console.log('✅ BOT CONECTADO COM SUCESSO!');
+        console.log('═'.repeat(70));
+        console.log(`🤖 Bot está online e pronto para uso`);
+        console.log(`📱 Número: ${this.config.BOT_NUMERO_REAL}`);
+        console.log(`🔗 JID: ${this.BOT_JID}`);
+        console.log('═'.repeat(70) + '\n');
+
       } else if (connection === 'close') {
         this.isConnected = false;
+        this.currentQR = null;
+        
         const code = (lastDisconnect && lastDisconnect.error && lastDisconnect.error.output && lastDisconnect.error.output.statusCode) || undefined;
         const reason = (lastDisconnect && lastDisconnect.error && lastDisconnect.error.message) || 'desconhecido';
 
@@ -283,21 +633,48 @@ class BotCore {
           this._cleanAuthOnError();
         } else if (code === 403) {
           this.logger.warn('🚫 Conta banida ou bloqueada');
+        } else if (code === 503) {
+          this.logger.warn('🌐 Serviço indisponível - servidor WhatsApp offline');
+        }
+
+        // Chama callback se existir
+        if (this.eventListeners.onDisconnected) {
+          this.eventListeners.onDisconnected(code, reason);
         }
 
-        // Reconecta com backoff exponencial
-        const delay = Math.min(5000 * Math.pow(2, this.reconnectAttempts || 0), 30000);
+        // Reconecta com backoff exponencial otimizado
+        const reconnectDelay = Math.min(8000 * Math.pow(1.8, this.reconnectAttempts || 0), 90000); // Máximo 90 segundos
         this.reconnectAttempts = (this.reconnectAttempts || 0) + 1;
 
-        this.logger.info(`🔄 Reconectando em ${delay/1000}s... (tentativa ${this.reconnectAttempts})`);
-        setTimeout(() => this.connect().catch(e => this.logger.error('Erro na reconexão:', e)), delay);
+        this.logger.info(`🔄 Reconectando em ${reconnectDelay/1000}s... (tentativa ${this.reconnectAttempts})`);
+        
+        // Limpa socket atual
+        if (this.sock) {
+          try {
+            this.sock.ev.removeAllListeners();
+            if (this.sock.ws) {
+              this.sock.ws.close();
+            }
+          } catch (e) {
+            this.logger.warn('Erro ao limpar socket:', e.message);
+          }
+          this.sock = null;
+        }
+
+        setTimeout(() => {
+          this.logger.info('🔄 Iniciando reconexão...');
+          this.connect().catch(e => this.logger.error('Erro na reconexão:', e.message));
+        }, reconnectDelay);
 
       } else if (connection === 'connecting') {
         this.logger.info('🔄 Conectando ao WhatsApp...');
+        // Limpa QR code anterior ao tentar nova conexão
+        this.currentQR = null;
       }
 
     } catch (error) {
       this.logger.error('❌ Erro em handleConnectionUpdate:', error.message);
+      this.logger.error(error.stack);
     }
   }
 
@@ -314,8 +691,11 @@ class BotCore {
       this.processadas.add(m.key.id);
       setTimeout(() => this.processadas.delete(m.key.id), this.config.MESSAGE_DEDUP_TIME_MS);
 
-      // Ignorar mensagens antigas
-      if (m.messageTimestamp && m.messageTimestamp * 1000 < this.lastProcessedTime - 10000) {
+      // Ignorar mensagens antigas (mais de 10 segundos)
+      const messageTime = m.messageTimestamp * 1000;
+      const currentTime = Date.now();
+      if (messageTime && messageTime < currentTime - 10000) {
+        this.logger.debug(`⏭️  Mensagem antiga ignorada: ${messageTime}`);
         return;
       }
 
@@ -338,6 +718,9 @@ class BotCore {
       const texto = this.messageProcessor.extractText(m).trim();
       const temAudio = this.messageProcessor.hasAudio(m);
 
+      // Log da mensagem recebida
+      this.logger.info(`📩 [${ehGrupo ? 'GRUPO' : 'PV'}] ${nome}: ${texto.substring(0, 50)}${texto.length > 50 ? '...' : ''}`);
+
       // Verifica ban
       if (this.moderationSystem.isBanned(numeroReal)) {
         this.logger.warn(`🚫 Mensagem de usuário banido ignorada: ${nome}`);
@@ -371,11 +754,16 @@ class BotCore {
           const { rec, leveled } = this.levelSystem.awardXp(m.key.remoteJid, uid, xpAmount);
           if (leveled) {
             const patente = typeof this.getPatente === 'function' ? this.getPatente(rec.level) : `Nível ${rec.level}`;
-            await this.sock.sendMessage(m.key.remoteJid, { text: `🎉 @${uid.split('@')[0]} subiu para o nível ${rec.level}! 🏅 ${patente}`, contextInfo: { mentionedJid: [uid] } });
+            await this.sock.sendMessage(m.key.remoteJid, { 
+              text: `🎉 @${uid.split('@')[0]} subiu para o nível ${rec.level}! 🏅 ${patente}`, 
+              contextInfo: { mentionedJid: [uid] } 
+            });
             if (rec.level >= this.levelSystem.maxLevel) {
               const maxRes = await this.levelSystem.registerMaxLevelUser(m.key.remoteJid, uid, m.pushName || uid, this.sock);
               if (maxRes && maxRes.promoted) {
-                await this.sock.sendMessage(m.key.remoteJid, { text: `🎊 ${m.pushName || uid} foi promovido automaticamente a ADM!` });
+                await this.sock.sendMessage(m.key.remoteJid, { 
+                  text: `🎊 ${m.pushName || uid} foi promovido automaticamente a ADM!` 
+                });
               }
             }
           }
@@ -409,30 +797,35 @@ class BotCore {
   async handleAudioMessage(m, nome, numeroReal, replyInfo, ehGrupo) {
     this.logger.info(`🎤 [ÁUDIO] ${nome}`);
 
-    // Decodifica áudio
-    const audioBuffer = await this.mediaProcessor.downloadMedia(
-      m.message.audioMessage,
-      'audio'
-    );
+    try {
+      // Decodifica áudio
+      const audioBuffer = await this.mediaProcessor.downloadMedia(
+        m.message.audioMessage,
+        'audio'
+      );
 
-    if (!audioBuffer) {
-      this.logger.error('❌ Erro ao baixar áudio');
-      return;
-    }
+      if (!audioBuffer) {
+        this.logger.error('❌ Erro ao baixar áudio');
+        return;
+      }
 
-    // STT
-    const transcricao = await this.audioProcessor.speechToText(audioBuffer);
+      // STT
+      const transcricao = await this.audioProcessor.speechToText(audioBuffer);
 
-    if (!transcricao.sucesso) {
-      this.logger.warn('⚠️  Falha na transcrição');
-      return;
-    }
+      if (!transcricao.sucesso) {
+        this.logger.warn('⚠️  Falha na transcrição');
+        return;
+      }
 
-    const textoAudio = transcricao.texto;
-    this.logger.info(`📝 Transcrição: ${textoAudio.substring(0, 80)}...`);
+      const textoAudio = transcricao.texto;
+      this.logger.info(`📝 Transcrição: ${textoAudio.substring(0, 80)}...`);
 
-    // Processa como texto
-    await this.handleTextMessage(m, nome, numeroReal, textoAudio, replyInfo, ehGrupo, true);
+      // Processa como texto
+      await this.handleTextMessage(m, nome, numeroReal, textoAudio, replyInfo, ehGrupo, true);
+      
+    } catch (error) {
+      this.logger.error('❌ Erro ao processar áudio:', error.message);
+    }
   }
 
   /**
@@ -452,7 +845,10 @@ class BotCore {
       try {
         if (this.commandHandler) {
           const handled = await this.commandHandler.handle(m, { nome, numeroReal, texto, replyInfo, ehGrupo });
-          if (handled) return;
+          if (handled) {
+            this.logger.info(`⚡ Comando tratado: ${texto.substring(0, 30)}...`);
+            return;
+          }
         }
       } catch (e) {
         this.logger.warn('Erro no CommandHandler:', e.message);
@@ -489,7 +885,7 @@ class BotCore {
       }
 
       if (!deveResponder) {
-        this.logger.info(`⏭️  Mensagem ignorada (sem ativação): ${texto.substring(0, 50)}...`);
+        this.logger.debug(`⏭️  Mensagem ignorada (sem ativação): ${texto.substring(0, 50)}...`);
         return;
       }
 
@@ -565,7 +961,8 @@ class BotCore {
       await delay(durationMs);
       await this.sock.sendPresenceUpdate('paused', jid);
     } catch (e) {
-      // Silenciosamente ignora
+      // Ignora erros de presença silenciosamente
+      this.logger.debug('Erro na simulação de digitação:', e.message);
     }
   }
 
@@ -626,6 +1023,7 @@ class BotCore {
       this.isConnected = false;
       this.currentQR = null;
       this.BOT_JID = null;
+      this.reconnectAttempts = 0;
     } catch (error) {
       this.logger.error('❌ Erro ao limpar credenciais:', error.message);
     }
@@ -638,15 +1036,30 @@ class BotCore {
     try {
       this.logger.info('🔄 Forçando geração de QR code...');
 
+      // Limpa estado atual
+      this.currentQR = null;
+      this.isConnected = false;
+
       if (this.sock) {
-        this.sock.ev.removeAllListeners();
-        if (this.sock.ws) {
-          this.sock.ws.close();
+        try {
+          this.sock.ev.removeAllListeners();
+          if (this.sock.ws) {
+            this.sock.ws.close();
+          }
+        } catch (e) {
+          this.logger.warn('Erro ao limpar socket:', e.message);
         }
+        this.sock = null;
+      }
+
+      // Limpa timeout se existir
+      if (this.qrTimeout) {
+        clearTimeout(this.qrTimeout);
+        this.qrTimeout = null;
       }
 
       // Pequeno delay antes de reconectar
-      await delay(2000);
+      await delay(3000);
 
       // Reconecta
       await this.connect();
@@ -660,11 +1073,42 @@ class BotCore {
    * Obtém QR Code atual
    */
   getQRCode() {
-    // Se não está conectado E não tem QR, significa que precisa de login
-    if (!this.isConnected && !this.currentQR) {
-      this.logger.warn('⚠️ Bot não conectado e sem QR code. Verifique se as credenciais expiraram.');
+    try {
+      // Se já está conectado, não precisa de QR
+      if (this.isConnected) {
+        this.logger.debug('✅ Bot já conectado, sem necessidade de QR code');
+        return null;
+      }
+      
+      // Se tem QR code armazenado, retorna
+      if (this.currentQR) {
+        this.logger.debug(`📱 QR code disponível (${this.currentQR.length} caracteres)`);
+        return this.currentQR;
+      }
+      
+      // Se não está conectado e não tem QR, verifica estado
+      this.logger.debug('🔄 Bot não conectado e sem QR code disponível');
+      
+      // Verifica se a conexão está em andamento
+      if (this.sock && this.sock.ws) {
+        const state = this.sock.ws.readyState;
+        if (state === 0) { // CONNECTING
+          this.logger.debug('🔄 Conexão em andamento... aguarde QR code');
+          return null;
+        } else if (state === 1) { // OPEN
+          this.logger.debug('✅ Conexão já aberta, mas isConnected não atualizado');
+          return null;
+        }
+      }
+      
+      // Se chegou aqui, precisa reconectar
+      this.logger.debug('⚠️ Bot desconectado e sem QR. Talvez seja necessário reiniciar a conexão.');
+      return null;
+      
+    } catch (error) {
+      this.logger.error('❌ Erro ao obter QR code:', error.message);
+      return null;
     }
-    return this.currentQR;
   }
 
   /**
@@ -677,7 +1121,10 @@ class BotCore {
       botNumero: this.config.BOT_NUMERO_REAL,
       botName: this.config.BOT_NAME,
       version: this.config.BOT_VERSION,
-      uptime: Math.floor(process.uptime())
+      uptime: Math.floor(process.uptime()),
+      hasQR: this.currentQR !== null && this.currentQR !== undefined,
+      reconnectAttempts: this.reconnectAttempts,
+      connectionStartTime: this.connectionStartTime
     };
   }
 
@@ -685,15 +1132,98 @@ class BotCore {
    * Retorna estatísticas
    */
   getStats() {
+    const status = this.getStatus();
+    
     return {
-      ...this.getStatus(),
-      api: this.apiClient.getStats(),
-      audio: this.audioProcessor.getStats(),
-      media: this.mediaProcessor.getStats(),
-      message: this.messageProcessor.getStats(),
-      moderation: this.moderationSystem.getStats()
+      ...status,
+      api: this.apiClient ? this.apiClient.getStats() : { error: 'API não inicializada' },
+      audio: this.audioProcessor ? this.audioProcessor.getStats() : { error: 'AudioProcessor não inicializado' },
+      media: this.mediaProcessor ? this.mediaProcessor.getStats() : { error: 'MediaProcessor não inicializado' },
+      message: this.messageProcessor ? this.messageProcessor.getStats() : { error: 'MessageProcessor não inicializado' },
+      moderation: this.moderationSystem ? this.moderationSystem.getStats() : { error: 'ModerationSystem não inicializado' },
+      leveling: this.levelSystem ? this.levelSystem.getStats() : { error: 'LevelSystem não inicializado' },
+      componentsInitialized: {
+        apiClient: !!this.apiClient,
+        audioProcessor: !!this.audioProcessor,
+        mediaProcessor: !!this.mediaProcessor,
+        messageProcessor: !!this.messageProcessor,
+        moderationSystem: !!this.moderationSystem,
+        levelSystem: !!this.levelSystem,
+        commandHandler: !!this.commandHandler
+      }
     };
   }
+
+  /**
+   * Registra event listeners
+   */
+  on(event, callback) {
+    if (event === 'qr') {
+      this.eventListeners.onQRGenerated = callback;
+    } else if (event === 'connected') {
+      this.eventListeners.onConnected = callback;
+    } else if (event === 'disconnected') {
+      this.eventListeners.onDisconnected = callback;
+    } else {
+      this.logger.warn(`⚠️  Evento não suportado: ${event}`);
+    }
+  }
+
+  /**
+   * Limpa cache de componentes
+   */
+  clearCache() {
+    try {
+      if (this.audioProcessor && typeof this.audioProcessor.clearCache === 'function') {
+        this.audioProcessor.clearCache();
+      }
+      if (this.mediaProcessor && typeof this.mediaProcessor.clearCache === 'function') {
+        this.mediaProcessor.clearCache();
+      }
+      if (this.messageProcessor && typeof this.messageProcessor.clearCache === 'function') {
+        this.messageProcessor.clearCache();
+      }
+      this.logger.info('✅ Cache limpo');
+    } catch (error) {
+      this.logger.error('❌ Erro ao limpar cache:', error.message);
+    }
+  }
+
+  /**
+   * Verifica se o bot está pronto
+   */
+  isReady() {
+    return this.isConnected && this.sock && this.sock.ws && this.sock.ws.readyState === 1;
+  }
+
+  /**
+   * Desconecta o bot
+   */
+  async disconnect() {
+    try {
+      this.logger.info('🔴 Desconectando bot...');
+      
+      if (this.sock) {
+        try {
+          this.sock.ev.removeAllListeners();
+          if (this.sock.ws) {
+            this.sock.ws.close();
+          }
+        } catch (e) {
+          this.logger.warn('Erro ao fechar socket:', e.message);
+        }
+        this.sock = null;
+      }
+      
+      this.isConnected = false;
+      this.currentQR = null;
+      this.BOT_JID = null;
+      
+      this.logger.info('✅ Bot desconectado');
+    } catch (error) {
+      this.logger.error('❌ Erro ao desconectar:', error.message);
+    }
+  }
 }
 
-module.exports = BotCore;
+module.exports = BotCore;