API robusta + Transformers + front + fix Turso

.env.example

@@ -74,12 +74,26 @@ ENABLE_AI_INTERPRETATION=true
 REPORT_TIMEZONE=America/Sao_Paulo
 REPORT_RECIPIENT_EMAIL=
 
-# ---------------------- SMTP (opcional) --------------------
+# ---------------------- E-mail: SMTP (uso local) -----------
+# Funciona localmente. Em Hugging Face Spaces o SMTP é BLOQUEADO — use a
+# Gmail API (abaixo), que envia por HTTPS.
 SMTP_HOST=
 SMTP_PORT=
 SMTP_USER=
 SMTP_PASSWORD=
 
+# ------------- E-mail: Gmail API (HTTP/OAuth) --------------
+# Preferido em produção/online (passa por firewalls que bloqueiam SMTP).
+# Como obter o refresh token: Google Cloud Console -> ativar "Gmail API" ->
+# criar credencial OAuth -> no OAuth Playground (https://developers.google.com/oauthplayground)
+# usar suas credenciais e autorizar o escopo
+# https://www.googleapis.com/auth/gmail.send -> trocar pelo refresh token.
+GMAIL_CLIENT_ID=
+GMAIL_CLIENT_SECRET=
+GMAIL_REFRESH_TOKEN=
+# E-mail remetente (a conta autorizada no OAuth acima).
+GMAIL_SENDER=
+
 # --------------------- ClickUp (opcional) ------------------
 CLICKUP_API_TOKEN=
 CLICKUP_LIST_ID=

scripts/test_gmail_oauth.py

@@ -0,0 +1,101 @@
+"""Testa o envio de e-mail via Gmail API (OAuth refresh token).
+
+Valida as credenciais antes do deploy. Envia um e-mail curto de teste.
+
+Uso:
+    python scripts/test_gmail_oauth.py
+
+Variáveis necessárias no .env:
+    GMAIL_CLIENT_ID, GMAIL_CLIENT_SECRET, GMAIL_REFRESH_TOKEN,
+    GMAIL_SENDER (remetente autorizado), REPORT_RECIPIENT_EMAIL (destinatário).
+
+Não imprime tokens nem segredos.
+"""
+
+import base64
+import os
+from email.mime.text import MIMEText
+
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+CLIENT_ID = os.getenv("GMAIL_CLIENT_ID", "")
+CLIENT_SECRET = os.getenv("GMAIL_CLIENT_SECRET", "")
+REFRESH_TOKEN = os.getenv("GMAIL_REFRESH_TOKEN", "")
+SENDER = os.getenv("GMAIL_SENDER", "")
+RECIPIENT = os.getenv("REPORT_RECIPIENT_EMAIL", "")
+
+
+def validar() -> None:
+    """Confere se as variáveis obrigatórias estão preenchidas."""
+    faltando = [
+        nome
+        for nome, valor in {
+            "GMAIL_CLIENT_ID": CLIENT_ID,
+            "GMAIL_CLIENT_SECRET": CLIENT_SECRET,
+            "GMAIL_REFRESH_TOKEN": REFRESH_TOKEN,
+            "GMAIL_SENDER": SENDER,
+            "REPORT_RECIPIENT_EMAIL": RECIPIENT,
+        }.items()
+        if not valor
+    ]
+    if faltando:
+        raise SystemExit(f"Variáveis ausentes no .env: {', '.join(faltando)}")
+
+
+def obter_access_token() -> str:
+    """Troca o refresh token por um access token (sem imprimir segredos)."""
+    resp = requests.post(
+        "https://oauth2.googleapis.com/token",
+        data={
+            "grant_type": "refresh_token",
+            "client_id": CLIENT_ID,
+            "client_secret": CLIENT_SECRET,
+            "refresh_token": REFRESH_TOKEN,
+        },
+        timeout=30,
+    )
+    if resp.status_code != 200:
+        try:
+            erro = resp.json()
+            detalhe = f"{erro.get('error')} - {erro.get('error_description', '')}"
+        except ValueError:
+            detalhe = "resposta inválida do servidor OAuth."
+        print("Falha no OAuth do Google. Status:", resp.status_code, "-", detalhe.strip(" -"))
+        raise SystemExit(1)
+    return resp.json()["access_token"]
+
+
+def main() -> None:
+    """Executa o teste de envio."""
+    validar()
+    print("Obtendo access token do Google...")
+    token = obter_access_token()
+    print("Access token obtido com sucesso.")
+
+    mensagem = MIMEText(
+        "Teste de envio do Analytical-Force via Gmail API. Se você recebeu, está funcionando.",
+        "plain",
+        "utf-8",
+    )
+    mensagem["Subject"] = "Analytical-Force — Teste Gmail API"
+    mensagem["From"] = SENDER
+    mensagem["To"] = RECIPIENT
+    raw = base64.urlsafe_b64encode(mensagem.as_bytes()).decode("utf-8")
+
+    resp = requests.post(
+        "https://gmail.googleapis.com/gmail/v1/users/me/messages/send",
+        headers={"Authorization": f"Bearer {token}"},
+        json={"raw": raw},
+        timeout=30,
+    )
+    if resp.status_code >= 400:
+        print("Falha ao enviar. Status:", resp.status_code, "-", resp.text[:300])
+        raise SystemExit(1)
+    print(f"E-mail de teste enviado com sucesso para {RECIPIENT}.")
+
+
+if __name__ == "__main__":
+    main()

src/config/settings.py

@@ -251,12 +251,33 @@ class EmailSettings:
     smtp_user: str = ""
     smtp_password: str = ""
     recipient_email: str = ""
+    # Gmail API (HTTP/OAuth) — envia por HTTPS, funcionando onde o SMTP é
+    # bloqueado (ex.: Hugging Face Spaces). Preferido quando configurado.
+    gmail_client_id: str = ""
+    gmail_client_secret: str = ""
+    gmail_refresh_token: str = ""
+    gmail_sender: str = ""
 
     @property
-    def is_configured(self) -> bool:
-        """Indica se há dados mínimos para enviar e-mail via SMTP."""
+    def gmail_api_configured(self) -> bool:
+        """Indica se há credenciais para enviar via Gmail API (HTTP)."""
+        return bool(
+            self.gmail_client_id
+            and self.gmail_client_secret
+            and self.gmail_refresh_token
+            and self.recipient_email
+        )
+
+    @property
+    def smtp_configured(self) -> bool:
+        """Indica se há dados mínimos para enviar via SMTP."""
         return bool(self.smtp_host and self.smtp_port and self.recipient_email)
 
+    @property
+    def is_configured(self) -> bool:
+        """Indica se há ALGUM método de envio configurado (Gmail API ou SMTP)."""
+        return self.gmail_api_configured or self.smtp_configured
+
 
 @dataclass(frozen=True)
 class ClickUpSettings:
@@ -592,6 +613,10 @@ def get_settings() -> Settings:
         smtp_user=_get_str("SMTP_USER"),
         smtp_password=_get_str("SMTP_PASSWORD"),
         recipient_email=_get_str("REPORT_RECIPIENT_EMAIL"),
+        gmail_client_id=_get_str("GMAIL_CLIENT_ID"),
+        gmail_client_secret=_get_str("GMAIL_CLIENT_SECRET"),
+        gmail_refresh_token=_get_str("GMAIL_REFRESH_TOKEN"),
+        gmail_sender=_get_str("GMAIL_SENDER"),
     )
 
     clickup = ClickUpSettings(

src/delivery/clickup_sender.py

@@ -34,6 +34,25 @@ def _link_salesforce(instance_url: str | None, record_id: str | None) -> str | N
     return f"{instance_url.rstrip('/')}/{record_id}"
 
 
+def _detalhe_erro_clickup(exc: Exception) -> str:
+    """Extrai status + mensagem do erro do ClickUp, para diagnóstico (sem segredos).
+
+    A resposta de erro do ClickUp traz campos como ``err`` e ``ECODE`` — úteis
+    para entender a recusa (token, lista, assignee, etc.).
+    """
+    resp = getattr(exc, "response", None)
+    if resp is not None:
+        try:
+            corpo = resp.json()
+            msg = corpo.get("err") or corpo.get("error") or ""
+            ecode = corpo.get("ECODE", "")
+            return f"HTTP {resp.status_code} {ecode}: {msg}".strip()
+        except Exception:
+            texto = str(getattr(resp, "text", ""))[:300]
+            return f"HTTP {getattr(resp, 'status_code', '?')}: {texto}"
+    return f"{type(exc).__name__}: {exc}"
+
+
 def _moeda(valor: Any) -> str:
     """Formata um número como moeda em Real (R$ 1.234,56)."""
     try:
@@ -211,11 +230,13 @@ def criar_tarefas_de_alertas(
 
     for alerta in criticos:
         severidade = alerta.get("severity", "high")
+        markdown = _descricao_markdown(alerta, instance_url, report_date)
         corpo: dict[str, Any] = {
             "name": f"[Analytical-Force] {alerta.get('title', 'Alerta crítico')}",
-            "markdown_description": _descricao_markdown(
-                alerta, instance_url, report_date
-            ),
+            # ClickUp usa 'markdown_content' para a descrição em Markdown;
+            # mantemos 'description' como texto simples de fallback.
+            "description": str(alerta.get("description") or alerta.get("title", "")),
+            "markdown_content": markdown,
             "priority": _PRIORIDADE_SEVERIDADE.get(severidade, 1),
         }
         if assignees:
@@ -232,7 +253,8 @@ def criar_tarefas_de_alertas(
             except Exception:  # resposta sem JSON não deve quebrar o fluxo
                 pass
         except Exception as exc:  # não derruba o agente
-            logger.error("Falha ao criar tarefa no ClickUp: %s", type(exc).__name__)
+            # Surface do motivo real do ClickUp (status + mensagem), sem segredos.
+            logger.error("Falha ao criar tarefa no ClickUp: %s", _detalhe_erro_clickup(exc))
 
     logger.info("Tarefas criadas no ClickUp: %d.", criadas)
     return criadas

src/delivery/email_sender.py

@@ -8,11 +8,14 @@ retorna ``False``.
 
 from __future__ import annotations
 
+import base64
 import smtplib
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from typing import Any
 
+import requests
+
 from ..config.settings import EmailSettings
 from ..utils.logger import get_logger
 
@@ -265,10 +268,13 @@ def enviar_relatorio_email(
     metrics: dict[str, Any],
     alerts: list[dict[str, Any]],
 ) -> bool:
-    """Envia o relatório executivo por e-mail, se o SMTP estiver configurado.
+    """Envia o relatório executivo por e-mail.
+
+    Prefere a **Gmail API (HTTP)** quando configurada — funciona em ambientes
+    que bloqueiam SMTP (ex.: Hugging Face Spaces). Caso contrário, usa SMTP.
 
     Args:
-        config: Configurações de SMTP/destinatário.
+        config: Configurações de e-mail (Gmail API e/ou SMTP).
         assunto: Assunto do e-mail.
         report_date: Data de referência do relatório (texto).
         metrics: Métricas calculadas (leads/opportunities/tasks/...).
@@ -278,19 +284,28 @@ def enviar_relatorio_email(
         ``True`` se enviado; ``False`` se não configurado ou em caso de erro.
     """
     if not config.is_configured:
-        logger.info("Envio de e-mail ignorado: SMTP não configurado.")
+        logger.info("Envio de e-mail ignorado: nenhum método configurado.")
         return False
 
     html = _montar_html(report_date, metrics, alerts)
     texto = _montar_texto(report_date, metrics, alerts)
 
+    remetente = config.gmail_sender or config.smtp_user or "analytical-force@localhost"
     mensagem = MIMEMultipart("alternative")
     mensagem["Subject"] = assunto
-    mensagem["From"] = config.smtp_user or "analytical-force@localhost"
+    mensagem["From"] = remetente
     mensagem["To"] = config.recipient_email
     mensagem.attach(MIMEText(texto, "plain", "utf-8"))
     mensagem.attach(MIMEText(html, "html", "utf-8"))
 
+    # Gmail API tem prioridade (HTTPS; passa por firewalls que bloqueiam SMTP).
+    if config.gmail_api_configured:
+        return _enviar_via_gmail_api(config, mensagem)
+    return _enviar_via_smtp(config, mensagem)
+
+
+def _enviar_via_smtp(config: EmailSettings, mensagem: MIMEMultipart) -> bool:
+    """Envia a mensagem via SMTP (STARTTLS). Usado em ambiente local."""
     try:
         with smtplib.SMTP(config.smtp_host, config.smtp_port, timeout=30) as servidor:
             servidor.starttls()
@@ -299,9 +314,57 @@ def enviar_relatorio_email(
             servidor.sendmail(
                 mensagem["From"], [config.recipient_email], mensagem.as_string()
             )
-        logger.info("Relatório enviado por e-mail para %s.", config.recipient_email)
+        logger.info("Relatório enviado por e-mail (SMTP) para %s.", config.recipient_email)
+        return True
+    except Exception as exc:  # não deve derrubar o agente
+        # Surface do tipo de erro (sem expor senha). OSError costuma indicar
+        # SMTP bloqueado pelo ambiente (ex.: Hugging Face) — use a Gmail API.
+        logger.error("Falha ao enviar e-mail (SMTP): %s", type(exc).__name__)
+        return False
+
+
+def _obter_access_token_gmail(config: EmailSettings) -> str:
+    """Obtém um access_token do Google via refresh_token (OAuth).
+
+    Não registra o token nem o payload (contêm segredos).
+    """
+    resposta = requests.post(
+        "https://oauth2.googleapis.com/token",
+        data={
+            "grant_type": "refresh_token",
+            "client_id": config.gmail_client_id,
+            "client_secret": config.gmail_client_secret,
+            "refresh_token": config.gmail_refresh_token,
+        },
+        timeout=30,
+    )
+    if resposta.status_code != 200:
+        try:
+            erro = resposta.json()
+            detalhe = f"{erro.get('error')} - {erro.get('error_description', '')}".strip(" -")
+        except ValueError:
+            detalhe = "resposta inválida do servidor OAuth do Google."
+        raise RuntimeError(f"OAuth Google falhou (status {resposta.status_code}): {detalhe}")
+    return resposta.json()["access_token"]
+
+
+def _enviar_via_gmail_api(config: EmailSettings, mensagem: MIMEMultipart) -> bool:
+    """Envia a mensagem usando a Gmail API (HTTP), via OAuth refresh token."""
+    try:
+        token = _obter_access_token_gmail(config)
+        raw = base64.urlsafe_b64encode(mensagem.as_bytes()).decode("utf-8")
+        resposta = requests.post(
+            "https://gmail.googleapis.com/gmail/v1/users/me/messages/send",
+            headers={"Authorization": f"Bearer {token}"},
+            json={"raw": raw},
+            timeout=30,
+        )
+        resposta.raise_for_status()
+        logger.info(
+            "Relatório enviado por e-mail (Gmail API) para %s.", config.recipient_email
+        )
         return True
     except Exception as exc:  # não deve derrubar o agente
-        # Surface do tipo de erro para diagnóstico (sem expor senha).
-        logger.error("Falha ao enviar e-mail: %s", type(exc).__name__)
+        # Surface do tipo de erro, sem expor token.
+        logger.error("Falha ao enviar e-mail (Gmail API): %s", type(exc).__name__)
         return False