lizandrogd/soft_usite
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(umind): el correo entra al agente por dos puertas distintas — y son distintas a propósito

Browse Source 
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>
This commit is contained in:
Lizandro Guarnizo
2026-08-23 20:08:46 -05:00
co-authored by Claude Opus 5
parent ffa24a068f
commit eddec45857
21 changed files with 987 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rest/controllers/umind_admin_controller.go
+26 -2
View File
@@ -563,6 +563,7 @@ func GetUmindCanalesHandler(c *fiber.Ctx) error {
"webhook_url": webhookURL, "ultimo_error": canal.UltimoError,
"usar_whisper_audio": canal.UsarWhisperAudio, "usar_ocr_imagenes": canal.UsarOcrImagenes,
"usar_archivos_docs": canal.UsarArchivosDocs,
"intervalo_minutos": canal.IntervaloMinutos,
}
}
return c.JSON(fiber.Map{"items": out})
@@ -576,6 +577,7 @@ type umindCanalReq struct {
UsarWhisperAudio bool `json:"usar_whisper_audio"`
UsarOcrImagenes bool `json:"usar_ocr_imagenes"`
UsarArchivosDocs bool `json:"usar_archivos_docs"`
IntervaloMinutos int `json:"intervalo_minutos"`
}
func CreateUmindCanalHandler(c *fiber.Ctx) error {
@@ -600,18 +602,40 @@ func CreateUmindCanalHandler(c *fiber.Ctx) error {
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": k + " requerido"})
}
}
case "correo":
for _, k := range []string{"imap_host", "smtp_host", "usuario", "password"} {
if strings.TrimSpace(req.Credenciales[k]) == "" {
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": k + " requerido"})
}
}
// Probar ANTES de guardar: un canal de correo con la contraseña mal no
// falla acá adelante sino en el cron, donde nadie lo está mirando.
cred := services.CredencialesIMAP{
Host: req.Credenciales["imap_host"], Usuario: req.Credenciales["usuario"],
Password: req.Credenciales["password"], Encriptado: req.Credenciales["imap_encriptado"],
}
fmt.Sscanf(req.Credenciales["imap_puerto"], "%d", &cred.Puerto)
if err := services.ProbarConexionIMAPGenerica(cred); err != nil {
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "la casilla rechazó la conexión: " + err.Error()})
}
default:
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "tipo debe ser telegram o whatsapp"})
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "tipo debe ser telegram, whatsapp o correo"})
}
credencialesEnc, err := services.CifrarCredencialesCanal(req.Credenciales)
if err != nil {
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
}
intervalo := req.IntervaloMinutos
if intervalo < 2 {
// Menos de 2 minutos es martillar el servidor de correo del cliente
// para ganar segundos que un correo no necesita.
intervalo = 5
}
canal := &models.UmindCanal{
AgenteID: req.AgenteID, Tipo: req.Tipo, Activo: true, CredencialesEnc: credencialesEnc,
UsarWhisperAudio: req.UsarWhisperAudio, UsarOcrImagenes: req.UsarOcrImagenes,
UsarArchivosDocs: req.UsarArchivosDocs,
UsarArchivosDocs: req.UsarArchivosDocs, IntervaloMinutos: intervalo,
}
if err := models.CreateUmindCanal(canal); err != nil {
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
rest/controllers/umind_conexion_imap_controller.go
+103
View File
@@ -0,0 +1,103 @@
package controllers
import (
"strconv"
"strings"
"github.com/gofiber/fiber/v2"
"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
"github.com/sujit-baniya/fiber-boilerplate/pkg/services"
)
// ─── Cuentas de correo IMAP (solo lectura) ───────────────────────────────────
//
// Viven en "Lo que sabe": el dueño le pide al agente "revisame los correos de
// hoy y resumime" y el agente consulta la casilla en ese momento — nada de
// fondo, nada de polling. Para que el agente RESPONDA correos está el canal
// de correo en "Dónde atiende", que es otra cosa y tiene otras guardas.
// CrearConexionImapHandler conecta una casilla por IMAP. Se prueba ANTES de
// guardar: una contraseña mal cargada tiene que fallar acá, con la persona
// mirando, y no después dentro de una conversación.
// POST /umind/conexiones/imap
func CrearConexionImapHandler(c *fiber.Ctx) error {
var req struct {
AgenteID uint `json:"agente_id"`
Email string `json:"email"`
Host string `json:"host"`
Puerto int `json:"puerto"`
Password string `json:"password"`
Encriptado string `json:"encriptado"`
}
if err := c.BodyParser(&req); err != nil {
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "body inválido"})
}
if _, err := accesoAgente(c, req.AgenteID); err != nil {
return err
}
email := strings.ToLower(strings.TrimSpace(req.Email))
if email == "" || !strings.Contains(email, "@") {
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "poné la dirección de la casilla, ej: ventas@tunegocio.com"})
}
if strings.TrimSpace(req.Password) == "" {
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "falta la contraseña de la casilla"})
}
// Sin host se prueba el clásico mail.<dominio>: en hosting común acierta
// casi siempre y el cliente no ve un solo campo técnico.
host := strings.TrimSpace(req.Host)
if host == "" {
host = "mail." + strings.SplitN(email, "@", 2)[1]
}
cred := services.CredencialesIMAP{
Host: host, Puerto: req.Puerto, Usuario: email,
Password: req.Password, Encriptado: req.Encriptado,
}
if err := services.ProbarConexionIMAPGenerica(cred); err != nil {
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
"error": "la casilla rechazó la conexión: " + err.Error() +
" — si tu correo es de Gmail u Outlook, usá los botones de conectar con Google/Microsoft",
})
}
enc, err := services.CifrarCredencialesIMAP(cred)
if err != nil {
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
}
conexion := &models.UmindConexion{
AgenteID: req.AgenteID, Proveedor: "imap", Email: email,
CredencialesEnc: enc, Activo: true,
}
if err := models.CreateUmindConexion(conexion); err != nil {
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": err.Error()})
}
return c.Status(fiber.StatusCreated).JSON(fiber.Map{"ok": true, "id": conexion.ID, "host": host})
}
// ProbarConexionImapAgenteHandler reconecta una cuenta ya guardada y dice si
// sigue andando — la contraseña pudo cambiar del lado del cliente.
// POST /umind/conexiones/:id/probar
func ProbarConexionImapAgenteHandler(c *fiber.Ctx) error {
id, err := strconv.ParseUint(c.Params("id"), 10, 64)
if err != nil {
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "id inválido"})
}
if err := accesoConexion(c, uint(id)); err != nil {
return err
}
conexion, err := models.GetUmindConexionByID(uint(id))
if err != nil {
return errSinAcceso(c)
}
if conexion.Proveedor != "imap" {
return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "esta cuenta es OAuth: se prueba sola al usarse"})
}
cred, err := services.DescifrarCredencialesIMAP(conexion.CredencialesEnc)
if err != nil {
return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "credenciales corruptas"})
}
if err := services.ProbarConexionIMAPGenerica(cred); err != nil {
return c.Status(fiber.StatusBadGateway).JSON(fiber.Map{"error": err.Error()})
}
return c.JSON(fiber.Map{"ok": true, "message": "La casilla responde bien"})
}
rest/routes/umind.go
+2
View File
@@ -65,6 +65,8 @@ func RegistrarRutasUmind(g fiber.Router, scope fiber.Handler, escritura fiber.Ha
g.Get("/umind/conexiones", r(controllers.GetUmindConexionesHandler)...)
g.Get("/umind/conexiones/conectar", w(controllers.UmindConectarHandler)...)
g.Post("/umind/conexiones/imap", w(controllers.CrearConexionImapHandler)...)
g.Post("/umind/conexiones/:id/probar", w(controllers.ProbarConexionImapAgenteHandler)...)
g.Delete("/umind/conexiones/:id", w(controllers.DeleteUmindConexionHandler)...)
g.Get("/umind/eventos", r(controllers.GetUmindEventosHandler)...)