@danhachuel/leadmaster 0.1.21 → 0.1.23

package/CHANGELOG.md

@@ -37,6 +37,53 @@ 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.23] — 2026-11-09
+
+### Adicionado
+
+- **Extratores conectados de verdade (fim da dependência de mock quando
+  configurado):**
+  - **Google Maps:** executa o binário real (`gosom/google-maps-scraper`) com as
+    flags de isolamento (`creationflags`, sem janelas de CMD) e **timeout de
+    segurança configurável** (`timeout_maps_segundos`, padrão 300s).
+  - **Instagram:** passa **URL + limite** ao CLI (`igmapper_args` agora inclui
+    `{limit}`) com timeout configurável (`timeout_instagram_segundos`, padrão
+    120s).
+  - **CNPJ:** URL base da **BrasilAPI** vem do `config.json`
+    (`cnpj_api_url`) — permite trocar o provedor sem alterar código.
+  - **Regra de erro:** scraper **configurado** que falha (código ≠ 0, timeout,
+    executável inválido) retorna **HTTP 500 com mensagem clara** e **não salva
+    nada** (sem mock disfarçado, sem dados parciais). Sem scraper configurado,
+    o modo mock segue protegendo os primeiros testes.
+  - Ferramentas → Extratores ganhou os campos **URL base da BrasilAPI** e
+    **timeouts de segurança** (Maps/Instagram).
+- **4 novos testes pytest** (`backend/tests/test_extractors_real.py`): scraper
+  configurado falhando → 500 sem salvar, timeout → 500 "Timeout na extração",
+  falha do igmapper → 500 sem salvar, e mock preservado sem configuração.
+
+## [0.1.22] — 2026-11-09
+
+### Adicionado
+
+- **Funil de Prospecção (visão macro de conversão):**
+  - Rota `GET /api/funnel`: conta os leads por etapa do CRM (`Leads → Em
+    Contato → Proposta → Fechado`), calcula a taxa de conversão de cada
+    transição (`para/de × 100`, 1 decimal) e a queda percentual, e identifica
+    o **gargalo** — a etapa *origem* da maior queda (onde os leads param).
+    Resposta: `{etapas, conversoes, gargalo}`.
+  - Página `frontend/src/pages/Funil.tsx` (rota `/funil`, link **"Funil de
+    Prospecção"** no menu): **funil em CSS puro** com fatias de largura
+    decrescente (nome + quantidade por etapa), **cards de conversão** por
+    transição (verde ≥50%, âmbar ≥25%, vermelho abaixo), **alerta de gargalo**
+    em vermelho/laranja com "⚠️ Gargalo: muitos leads param em 'X'" e fatia
+    do gargalo destacada (von Restorff), zero filtros na tela (Lei de Hick) e
+    funil vazio com barra zerada + "Comece a prospectar para ver seu funil"
+    (Zeigarnik). Acesso aos dados via `api.funil()` no cliente padronizado.
+- **4 novos testes pytest** (`backend/tests/test_funnel_routes.py`):
+  conversões + gargalo com distribuição [10,5,2,1] (taxas 50/40/50 → gargalo
+    "Em Contato"), gargalo na primeira etapa, funil vazio (taxas `null`,
+    gargalo `null`) e funil sem gargalo (quedas zero).
+
 ## [0.1.21] — 2026-11-09
 
 ### Adicionado

package/backend/main.py

@@ -430,15 +430,16 @@ def extrair_instagram_endpoint(dados: InstagramExtractIn):
     leads: list = []
 
     if cli and Path(cli).exists():
+        # Scraper REAL configurado: executa e propaga erro amigavel (HTTP 500) se
+        # falhar — nunca salvamos dados parciais/corrompidos.
         try:
-            resultado = extractors.extrair_instagram(dados.profile_url)
+            resultado = extractors.extrair_instagram(dados.profile_url, dados.limit)
             leads = resultado.get("leads", [])
-            if leads:
-                origem = "cli"
-            else:
-                aviso = "O igmapper rodou mas não retornou leads — usando dados mockados."
-        except (extractors.ExtratorNaoConfigurado, extractors.ExtratorErro) as e:
-            aviso = f"igmapper indisponível ({e}); usando dados mockados."
+            origem = "cli"
+        except extractors.ExtratorNaoConfigurado as e:
+            raise HTTPException(500, f"Scraper nao configurado corretamente: {e}")
+        except extractors.ExtratorErro as e:
+            raise HTTPException(500, str(e))
 
     if not leads:
         leads = extractors.gerar_mock_instagram(dados.profile_url, dados.limit)
@@ -513,15 +514,16 @@ def extrair_maps(dados: MapsExtractIn):
     leads: list = []
 
     if cli and Path(cli).exists():
+        # Scraper REAL configurado: executa e propaga erro amigavel (HTTP 500)
+        # se falhar — nunca salvamos dados parciais/corrompidos.
         try:
             resultado = extractors.extrair_google_maps(dados.keyword, dados.location, max_resultados)
             leads = resultado.get("leads", [])
-            if leads:
-                origem = "cli"
-            else:
-                aviso = "O scraper rodou mas não retornou leads — usando dados mockados."
-        except (extractors.ExtratorNaoConfigurado, extractors.ExtratorErro) as e:
-            aviso = f"Scraper indisponível ({e}); usando dados mockados."
+            origem = "cli"
+        except extractors.ExtratorNaoConfigurado as e:
+            raise HTTPException(500, f"Scraper nao configurado corretamente: {e}")
+        except extractors.ExtratorErro as e:
+            raise HTTPException(500, str(e))
 
     if not leads:
         leads = extractors.gerar_mock_maps(dados.keyword, dados.location, dados.limit)
@@ -602,6 +604,41 @@ def salvar_prompt_agente(agent_id: str, dados: dict):
     return {"ok": True, "agent_id": agent_id, "prompt": agente["prompt"]}
 
 
+# ---------------------------------------------------------------------------
+# Funil de Prospecção (métricas de conversão do CRM)
+# ---------------------------------------------------------------------------
+
+ETAPAS_FUNIL = ["Leads", "Em Contato", "Proposta", "Fechado"]
+
+
+@app.get("/api/funnel")
+def funil_prospeccao():
+    """Métricas de conversão do funil, calculadas a partir do leads.json."""
+    leads = storage.list_leads()
+    quantidades = [
+        sum(1 for l in leads if l.get("etapa") == etapa)
+        for etapa in ("leads", "em_contato", "proposta", "fechado")
+    ]
+    etapas = [{"nome": nome, "quantidade": qtd} for nome, qtd in zip(ETAPAS_FUNIL, quantidades)]
+
+    conversoes = []
+    for i in range(len(ETAPAS_FUNIL) - 1):
+        de, para = ETAPAS_FUNIL[i], ETAPAS_FUNIL[i + 1]
+        if quantidades[i] > 0:
+            taxa = round(quantidades[i + 1] / quantidades[i] * 100, 1)
+            queda = round(100 - taxa, 1)
+        else:
+            taxa, queda = None, None
+        conversoes.append({"de": de, "para": para, "taxa": taxa, "queda": queda})
+
+    # Gargalo: etapa ORIGEM da maior queda entre etapas consecutivas — é onde os
+    # leads param (ex.: muitos entram em "Em Contato" e não seguem).
+    quedas = [c for c in conversoes if c["queda"] is not None and c["queda"] > 0]
+    gargalo = max(quedas, key=lambda c: c["queda"])["de"] if quedas else None
+
+    return {"etapas": etapas, "conversoes": conversoes, "gargalo": gargalo}
+
+
 # ---------------------------------------------------------------------------
 # Configuração e integrações
 # ---------------------------------------------------------------------------

package/backend/services/extractors.py

@@ -32,6 +32,14 @@ def _conf() -> dict:
     return storage.get_config()["extratores"]
 
 
+def _timeout_extrator(chave: str, padrao: int) -> int:
+    """Timeout de segurança configurável por extrator (Ferramentas → Extratores)."""
+    try:
+        return max(5, int(_conf().get(chave, padrao)))
+    except (TypeError, ValueError):
+        return padrao
+
+
 def _novo_lead_parcial() -> dict:
     return {"tags": [], "observacoes": "", "score": 50}
 
@@ -62,7 +70,19 @@ def extrair_google_maps(palavra_chave: str, localizacao: str, max_resultados: in
             outdir=str(outdir),
         )
         try:
-            resultado = subprocess.run(cmd, capture_output=True, text=True, timeout=1800, shell=False, creationflags=proc_flags.creationflags())
+            resultado = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=_timeout_extrator("timeout_maps_segundos", 300),
+                shell=False,
+                creationflags=proc_flags.creationflags(),
+            )
+        except subprocess.TimeoutExpired as e:
+            raise ExtratorErro(
+                f"Timeout na extração do Google Maps após {_timeout_extrator('timeout_maps_segundos', 300)}s. "
+                "Aumente o timeout em Ferramentas → Extratores ou reduza a quantidade de resultados."
+            ) from e
         except FileNotFoundError as e:
             raise ExtratorNaoConfigurado(f"Não foi possível executar o CLI do Google Maps Scraper: {e}") from e
         if resultado.returncode != 0:
@@ -78,7 +98,7 @@ def extrair_google_maps(palavra_chave: str, localizacao: str, max_resultados: in
 # Instagram (lucasoal/igmapper via CLI)
 # ---------------------------------------------------------------------------
 
-def extrair_instagram(profile_url: str) -> dict:
+def extrair_instagram(profile_url: str, limit: int = 10) -> dict:
     conf = _conf()
     cli = conf.get("igmapper_cli", "")
     if not cli or not Path(cli).exists():
@@ -88,10 +108,27 @@ def extrair_instagram(profile_url: str) -> dict:
         )
     with tempfile.TemporaryDirectory(prefix="leadmaster-ig-") as tmp:
         outdir = Path(tmp)
-        args_template = conf.get("igmapper_args", "--profile {url} --outdir {outdir}")
-        cmd = [cli] + _formatar_args(args_template, url=profile_url, outdir=str(outdir))
+        args_template = conf.get("igmapper_args", "--profile {url} --limit {limit} --outdir {outdir}")
+        cmd = [cli] + _formatar_args(
+            args_template,
+            url=profile_url,
+            limit=max(1, int(limit or 10)),
+            outdir=str(outdir),
+        )
         try:
-            resultado = subprocess.run(cmd, capture_output=True, text=True, timeout=900, shell=False, creationflags=proc_flags.creationflags())
+            resultado = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=_timeout_extrator("timeout_instagram_segundos", 120),
+                shell=False,
+                creationflags=proc_flags.creationflags(),
+            )
+        except subprocess.TimeoutExpired as e:
+            raise ExtratorErro(
+                f"Timeout na extração do Instagram após {_timeout_extrator('timeout_instagram_segundos', 120)}s. "
+                "Aumente o timeout em Ferramentas → Extratores."
+            ) from e
         except FileNotFoundError as e:
             raise ExtratorNaoConfigurado(f"Não foi possível executar o igmapper: {e}") from e
         if resultado.returncode != 0:
@@ -113,6 +150,7 @@ def extrair_instagram(profile_url: str) -> dict:
 # for este valor, o extrator trabalha em modo MOCK (5–10 empresas fictícias) —
 # estabilidade e anti-bloqueio nesta fase. URL diferente = provedor real.
 CNPJ_PROVEDOR_PADRAO = "https://api.opencnpj.org"
+CNPJ_API_PADRAO = "https://brasilapi.com.br/api/cnpj/v1"
 
 
 def _so_digitos(texto: str) -> str:
@@ -123,14 +161,16 @@ def consulta_cnpj(cnpj: str) -> dict:
     cnpj = _so_digitos(cnpj)
     if len(cnpj) != 14:
         raise ExtratorErro("CNPJ inválido: use 14 dígitos (com ou sem pontuação).")
+    base = (_conf().get("cnpj_api_url") or CNPJ_API_PADRAO).rstrip("/")
+    url = f"{base}/{cnpj}"
     try:
-        r = httpx.get(f"https://brasilapi.com.br/api/cnpj/v1/{cnpj}", timeout=30)
+        r = httpx.get(url, timeout=30)
     except httpx.HTTPError as e:
-        raise ExtratorErro(f"Falha ao consultar a BrasilAPI: {e}") from e
+        raise ExtratorErro(f"Falha ao consultar a API de CNPJ ({base}): {e}") from e
     if r.status_code == 404:
-        raise ExtratorErro("CNPJ não encontrado na BrasilAPI.")
+        raise ExtratorErro("CNPJ não encontrado na API consultada.")
     if r.status_code >= 400:
-        raise ExtratorErro(f"BrasilAPI respondeu HTTP {r.status_code}: {r.text[:200]}")
+        raise ExtratorErro(f"API de CNPJ ({base}) respondeu HTTP {r.status_code}: {r.text[:200]}")
     d = r.json()
     endereco = " ".join(
         p

package/backend/services/storage.py

@@ -114,9 +114,12 @@ DEFAULT_CONFIG = {
             '--kw "{palavra_chave}" --loc "{localizacao}" --lang pt --email --max {max_resultados} --outdir "{outdir}"'
         ),
         "igmapper_cli": "",
-        "igmapper_args": "--profile {url} --outdir {outdir}",
+        "igmapper_args": "--profile {url} --limit {limit} --outdir {outdir}",
         "scrapling_cli": "",
+        "cnpj_api_url": "https://brasilapi.com.br/api/cnpj/v1",
         "cnpj_provedor_busca": "https://api.opencnpj.org",
+        "timeout_maps_segundos": 300,
+        "timeout_instagram_segundos": 120,
     },
     "agentes": {
         "disparo": {

package/backend/tests/test_extractors_real.py

@@ -0,0 +1,65 @@
+"""Testes dos extratores REAIS (0.1.23): scraper configurado que falha retorna
+HTTP 500 amigável e NÃO salva leads mockados/parciais; sem scraper configurado,
+o modo mock segue funcionando. Usa o próprio executável do Python como falso
+binário para simular falha de execução do CLI.
+"""
+
+import subprocess
+import sys
+from unittest.mock import patch
+
+import pytest
+from fastapi.testclient import TestClient
+
+import main
+
+
+@pytest.fixture()
+def client(tmp_path, monkeypatch):
+    monkeypatch.setenv("LEADMASTER_HOME", str(tmp_path))
+    with TestClient(main.app) as c:
+        yield c
+
+
+def _completed(returncode, stderr=""):
+    return main.extractors.subprocess.CompletedProcess(args=[], returncode=returncode, stdout="", stderr=stderr)
+
+
+def test_maps_scraper_falhar_500_sem_salvar(client):
+    # "Binário" configurado (o próprio python), mas a execução falha (returncode 1).
+    client.put("/api/config", json={"extratores": {"google_maps_cli": sys.executable}})
+    antes = len(client.get("/api/crm/leads").json())
+    with patch.object(main.extractors.subprocess, "run", return_value=_completed(1, "falha simulada")):
+        r = client.post("/api/extractors/maps", json={"keyword": "pizzaria", "location": "São Paulo, SP", "limit": 8})
+    assert r.status_code == 500
+    assert "código 1" in r.json()["detail"] or "falha simulada" in r.json()["detail"]
+    # Nada foi salvo no leads.json (sem mock/parcial).
+    depois = client.get("/api/crm/leads").json()
+    assert len(depois) == antes
+
+
+def test_maps_scraper_timeout_500(client):
+    client.put("/api/config", json={"extratores": {"google_maps_cli": sys.executable}})
+    with patch.object(
+        main.extractors.subprocess, "run", side_effect=subprocess.TimeoutExpired(cmd="x", timeout=300)
+    ):
+        r = client.post("/api/extractors/maps", json={"keyword": "dentista", "location": "Rio, RJ", "limit": 8})
+    assert r.status_code == 500
+    assert "Timeout na extração" in r.json()["detail"]
+
+
+def test_instagram_scraper_falhar_500_sem_salvar(client):
+    client.put("/api/config", json={"extratores": {"igmapper_cli": sys.executable}})
+    antes = len(client.get("/api/crm/leads").json())
+    with patch.object(main.extractors.subprocess, "run", return_value=_completed(2, "igmapper explodiu")):
+        r = client.post("/api/extractors/instagram", json={"profile_url": "https://instagram.com/x", "limit": 6})
+    assert r.status_code == 500
+    depois = client.get("/api/crm/leads").json()
+    assert len(depois) == antes
+
+
+def test_maps_sem_scraper_mantem_mock(client):
+    r = client.post("/api/extractors/maps", json={"keyword": "pizzaria", "location": "Campinas, SP", "limit": 7})
+    assert r.status_code == 201
+    assert r.json()["origem"] == "mock"
+    assert len(r.json()["importados"]) == 7

package/backend/tests/test_funnel_routes.py

@@ -0,0 +1,65 @@
+"""Testes do Funil de Prospecção — GET /api/funnel.
+
+Semeadura determinística no leads.json do home temporário para validar
+contagens, taxas de conversão e identificação do gargalo.
+"""
+
+import json
+
+import pytest
+from fastapi.testclient import TestClient
+
+import main
+
+
+@pytest.fixture()
+def client(tmp_path, monkeypatch):
+    monkeypatch.setenv("LEADMASTER_HOME", str(tmp_path))
+    with TestClient(main.app) as c:
+        yield c
+
+
+def _semear(client, distribuicao):
+    """Escreve leads diretamente no leads.json do home do teste."""
+    home = main.storage.storage_dir()
+    leads = []
+    for etapa, qtd in distribuicao.items():
+        for i in range(qtd):
+            leads.append({"id": f"{etapa}-{i}", "nome": f"Lead {etapa} {i}", "telefone": "", "email": "", "fonte": "Teste", "etapa": etapa})
+    (home / "leads.json").write_text(json.dumps(leads), encoding="utf-8")
+
+
+def test_funil_conversoes_e_gargalo(client):
+    # [10, 5, 2, 1]: taxas 50%, 40%, 50% → quedas 50, 60, 50 → gargalo "Em Contato"
+    _semear(client, {"leads": 10, "em_contato": 5, "proposta": 2, "fechado": 1})
+    r = client.get("/api/funnel")
+    assert r.status_code == 200
+    corpo = r.json()
+    assert [e["quantidade"] for e in corpo["etapas"]] == [10, 5, 2, 1]
+    assert [e["nome"] for e in corpo["etapas"]] == ["Leads", "Em Contato", "Proposta", "Fechado"]
+    taxas = [c["taxa"] for c in corpo["conversoes"]]
+    assert taxas == [50.0, 40.0, 50.0]
+    assert corpo["gargalo"] == "Em Contato"
+
+
+def test_funil_gargalo_primeira_etapa(client):
+    # Todos param na primeira etapa: queda 100% em Leads → Em Contato.
+    _semear(client, {"leads": 7, "em_contato": 0, "proposta": 0, "fechado": 0})
+    corpo = client.get("/api/funnel").json()
+    assert corpo["gargalo"] == "Leads"
+    assert corpo["conversoes"][0]["taxa"] == 0.0
+
+
+def test_funil_sem_leads(client):
+    _semear(client, {})
+    corpo = client.get("/api/funnel").json()
+    assert [e["quantidade"] for e in corpo["etapas"]] == [0, 0, 0, 0]
+    assert all(c["taxa"] is None for c in corpo["conversoes"])
+    assert corpo["gargalo"] is None
+
+
+def test_funil_sem_gargalo(client):
+    # Quedas todas zero (contagens iguais) → sem gargalo definido.
+    _semear(client, {"leads": 4, "em_contato": 4, "proposta": 4, "fechado": 4})
+    corpo = client.get("/api/funnel").json()
+    assert corpo["gargalo"] is None