refactor: enhance chat components with type safety and response functionality

- Updated type definitions in ChatWindow and MessageList components for better type safety.
- Improved MessageInput to handle message responses, including a preview feature for replying to messages.
- Enhanced the chat message handling logic to support message references and improve user interaction.
- Refactored notification utility functions to support push notifications and rate limiting for email sending.
- Updated backend schema to accommodate new features related to message responses and notifications.

packages/backend/convex/actions/email.ts

@@ -3,6 +3,7 @@
 import { action } from "../_generated/server";
 import { v } from "convex/values";
 import { internal } from "../_generated/api";
+import { decryptSMTPPasswordNode } from "./utils/nodeCrypto";
 
 export const enviar = action({
   args: {
@@ -23,47 +24,105 @@ export const enviar = action({
         return { sucesso: false, erro: "Email não encontrado" };
       }
 
-      // Buscar configuração SMTP ativa com senha descriptografada
-      const config = await ctx.runQuery(internal.email.getActiveEmailConfigWithPassword, {});
-
-      if (!config) {
+      // Buscar configuração SMTP ativa
+      const configRaw = await ctx.runQuery(internal.email.getActiveEmailConfig, {});
+      
+      if (!configRaw) {
         return {
           sucesso: false,
           erro: "Configuração de email não encontrada ou inativa",
         };
       }
 
-      if (!config.testadoEm) {
+      // Descriptografar senha usando função compatível com Node.js
+      let senhaDescriptografada: string;
+      try {
+        senhaDescriptografada = await decryptSMTPPasswordNode(configRaw.senhaHash);
+      } catch (decryptError) {
+        const decryptErrorMessage = decryptError instanceof Error ? decryptError.message : String(decryptError);
+        console.error("Erro ao descriptografar senha SMTP:", decryptErrorMessage);
         return {
           sucesso: false,
-          erro: "Configuração SMTP não foi testada. Teste a conexão primeiro!",
+          erro: `Erro ao descriptografar senha SMTP: ${decryptErrorMessage}`,
         };
       }
 
+      const config = {
+        ...configRaw,
+        senha: senhaDescriptografada,
+      };
+
+      // Config já foi validado acima
+
+      // Avisar mas não bloquear se não foi testado
+      if (!config.testadoEm) {
+        console.warn("⚠️ Configuração SMTP não foi testada. Tentando enviar mesmo assim...");
+      }
+
       // Marcar como enviando
       await ctx.runMutation(internal.email.markEmailEnviando, {
         emailId: args.emailId,
       });
 
-      // Criar transporter do nodemailer
-      const transporter = nodemailer.createTransport({
+      // Criar transporter do nodemailer com configuração melhorada
+      const transporterOptions: {
+        host: string;
+        port: number;
+        secure: boolean;
+        requireTLS?: boolean;
+        auth: {
+          user: string;
+          pass: string;
+        };
+        tls?: {
+          rejectUnauthorized: boolean;
+          ciphers?: string;
+        };
+        connectionTimeout: number;
+        greetingTimeout: number;
+        socketTimeout: number;
+        pool?: boolean;
+        maxConnections?: number;
+        maxMessages?: number;
+      } = {
         host: config.servidor,
         port: config.porta,
         secure: config.usarSSL,
-        requireTLS: config.usarTLS,
         auth: {
           user: config.usuario,
           pass: config.senha, // Senha já descriptografada
         },
-        tls: {
-          // Permitir certificados autoassinados apenas se necessário
+        connectionTimeout: 15000, // 15 segundos
+        greetingTimeout: 15000,
+        socketTimeout: 15000,
+        pool: true, // Usar pool de conexões
+        maxConnections: 5,
+        maxMessages: 100,
+      };
+
+      // Adicionar TLS apenas se necessário
+      if (config.usarTLS) {
+        transporterOptions.requireTLS = true;
+        transporterOptions.tls = {
+          rejectUnauthorized: false, // Permitir certificados autoassinados
+        };
+      } else if (config.usarSSL) {
+        transporterOptions.tls = {
           rejectUnauthorized: false,
-          ciphers: "SSLv3",
-        },
-        connectionTimeout: 10000, // 10 segundos
-        greetingTimeout: 10000,
-        socketTimeout: 10000,
-      });
+        };
+      }
+
+      const transporter = nodemailer.createTransport(transporterOptions);
+
+      // Verificar conexão antes de enviar
+      try {
+        await transporter.verify();
+        console.log("✅ Conexão SMTP verificada com sucesso");
+      } catch (verifyError) {
+        const verifyErrorMessage = verifyError instanceof Error ? verifyError.message : String(verifyError);
+        console.warn("⚠️ Falha na verificação SMTP, mas tentando enviar mesmo assim:", verifyErrorMessage);
+        // Não bloquear envio por falha na verificação, apenas avisar
+      }
 
       // Validar email destinatário antes de enviar
       const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
@@ -71,13 +130,28 @@ export const enviar = action({
         throw new Error(`Email destinatário inválido: ${email.destinatario}`);
       }
 
+      // Criar versão texto do HTML (remover tags e decodificar entidades básicas)
+      const textoPlano = email.corpo
+        .replace(/<[^>]*>/g, "") // Remover tags HTML
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .trim();
+
       // Enviar email
       const info = await transporter.sendMail({
         from: `"${config.nomeRemetente}" <${config.emailRemetente}>`,
         to: email.destinatario,
         subject: email.assunto,
         html: email.corpo,
-        text: email.corpo.replace(/<[^>]*>/g, ""), // Versão texto para clientes que não suportam HTML
+        text: textoPlano || email.assunto, // Versão texto para clientes que não suportam HTML
+        headers: {
+          "X-Mailer": "SGSE-Sistema",
+          "X-Priority": "3",
+        },
       });
 
       interface MessageInfo {
@@ -102,12 +176,23 @@ export const enviar = action({
       return { sucesso: true };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("❌ Erro ao enviar email:", errorMessage);
+      const errorStack = error instanceof Error ? error.stack : undefined;
+      
+      console.error("❌ Erro ao enviar email:", {
+        emailId: args.emailId,
+        destinatario: email?.destinatario,
+        erro: errorMessage,
+        stack: errorStack,
+      });
+
+      // Marcar como falha com detalhes completos
+      const erroCompleto = errorStack 
+        ? `${errorMessage}\n\nStack: ${errorStack}` 
+        : errorMessage;
 
-      // Marcar como falha
       await ctx.runMutation(internal.email.markEmailFalha, {
         emailId: args.emailId,
-        erro: errorMessage,
+        erro: erroCompleto.substring(0, 2000), // Limitar tamanho do erro
       });
 
       return { sucesso: false, erro: errorMessage };