@danhachuel/leadmaster 0.1.22 → 0.1.24

package/CHANGELOG.md

@@ -37,6 +37,62 @@ 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.24] — 2026-11-09
+
+### Corrigido
+
+- **Launcher — regressão do terminal preso investigada e blindagem reforçada** —
+   usuário reportou o prompt do MobaXterm voltando logo após "LeadMaster no ar"
+   na 0.1.21 (runtime permanente). A investigação mostrou que o fluxo publicado
+   **mantém** as proteções (`process.stdin.resume();`, `setInterval`,
+   `child.on('exit')`/`close`, `process.on('exit')`, sem `.unref()`) e que uma
+   morte silenciosa assim — sem nenhum log do handler de saída — só ocorre por
+   `SIGKILL`/`taskkill /F` (ex.: outra execução `install`/`start` matando a
+   instância anterior pelo kill switch, ou fechamento forçado da aba). Mesmo
+   assim, o launcher foi reforçado e os gates agora validam o **fluxo**:
+   - **Rede de segurança no `cmdStart`:** `process.on('beforeExit')` re-arma o
+     `setInterval` se o event loop esvaziar (stdin em EOF, timer perdido,
+     surpresa de PTY) — o Node jamais encerra sozinho; erros do stream de
+     stdin (`process.stdin.on('error')`) são ignorados;
+   - **Gates de fluxo (`test_launcher_protections.py`):** novo helper
+     `_corpo_cmd_start()` extrai o corpo da função para garantir que
+     `spawn`, `process.stdin.resume();`, `setInterval`, `child.on('exit')`,
+     `child.on('close')`, `process.on('exit')` e `beforeExit` existam **dentro
+     do `start`** (não no `install` nem em função morta) e que **nenhum
+     `process.exit(`** apareça após o terminal ser preso — a saída só por ciclo
+     de vida do filho ou por `SIGTERM`/`SIGBREAK`;
+   - **AGENTS.md:** regra 2 do launcher documenta a rede de segurança e a
+     exigência de posição (após o spawn, no fluxo do start).
+- **Diagnóstico rápido para o usuário:** com a regra acima, se o prompt voltar
+  sem as linhas "Encerrando LeadMaster..." (SIGTERM/SIGBREAK) ou "Servidor
+  local encerrou com código N" (Python caiu), a causa é externa ao launcher
+  (outra execução ou fechamento forçado) — o espelho
+  `storage/logs/launcher_console.log` mostra exatamente qual caminho ocorreu.
+
+## [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

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)

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_launcher_protections.py

@@ -23,6 +23,15 @@ def _conteudo() -> str:
     return CAMINHO.read_text(encoding="utf-8")
 
 
+def _corpo_cmd_start() -> str:
+    """Corpo da função cmdStart — valida o FLUXO do start (não só strings)."""
+    c = _conteudo()
+    assert "function cmdStart(" in c, "função cmdStart não encontrada"
+    inicio = c.index("function cmdStart(")
+    fim = c.index("async function cmdDoctor")
+    return c[inicio:fim]
+
+
 class TestLauncherProtections:
     def test_keepalivo(self):
         assert "setInterval(() => {}, 1000)" in _conteudo()
@@ -44,6 +53,28 @@ class TestLauncherProtections:
         # Avisar que já existe instância no ar é proibido (impede atualizações).
         assert "já está rodando" not in c
 
+    def test_keepalive_no_fluxo_do_start(self):
+        # Gate de FLUXO (regressão da 0.1.21): as proteções precisam existir
+        # dentro do cmdStart — no install, em função morta ou em bloco errado
+        # não valem. A morte prematura do Node devolve o prompt do MobaXterm.
+        corpo = _corpo_cmd_start()
+        assert "spawn(" in corpo  # worker Python é spawnado no start
+        assert "process.stdin.resume();" in corpo  # terminal preso
+        assert "setInterval(() => {}, 1000)" in corpo  # keep-alive
+        assert "beforeExit" in corpo  # rede de segurança do event loop
+        assert "child.on('exit'" in corpo or 'child.on("exit"' in corpo
+        assert "child.on('close'" in corpo or 'child.on("close"' in corpo
+        assert "process.on('exit'" in corpo or 'process.on("exit"' in corpo
+
+    def test_start_nunca_chama_exit_apos_terminal_preso(self):
+        # Após o terminal ser preso, nenhum caminho de sucesso chama
+        # process.exit — a saída só ocorre pelo ciclo de vida do filho
+        # (child exit/close) ou por sinais de parada legítima.
+        corpo = _corpo_cmd_start()
+        pos = corpo.index("process.stdin.resume();")
+        fim_iife = corpo.index("})().catch(")  # catch de erro fatal fica de fora
+        assert "process.exit(" not in corpo[pos:fim_iife]
+
     def test_ciclo_de_vida_vinculado(self):
         c = _conteudo()
         assert "child.on('exit'" in c or "child.on(\"exit\"" in c