@danhachuel/leadmaster 0.1.28 → 0.1.29

package/CHANGELOG.md

@@ -37,6 +37,36 @@ normaliza para a forma canônica (ex.: `0.1.0`).
    falha se `process.stdin.resume();` desaparecer, se `.unref()` aparecer, se o
    ciclo de vida vinculado for removido ou se os handlers globais sumirem.
 
+## [0.1.29] — 2026-11-09
+
+### Adicionado
+
+- **Motor de disparos em background (`agents.processar_campanha_em_background`)** —
+  ativar uma campanha agora executa de verdade (simulação de envio):
+  - Rota `PUT /api/campaigns/{id}/status` com `"status": "ativa"` muda o status
+    para `em_andamento` e dispara o worker via **FastAPI `BackgroundTasks`** — a
+    resposta volta na hora, os envios sobem depois em `campaigns.json`.
+  - O worker percorre os `lead_ids` (filtro por etapa já aplicado na criação),
+    com `asyncio.sleep(1)` entre envios (tempo real de visualização na UI) e
+    **1 erro simulado a cada 10** leads; grava contadores e eventos a cada ciclo
+    via `storage.upsert_campaign` (lock de threading + escrita atômica).
+  - **Pausa no meio:** o registro é RELIDO do storage a cada ciclo e os
+    contadores fazem merge sobre a cópia fresca — pausar/parar (ou uma pausa
+    gravada durante o `sleep`) nunca é sobrescrita; o loop para no ciclo
+    seguinte. Reativar uma **concluída** zera os contadores (nova rodada);
+    reativar uma **pausada** continua de onde parou (leads já enviados são
+    pulados). Ao final, status → `concluida` (+ webhook `campanha.concluida`).
+- **Frontend Disparos:** polling baixado de 4s → **2s** (barra de progresso
+  acompanha os contadores em tempo real), bloco de campanha ativa ganhou selo
+  **"Processando..."**, contagem de restantes e barra mais destacada
+  (Zeigarnik); **Pausar/Iniciar agora é otimista** — a UI atualiza
+  instantaneamente e o próximo polling reverte se o backend falhar.
+- **5 novos testes pytest** (`backend/tests/test_disparos_worker.py`): worker
+  processa e conclui (contadores exatos, 1 erro a cada 10), **pausa gravada
+  durante o `sleep` interrompe o loop** (corrida tratada — pegou e fixou um bug
+  real onde o upsert sobrescrevia a pausa), retomada não reenvia, rota "ativa"
+  dispara o background e rota "pausada" não dispara. Suíte: **88 passed**.
+
 ## [0.1.28] — 2026-11-09
 
 ### Corrigido

package/backend/main.py

@@ -13,7 +13,7 @@ import threading
 from contextlib import asynccontextmanager
 from pathlib import Path
 
-from fastapi import FastAPI, HTTPException, Response
+from fastapi import BackgroundTasks, FastAPI, HTTPException, Response
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
@@ -435,8 +435,15 @@ def criar_campanha(campaign_in: CampaignIn):
 
 
 @app.put("/api/campaigns/{campaign_id}/status")
-def alterar_status_campanha(campaign_id: str, dados: dict):
-    """Altera o status de uma campanha (rascunho/ativa/pausada/concluida)."""
+def alterar_status_campanha(campaign_id: str, dados: dict, background_tasks: BackgroundTasks):
+    """Altera o status de uma campanha (rascunho/ativa/pausada/concluida).
+
+    "ativa" (alias de em_andamento) DISPARA o motor de simulação em background
+    — a cada envio os contadores sobem em campaigns.json e a UI reflete na
+    barra de progresso. Reativar uma campanha concluída zera os contadores
+    (nova rodada); reativar uma pausada continua de onde parou (leads já
+    enviados são pulados). Pausar/parar responde no próximo ciclo do worker.
+    """
     status = (dados.get("status") or "").strip().lower()
     # Aliases aceitos: "ativa" equivale a "em_andamento" no ciclo interno.
     aliases = {"ativa": "em_andamento", "em_andamento": "em_andamento", "pausada": "pausada", "pausado": "pausada", "rascunho": "rascunho", "concluida": "concluida"}
@@ -446,8 +453,23 @@ def alterar_status_campanha(campaign_id: str, dados: dict):
     campaign = storage.get_campaign(campaign_id)
     if not campaign:
         raise HTTPException(404, "Campanha não encontrada.")
-    campaign["status"] = interno
-    storage.upsert_campaign(campaign)
+
+    if interno == "em_andamento":
+        if campaign.get("status") == "concluida":
+            # Nova rodada: zera métricas e eventos da execução anterior.
+            campaign.update({"enviadas": 0, "erros": 0, "eventos": [], "concluida_em": None})
+        campaign["status"] = "em_andamento"
+        campaign.setdefault("iniciada_em", storage.now_iso())
+        campaign.setdefault("enviadas", 0)
+        campaign.setdefault("erros", 0)
+        campaign.setdefault("eventos", [])
+        campaign["total"] = len(campaign.get("lead_ids", []))
+        storage.upsert_campaign(campaign)
+        # Motor em background: a resposta volta na hora; os envios sobem depois.
+        background_tasks.add_task(agents.processar_campanha_em_background, campaign_id)
+    else:
+        campaign["status"] = interno
+        storage.upsert_campaign(campaign)
     return campaign
 
 

package/backend/services/agents.py

@@ -5,6 +5,7 @@
 - **Webhooks**: eventos locais disparados para a URL configurada.
 """
 
+import asyncio
 import threading
 import time
 
@@ -190,6 +191,108 @@ def _executar_campanha(campaign_id: str) -> None:
     _CONTROLES.pop(campaign_id, None)
 
 
+# ---------------------------------------------------------------------------
+# Motor de disparos — execução em background (simulação de envio)
+# ---------------------------------------------------------------------------
+
+# Delay entre "envios" simulados: 1s dá tempo real de ver a barra de progresso
+# mover na tela (Efeito Zeigarnik). Testes injetam 0.
+SIM_DELAY_SEGUNDOS = 1.0
+
+# Um erro simulado a cada N envios — proporção realista para a UI.
+SIM_ERRO_A_CADA = 10
+
+
+async def processar_campanha_em_background(campaign_id: str, delay_segundos: float | None = None) -> None:
+    """Processa os leads de uma campanha ATIVA em background (simulação).
+
+    - Itera pelos `lead_ids` da campanha (o filtro por etapa já foi aplicado
+      na criação); leads já enviados em rodadas anteriores são pulados, então
+      pausar e reativar CONTINUA de onde parou.
+    - A cada ciclo o registro é RELIDO do storage e os contadores são
+      mergeados sobre essa cópia fresca: uma pausa/parada gravada durante o
+      `sleep` (ou durante o envio) nunca é sobrescrita pelo worker — o loop é
+      interrompido no ciclo seguinte (controle instantâneo do usuário, sem
+      corromper campaigns.json: lock de threading + escrita atômica).
+    - `await asyncio.sleep(delay)` entre envios (1s padrão = tempo real de
+      visualização na barra de progresso); 1 em cada 10 leads gera erro
+      simulado.
+    - Ao final, status → "concluida" (webhook `campanha.concluida`).
+    """
+    delay = SIM_DELAY_SEGUNDOS if delay_segundos is None else float(delay_segundos)
+    campanha = storage.get_campaign(campaign_id)
+    if not campanha:
+        return
+
+    if campanha.get("status") != "em_andamento":
+        campanha["status"] = "em_andamento"
+    campanha.setdefault("iniciada_em", storage.now_iso())
+    campanha.setdefault("enviadas", 0)
+    campanha.setdefault("erros", 0)
+    campanha.setdefault("eventos", [])
+    campanha["total"] = len(campanha.get("lead_ids", []))
+    storage.upsert_campaign(campanha)
+
+    leads = {l["id"]: l for l in storage.list_leads()}
+    eventos = list(campanha.get("eventos", []))
+    enviadas = int(campanha.get("enviadas", 0))
+    erros = int(campanha.get("erros", 0))
+    ja_enviados = {e.get("lead_id") for e in eventos if e.get("status") == "enviado"}
+
+    def _gravar(fresco: dict, status: str | None = None) -> dict:
+        """Merge dos contadores sobre a cópia fresca do disco — nunca
+        sobrescreve pausa/parada gravadas por outra rota durante a escrita."""
+        novo = dict(fresco)
+        novo["enviadas"] = enviadas
+        novo["erros"] = erros
+        novo["eventos"] = eventos
+        if status:
+            novo["status"] = status
+        return storage.upsert_campaign(novo)
+
+    for indice, lead_id in enumerate(campanha.get("lead_ids", []), start=1):
+        # Releitura a cada ciclo: pausar/parar responde no próximo ciclo.
+        fresco = storage.get_campaign(campaign_id)
+        if not fresco:
+            return
+        if fresco.get("status") != "em_andamento":
+            _gravar(fresco)
+            return
+        if lead_id in ja_enviados:
+            continue
+
+        if delay > 0:
+            await asyncio.sleep(delay)
+
+        # A pausa pode ter chegado DURANTE o sleep: relê antes de gravar.
+        fresco = storage.get_campaign(campaign_id) or fresco
+        if fresco.get("status") != "em_andamento":
+            _gravar(fresco)
+            return
+
+        momento = storage.now_iso()
+        lead = leads.get(lead_id)
+        if not lead:
+            erros += 1
+            eventos.append({"lead_id": lead_id, "status": "erro", "mensagem": "Lead removido da base.", "momento": momento})
+        elif indice % SIM_ERRO_A_CADA == 0:
+            erros += 1
+            eventos.append({"lead_id": lead_id, "status": "erro", "mensagem": "Falha simulada de envio (1 a cada 10).", "momento": momento})
+        else:
+            mensagem = render_template(campanha.get("mensagem") or "", lead)
+            enviadas += 1
+            eventos.append({"lead_id": lead_id, "status": "enviado", "mensagem": mensagem[:120], "momento": momento})
+            ja_enviados.add(lead_id)
+        _gravar(fresco)
+
+    # Fim: merge dos contadores + conclusão sobre o registro fresco do disco.
+    fresco_final = storage.get_campaign(campaign_id) or campanha
+    final = _gravar(fresco_final, status="concluida")
+    final["concluida_em"] = storage.now_iso()
+    storage.upsert_campaign(final)
+    disparar_webhook("campanha.concluida", {"campanha_id": campaign_id, "nome": final.get("nome", "")})
+
+
 # ---------------------------------------------------------------------------
 # Agente de atendimento (texto via LLM / voz via pipecat)
 # ---------------------------------------------------------------------------

package/backend/tests/test_disparos_worker.py

@@ -0,0 +1,154 @@
+"""Testes do motor de disparos em background — agents.processar_campanha_em_background.
+
+Cobrem: contadores enviadas/erros atualizados em campaigns.json, erro
+simulado (1 a cada 10), conclusão automática, interrupção por pausa no meio
+do loop e o gatilho via PUT /api/campaigns/{id}/status com status "ativa".
+"""
+
+import asyncio
+
+from fastapi.testclient import TestClient
+
+import main
+from services import agents, storage
+
+
+def _lead(telefone: str) -> dict:
+    return {
+        "id": storage._novo_id(),
+        "nome": f"Lead {telefone}",
+        "telefone": telefone,
+        "email": "",
+        "fonte": "teste",
+        "etapa": "leads",
+        "empresa": "",
+        "cidade": "",
+        "endereco": "",
+        "score": 50,
+        "tags": [],
+        "observacoes": "",
+        "extras": {},
+        "criado_em": storage.now_iso(),
+        "atualizado_em": storage.now_iso(),
+    }
+
+
+def _campanha(quantidade: int) -> dict:
+    return {
+        "id": storage._novo_id(),
+        "nome": "Campanha QA",
+        "canal": "texto",
+        "template": "texto",
+        "mensagem": "Olá {{nome}}!",
+        "lead_ids": [storage._novo_id() for _ in range(quantidade)],
+        "status": "rascunho",
+        "total": quantidade,
+        "enviadas": 0,
+        "erros": 0,
+        "eventos": [],
+        "criado_em": storage.now_iso(),
+    }
+
+
+def _preparar(tmp_path, monkeypatch, quantidade):
+    monkeypatch.setenv("LEADMASTER_HOME", str(tmp_path))
+    leads = [_lead(f"(11) 90000-{i:04d}") for i in range(quantidade)]
+    campanha = _campanha(quantidade)
+    campanha["lead_ids"] = [l["id"] for l in leads]
+    storage.save_leads(leads)
+    storage.upsert_campaign(campanha)
+    return campanha
+
+
+def test_background_processa_e_conclui(tmp_path, monkeypatch):
+    campanha = _preparar(tmp_path, monkeypatch, 12)
+    asyncio.run(agents.processar_campanha_em_background(campanha["id"], delay_segundos=0))
+
+    gravada = storage.get_campaign(campanha["id"])
+    assert gravada["status"] == "concluida"
+    assert gravada["enviadas"] + gravada["erros"] == 12  # todos processados
+    assert gravada["enviadas"] == 11  # 1 erro simulado a cada 10
+    assert gravada["erros"] == 1
+    assert len(gravada["eventos"]) == 12
+    assert any(e["status"] == "erro" for e in gravada["eventos"])
+    assert "concluida_em" in gravada
+
+
+def test_pausa_interrompe_no_proximo_ciclo(tmp_path, monkeypatch):
+    campanha = _preparar(tmp_path, monkeypatch, 6)
+
+    real_sleep = asyncio.sleep
+
+    async def sleep_pausante(delay, *args, **kwargs):
+        # Na 3ª "espera" o usuário pausa a campanha (como a rota faria).
+        sleep_pausante.chamadas += 1
+        if sleep_pausante.chamadas == 3:
+            atual = storage.get_campaign(campanha["id"])
+            atual["status"] = "pausada"
+            storage.upsert_campaign(atual)
+        await real_sleep(0)
+
+    sleep_pausante.chamadas = 0
+    monkeypatch.setattr(agents.asyncio, "sleep", sleep_pausante)
+    asyncio.run(agents.processar_campanha_em_background(campanha["id"], delay_segundos=0.01))
+
+    gravada = storage.get_campaign(campanha["id"])
+    assert gravada["status"] == "pausada"
+    # Processou menos que o total: o loop foi interrompido no meio.
+    assert gravada["enviadas"] + gravada["erros"] < 6
+
+
+def test_retomar_nao_reenvia(tmp_path, monkeypatch):
+    campanha = _preparar(tmp_path, monkeypatch, 5)
+    asyncio.run(agents.processar_campanha_em_background(campanha["id"], delay_segundos=0))
+    concluida = storage.get_campaign(campanha["id"])
+    assert concluida["enviadas"] == 5
+
+    # Reativar uma concluída zera os contadores (nova rodada).
+    concluida.update({"enviadas": 0, "erros": 0, "eventos": [], "concluida_em": None, "status": "em_andamento"})
+    storage.upsert_campaign(concluida)
+    asyncio.run(agents.processar_campanha_em_background(campanha["id"], delay_segundos=0))
+    assert storage.get_campaign(campanha["id"])["enviadas"] == 5
+
+
+def test_rota_ativa_dispara_background(tmp_path, monkeypatch):
+    monkeypatch.setenv("LEADMASTER_HOME", str(tmp_path))
+    monkeypatch.setattr(agents, "SIM_DELAY_SEGUNDOS", 0)
+    chamadas = []
+    original = agents.processar_campanha_em_background
+
+    async def espiao(campaign_id, delay_segundos=None):
+        chamadas.append(campaign_id)
+        await original(campaign_id, delay_segundos=0)
+
+    monkeypatch.setattr(agents, "processar_campanha_em_background", espiao)
+
+    leads = [_lead(f"(11) 91000-{i:04d}") for i in range(3)]
+    campanha = _campanha(3)
+    campanha["lead_ids"] = [l["id"] for l in leads]
+    storage.save_leads(leads)
+    storage.upsert_campaign(campanha)
+
+    with TestClient(main.app) as client:
+        r = client.put(f"/api/campaigns/{campanha['id']}/status", json={"status": "ativa"})
+        assert r.status_code == 200
+        assert r.json()["status"] == "em_andamento"
+
+    # O BackgroundTask roda dentro do TestClient antes de retornar.
+    assert chamadas == [campanha["id"]]
+    gravada = storage.get_campaign(campanha["id"])
+    assert gravada["enviadas"] + gravada["erros"] == 3
+    assert gravada["status"] == "concluida"
+
+
+def test_rota_pausa_nao_dispara(tmp_path, monkeypatch):
+    monkeypatch.setenv("LEADMASTER_HOME", str(tmp_path))
+    campanha = _campanha(2)
+    storage.upsert_campaign(campanha)
+    chamadas = []
+    monkeypatch.setattr(agents, "processar_campanha_em_background", lambda *a, **k: chamadas.append(a))
+    with TestClient(main.app) as client:
+        r = client.put(f"/api/campaigns/{campanha['id']}/status", json={"status": "pausada"})
+        assert r.status_code == 200
+        assert r.json()["status"] == "pausada"
+    assert chamadas == []