Lizandro GuarnizoandClaude Opus 5
eddec45857
En "Dónde atiende", el canal correo: el agente lee una casilla y responde solo los correos que llegan, con su base de conocimiento, igual que atiende WhatsApp. Como el correo no tiene webhook, se revisa por intervalo — y el intervalo lo elige el cliente por canal (2 a 60 minutos): una inmobiliaria quiere 2, a un estudio contable con 30 le sobra. El cron corre cada minuto pero cada casilla se revisa solo cuando le toca, con un pool de 8 para que 100 casillas no salgan a la red en el mismo instante. Las guardas que separan "asistente" de "incidente", cada una con su test: nunca responde correo automático ni se responde a sí mismo (el bucle con otro autoresponder); la revisión se marca ANTES de conectar, así una contraseña cambiada no martilla el login cada minuto hasta que el host del cliente nos bloquea; y el correo se marca leído recién cuando la respuesta salió — si el envío falla, queda sin leer y se reintenta. En "Lo que sabe", las cuentas de correo: casillas que el agente consulta a pedido — "revisame los correos de hoy y haceme un resumen" — sin nada de fondo. Solo lectura en serio: Peek, INBOX en read-only, y un test que falla si alguien le agrega un marcado. Ahora se pueden conectar varias por agente; con más de una, el modelo pregunta cuál en vez de adivinar — resumirle a alguien la casilla que no pidió no es un error menor. El alta pide correo y contraseña: el host se deduce (mail.<dominio>) y el campo técnico aparece recién si eso falla. Se prueba la conexión antes de guardar, con la persona mirando. Enviar por una cuenta conectada está bloqueado a propósito: para responder correos está el canal, con sus guardas. Una tool de envío sin límites es una máquina de spam con el dominio del cliente. La navegación acompaña: "Lo que sabe" agrupa Información, Cuentas de correo y Herramientas — tres formas de saber, no tres pantallas sueltas — y Avanzado queda solo con Problemas. El SMTP se unificó en una sola implementación que comparten soporte y el canal: el bug de STARTTLS que abría dos conexiones ya se pagó una vez. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
94 lines
2.7 KiB
Go
94 lines
2.7 KiB
Go
package services
|
|
|
|
import (
|
|
"crypto/tls"
|
|
"fmt"
|
|
"net/smtp"
|
|
"strings"
|
|
)
|
|
|
|
// DatosSMTP es lo mínimo para mandar un correo por el servidor de cualquiera:
|
|
// lo usa el buzón de soporte con su configuración y el canal de correo de un
|
|
// agente con las credenciales del cliente. Una sola implementación — el bug de
|
|
// STARTTLS que abría dos conexiones ya se pagó una vez.
|
|
type DatosSMTP struct {
|
|
Host string
|
|
Puerto int
|
|
Encriptado string // ssl | tls | starttls | none
|
|
Usuario string
|
|
Password string
|
|
Desde string
|
|
DesdeNombre string
|
|
}
|
|
|
|
// EnviarPorSMTP abre una sola conexión, la asegura según la configuración,
|
|
// manda el mensaje y cierra con QUIT.
|
|
func EnviarPorSMTP(d DatosSMTP, para, asunto, cuerpoHTML string) error {
|
|
if d.Host == "" || d.Desde == "" || para == "" {
|
|
return fmt.Errorf("faltan datos para el envío (servidor, remitente o destinatario)")
|
|
}
|
|
puerto := d.Puerto
|
|
if puerto == 0 {
|
|
puerto = 587
|
|
}
|
|
nombre := d.DesdeNombre
|
|
if nombre == "" {
|
|
nombre = d.Desde
|
|
}
|
|
addr := fmt.Sprintf("%s:%d", d.Host, puerto)
|
|
msg := []byte(fmt.Sprintf(
|
|
"From: %s <%s>\r\nTo: %s\r\nSubject: %s\r\nMIME-Version: 1.0\r\nContent-Type: text/html; charset=UTF-8\r\n\r\n%s",
|
|
nombre, d.Desde, para, asunto, cuerpoHTML))
|
|
|
|
enc := strings.ToLower(strings.TrimSpace(d.Encriptado))
|
|
|
|
var cliente *smtp.Client
|
|
var err error
|
|
if enc == "tls" || enc == "ssl" {
|
|
conn, errDial := tls.Dial("tcp", addr, &tls.Config{ServerName: d.Host})
|
|
if errDial != nil {
|
|
return fmt.Errorf("no se pudo conectar por TLS: %w", errDial)
|
|
}
|
|
cliente, err = smtp.NewClient(conn, d.Host)
|
|
if err != nil {
|
|
conn.Close()
|
|
return fmt.Errorf("saludo SMTP rechazado: %w", err)
|
|
}
|
|
} else {
|
|
cliente, err = smtp.Dial(addr)
|
|
if err != nil {
|
|
return fmt.Errorf("no se pudo conectar: %w", err)
|
|
}
|
|
if enc != "none" {
|
|
if err := cliente.StartTLS(&tls.Config{ServerName: d.Host}); err != nil {
|
|
cliente.Close()
|
|
return fmt.Errorf("STARTTLS rechazado: %w", err)
|
|
}
|
|
}
|
|
}
|
|
defer cliente.Close()
|
|
|
|
if d.Usuario != "" {
|
|
if err := cliente.Auth(smtp.PlainAuth("", d.Usuario, d.Password, d.Host)); err != nil {
|
|
return fmt.Errorf("autenticación rechazada para %s: %w", d.Usuario, err)
|
|
}
|
|
}
|
|
if err := cliente.Mail(d.Desde); err != nil {
|
|
return fmt.Errorf("el servidor rechazó el remitente %s: %w", d.Desde, err)
|
|
}
|
|
if err := cliente.Rcpt(para); err != nil {
|
|
return fmt.Errorf("el servidor rechazó el destinatario %s: %w", para, err)
|
|
}
|
|
w, err := cliente.Data()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := w.Write(msg); err != nil {
|
|
return err
|
|
}
|
|
if err := w.Close(); err != nil {
|
|
return fmt.Errorf("el servidor rechazó el mensaje: %w", err)
|
|
}
|
|
return cliente.Quit()
|
|
}
|