@danhachuel/prodmaker 0.1.4 → 0.1.6

package/CHANGELOG.md

@@ -3,6 +3,45 @@
 Todas as versões seguem a etiqueta visual `MAJOR.MINOR.PATCH` com patch de dois dígitos
 (o registry NPM normaliza `0.1.00` → `0.1.0`).
 
+## 0.1.06 — 2026-10-26
+
+- **Parte 5 — AdsTracking: Minhas Visitas (AdsPixel) funcional, layout AdsX 1:1.**
+- Página completa sobre a tabela `visitas`: barra superior com período (90 dias) e contagens;
+  **alerta de POSSÍVEL DRENAGEM DE ORÇAMENTO** (IPs com ≥ 4 cliques repetidos) com botão
+  "Copiar Todos (N IPs)"; cards de visitantes (IP, ID, cliques, dispositivo, último acesso) com
+  **modal do visitante** (badge Humano, detalhes, abas IDs de Rastreamento / Payload JSON com
+  copiar, e últimos eventos).
+- Métricas: Visitas Humanas, Cliques/CTR, Checkouts, Vendas (zerados até chegarem webhooks —
+  nunca inventados); 3 donuts CSS (Origem do Tráfego, Dispositivos, Sistemas Operacionais —
+  parser de User-Agent local, sem serviços externos); **Fluxo de Tráfego ao Vivo** (SVG por
+  hora) e **Funil de Conversão** (Visitas → Cliques → Checkouts → Vendas).
+- Backend: `services/tracking.py` (agregações + parser UA + visitor_id por hash de IP) e
+  `api/tracking.py` (`GET /api/tracking/dashboard`, `GET /api/tracking/visitante/{ip}`).
+- Estado vazio honesto com instruções (configurar URL do `/track` via túnel + publicar páginas).
+
+## 0.1.05 — 2026-10-26
+
+- **Parte 4 — AdsPages & AdsHosting (geração de páginas, clonagem, pixel, domínios e publicação).**
+- **AdsPages funcional:** pre-sell de afiliado e página de vendas (12 seções) geradas por LLM
+  (templates do seed, idioma selecionável, dados preenchidos a partir do produto vinculado);
+  **clonagem de páginas com higienização** (BeautifulSoup remove scripts, iframes, noscript e
+  pixels/analytics do original); pré-visualização local em `/pages/{id}`, editor de HTML
+  integrado e download.
+- **Pixel próprio (AdsPixel) embutido** nas páginas geradas quando a URL pública do `/track`
+  está configurada (card "Pixel de Rastreamento" em Chaves de API): pageview, clique em CTA e
+  tempo na página, capturando gclid/utm/ref — endpoint `/track` (GET/POST + CORS) grava na
+  tabela `visitas` (a UI de Minhas Visitas vem na sequência). Sem URL configurada, nenhuma
+  tag é embutida (a UI não inventa dados).
+- **AdsHosting — Domínios:** cards no layout AdsX com status pendente/online; verificação por
+  DNS público (NS/A via dnspython) e, com API Token Cloudflare configurado, status da zona
+  via API; name servers exibidos com botão copiar; "+ Tags, Pixels and Scripts (Opcional)"
+  por domínio; adicionar/remover domínios.
+- **Páginas Criadas:** tabela com preview, download, edição de HTML, status rascunho/publicada
+  e **Publicar 🚀 via GitHub Contents API** (commit do HTML no repositório configurado em
+  Chaves de API; Cloudflare Pages deploy automaticamente quando o repositório está conectado) —
+  com link do commit e URL pública.
+- Novas tabelas: `paginas`, `dominios`, `visitas`. requirements.txt: + beautifulsoup4, dnspython.
+
 ## 0.1.04 — 2026-10-25
 
 - Favicon 🚀 (SVG) nas guias do navegador: app (SPA), login e páginas `/legal`.

package/THIRD-PARTY-NOTICES.md

@@ -16,7 +16,12 @@ Esta lista cresce a cada fase conforme novas integrações são ativadas.
 - **google-genai (SDK oficial Google Gemini)** — Apache-2.0 — https://github.com/googleapis/python-genai
 - **Markdown** — BSD-3-Clause — https://github.com/Python-Markdown/markdown
 - **xhtml2pdf** (inclui ReportLab) — MIT/Apache-2.0 — https://github.com/xhtml2pdf/xhtml2pdf
-- **httpx** (transitivo do openai; usado pelo cliente Gamma) — BSD-3-Clause — https://github.com/encode/httpx
+- **httpx** (transitivo do openai; usado pelos clientes GitHub/Cloudflare/clone) — BSD-3-Clause — https://github.com/encode/httpx
+
+## Runtime (Parte 4)
+
+- **Beautiful Soup 4** — MIT License — https://www.crummy.com/software/BeautifulSoup/ (higienização de páginas clonadas)
+- **dnspython** — ISC License — https://github.com/rbarrois/dnspython (verificação NS/A de domínios)
 
 ## Integrações planejadas (fases futuras)
 

package/app/api/dominios.py

@@ -0,0 +1,92 @@
+import json
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services.database import get_db, now_str, row_to_dict
+from ..services.dominios import verificar_dominio
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/dominios", tags=["dominios"])
+
+
+class DominioBody(BaseModel):
+    nome: str
+
+
+class TagsBody(BaseModel):
+    tags: str = ""
+
+
+@router.get("")
+def list_dominios():
+    with get_db() as conn:
+        rows = conn.execute("SELECT * FROM dominios ORDER BY id DESC").fetchall()
+    return [row_to_dict(row) for row in rows]
+
+
+@router.post("")
+def create_dominio(body: DominioBody):
+    nome = (body.nome or "").strip().lower().rstrip(".")
+    if "." not in nome:
+        raise HTTPException(status_code=400, detail="Informe um domínio válido (ex.: meusite.com).")
+    with get_db() as conn:
+        existing = conn.execute("SELECT id FROM dominios WHERE nome = ?", (nome,)).fetchone()
+        if existing:
+            raise HTTPException(status_code=400, detail="Este domínio já está cadastrado.")
+        timestamp = now_str()
+        cursor = conn.execute(
+            "INSERT INTO dominios (nome, status, created_at, updated_at) VALUES (?, 'pendente', ?, ?)",
+            (nome, timestamp, timestamp),
+        )
+        row = conn.execute("SELECT * FROM dominios WHERE id = ?", (cursor.lastrowid,)).fetchone()
+    return row_to_dict(row)
+
+
+@router.post("/{dominio_id}/verificar")
+def verificar(dominio_id: int):
+    record = _get_or_404(dominio_id)
+    try:
+        resultado = verificar_dominio(record["nome"])
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    with get_db() as conn:
+        conn.execute(
+            "UPDATE dominios SET status = ?, ns_data = ?, a_data = ?, cf_zone_id = ?, updated_at = ? WHERE id = ?",
+            (
+                resultado["status"],
+                json.dumps({"ns": resultado["ns"], "cf_name_servers": resultado["cf_name_servers"]}, ensure_ascii=False),
+                json.dumps({"a": resultado["a"]}, ensure_ascii=False),
+                resultado["cf_zone_id"],
+                now_str(),
+                dominio_id,
+            ),
+        )
+        row = conn.execute("SELECT * FROM dominios WHERE id = ?", (dominio_id,)).fetchone()
+    record = row_to_dict(row)
+    record["verificacao"] = resultado
+    return record
+
+
+@router.put("/{dominio_id}/tags")
+def update_tags(dominio_id: int, body: TagsBody):
+    _get_or_404(dominio_id)
+    with get_db() as conn:
+        conn.execute("UPDATE dominios SET tags = ?, updated_at = ? WHERE id = ?", (body.tags, now_str(), dominio_id))
+    return _get_or_404(dominio_id)
+
+
+@router.delete("/{dominio_id}")
+def delete_dominio(dominio_id: int):
+    _get_or_404(dominio_id)
+    with get_db() as conn:
+        conn.execute("DELETE FROM dominios WHERE id = ?", (dominio_id,))
+    return {"ok": True}
+
+
+def _get_or_404(dominio_id: int):
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM dominios WHERE id = ?", (dominio_id,)).fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Domínio não encontrado.")
+    return row_to_dict(row)

package/app/api/paginas.py

@@ -0,0 +1,155 @@
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+from ..services.database import get_db, now_str, row_to_dict
+from ..services.llm import LLMError
+from ..services.pages import gerar_pagina, salvar_html
+from ..services.publish import publicar_pagina
+from ..services.clone import clonar_url
+from ..services.store import STORAGE
+
+router = APIRouter(prefix="/api/paginas", tags=["paginas"])
+
+
+class PaginaBody(BaseModel):
+    tipo: str  # presell | vendas | clone
+    produto_id: int | None = None
+    titulo: str = ""
+    idioma: str = "Português"
+    afiliado_link: str = ""
+    checkout_link: str = ""
+    avatar: str = ""
+    resultado: str = ""
+    tempo: str = ""
+    dor: str = ""
+    prompt: str = ""
+    clone_url: str = ""
+
+
+def _get_produto(produto_id: int | None):
+    if not produto_id:
+        return None
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM produtos WHERE id = ?", (produto_id,)).fetchone()
+    return row_to_dict(row) if row else None
+
+
+@router.post("")
+def create_pagina(body: PaginaBody):
+    if not body.titulo.strip():
+        raise HTTPException(status_code=400, detail="Informe o título da página.")
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO paginas (titulo, tipo, produto_id, idioma, html_path, status, created_at, updated_at) VALUES (?, ?, ?, ?, '', 'rascunho', ?, ?)",
+            (body.titulo.strip(), body.tipo, body.produto_id, body.idioma, timestamp, timestamp),
+        )
+        page_id = cursor.lastrowid
+
+    try:
+        if body.tipo == "clone":
+            html, _cloned_title = clonar_url(body.clone_url)
+            provider = "clone"
+        else:
+            produto = _get_produto(body.produto_id)
+            result = gerar_pagina(body.tipo, produto, body.model_dump())
+            html = result["html"]
+            provider = result["provider"]
+        salvar_html(page_id, html)
+        rel_path = f"pages/{page_id}/index.html"
+        with get_db() as conn:
+            conn.execute("UPDATE paginas SET html_path = ?, updated_at = ? WHERE id = ?", (rel_path, now_str(), page_id))
+            row = conn.execute("SELECT * FROM paginas WHERE id = ?", (page_id,)).fetchone()
+        record = row_to_dict(row)
+        record["preview_url"] = f"/pages/{page_id}"
+        record["provider"] = provider
+        return record
+    except (LLMError, RuntimeError) as exc:
+        with get_db() as conn:
+            conn.execute("DELETE FROM paginas WHERE id = ?", (page_id,))
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.get("")
+def list_paginas():
+    with get_db() as conn:
+        rows = conn.execute("SELECT * FROM paginas ORDER BY id DESC").fetchall()
+    result = []
+    for row in rows:
+        record = row_to_dict(row)
+        record["preview_url"] = f"/pages/{record['id']}"
+        result.append(record)
+    return result
+
+
+@router.get("/{page_id}/html")
+def get_html(page_id: int):
+    record = _get_or_404(page_id)
+    path = STORAGE / record["html_path"] if record["html_path"] else None
+    if not path or not path.exists():
+        raise HTTPException(status_code=404, detail="HTML não encontrado.")
+    return {"html": path.read_text(encoding="utf-8")}
+
+
+@router.put("/{page_id}/html")
+def update_html(page_id: int, payload: dict):
+    _get_or_404(page_id)
+    html = payload.get("html")
+    if not html or not html.strip():
+        raise HTTPException(status_code=400, detail="HTML vazio.")
+    salvar_html(page_id, html)
+    with get_db() as conn:
+        conn.execute("UPDATE paginas SET updated_at = ? WHERE id = ?", (now_str(), page_id))
+    return {"ok": True}
+
+
+@router.get("/{page_id}/download")
+def download_pagina(page_id: int):
+    record = _get_or_404(page_id)
+    path = STORAGE / record["html_path"] if record["html_path"] else None
+    if not path or not path.exists():
+        raise HTTPException(status_code=404, detail="HTML não encontrado.")
+    return FileResponse(path, filename=f"{record['titulo']}.html", media_type="text/html")
+
+
+@router.post("/{page_id}/publicar")
+def publicar(page_id: int):
+    record = _get_or_404(page_id)
+    path = STORAGE / record["html_path"] if record["html_path"] else None
+    if not path or not path.exists():
+        raise HTTPException(status_code=404, detail="HTML não encontrado.")
+    try:
+        result = publicar_pagina(page_id, record["titulo"], path.read_text(encoding="utf-8"))
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    with get_db() as conn:
+        conn.execute(
+            "UPDATE paginas SET status = 'publicada', published_url = ?, updated_at = ? WHERE id = ?",
+            (result["pages_url"], now_str(), page_id),
+        )
+    updated = _get_or_404(page_id)
+    updated["publish_result"] = result
+    return updated
+
+
+@router.delete("/{page_id}")
+def delete_pagina(page_id: int):
+    record = _get_or_404(page_id)
+    if record["html_path"]:
+        folder = (STORAGE / record["html_path"]).parent
+        if folder.exists():
+            for item in folder.iterdir():
+                item.unlink()
+            folder.rmdir()
+    with get_db() as conn:
+        conn.execute("DELETE FROM paginas WHERE id = ?", (page_id,))
+    return {"ok": True}
+
+
+def _get_or_404(page_id: int):
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM paginas WHERE id = ?", (page_id,)).fetchone()
+    if not row:
+        raise HTTPException(status_code=404, detail="Página não encontrada.")
+    return row_to_dict(row)

package/app/api/tracking.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter, HTTPException, Query
+
+from ..services import tracking
+
+router = APIRouter(prefix="/api/tracking", tags=["tracking"])
+
+
+@router.get("/dashboard")
+def dashboard(days: int = Query(90, ge=1, le=365)):
+    """Agregações do AdsPixel: métricas, drenagem, visitantes, donuts, funil e fluxo."""
+    return tracking.dashboard(days)
+
+
+@router.get("/visitante/{ip}")
+def visitante(ip: str):
+    """Detalhes de um visitante (histórico de eventos + payload)."""
+    return tracking.visitante(ip)

package/app/main.py

@@ -15,7 +15,7 @@ from .services.database import ensure_db, get_db, now_str, row_to_dict
 from .services.llm import LLMError, analyze_product, list_providers
 from .services.store import PRODMAKER_HOME, STORAGE, STATE, ensure_state_dir, get_settings, save_settings
 
-APP_VERSION = "0.1.04"
+APP_VERSION = "0.1.06"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 
@@ -26,9 +26,15 @@ app = FastAPI(title="ProdMaker", version=APP_VERSION)
 
 from .api import infoprodutos as infoprodutos_router  # noqa: E402
 from .api import llm as llm_router  # noqa: E402
+from .api import paginas as paginas_router  # noqa: E402
+from .api import dominios as dominios_router  # noqa: E402
+from .api import tracking as tracking_router  # noqa: E402
 
 app.include_router(llm_router.router)
 app.include_router(infoprodutos_router.router)
+app.include_router(paginas_router.router)
+app.include_router(dominios_router.router)
+app.include_router(tracking_router.router)
 
 ensure_db()
 
@@ -225,7 +231,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.4"}
+    return {"version": APP_VERSION, "canonical": "0.1.6"}
 
 
 @app.get("/api/settings")
@@ -238,6 +244,52 @@ def update_settings(data: dict):
     return save_settings(data)
 
 
+# ---------------------------------------------------------------------------
+# Pixel próprio (AdsPixel) — recebe eventos das páginas geradas/publicadas
+# ---------------------------------------------------------------------------
+
+
+@app.options("/track")
+def track_options():
+    return Response(
+        status_code=204,
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+            "Access-Control-Allow-Headers": "*",
+        },
+    )
+
+
+@app.api_route("/track", methods=["GET", "POST"])
+def track(request: Request):
+    params = dict(request.query_params)
+    forwarded = request.headers.get("x-forwarded-for", "")
+    ip = forwarded.split(",")[0].strip() or (request.client.host if request.client else "")
+    known = {"event", "page", "gclid", "utm_source", "utm_medium", "utm_campaign", "ref"}
+    try:
+        with get_db() as conn:
+            conn.execute(
+                "INSERT INTO visitas (event, page, gclid, utm_source, utm_medium, utm_campaign, ref, ip, user_agent, extra, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (
+                    params.get("event", "pageview"),
+                    params.get("page", ""),
+                    params.get("gclid", ""),
+                    params.get("utm_source", ""),
+                    params.get("utm_medium", ""),
+                    params.get("utm_campaign", ""),
+                    params.get("ref", ""),
+                    ip,
+                    request.headers.get("user-agent", ""),
+                    json.dumps({k: v for k, v in params.items() if k not in known}, ensure_ascii=False),
+                    now_str(),
+                ),
+            )
+    except Exception:
+        pass  # o pixel nunca deve quebrar a página do visitante
+    return Response(status_code=204, headers={"Access-Control-Allow-Origin": "*"})
+
+
 # ---------------------------------------------------------------------------
 # Estáticos: /legal, frontend/dist (SPA fallback) e páginas geradas
 # ---------------------------------------------------------------------------

package/app/services/clone.py

@@ -0,0 +1,43 @@
+"""Clonagem de páginas com higienização — remove scripts, pixels e iframes do original."""
+import httpx
+from bs4 import BeautifulSoup
+
+from .llm import LLMError
+
+
+def clonar_url(url: str) -> tuple[str, str]:
+    """Baixa a URL e devolve (HTML higienizado, título) — scripts/pixels/iframes removidos."""
+    if not url.strip().startswith(("http://", "https://")):
+        raise LLMError("Informe uma URL válida (http/https) para clonar.")
+    try:
+        response = httpx.get(
+            url,
+            timeout=45.0,
+            follow_redirects=True,
+            headers={"User-Agent": "Mozilla/5.0 (compatible; ProdMaker/0.1; +local)"},
+        )
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha ao baixar a página: {exc}") from exc
+    if response.status_code >= 400:
+        raise LLMError(f"A página respondeu {response.status_code} — confira a URL.")
+
+    soup = BeautifulSoup(response.text, "html.parser")
+
+    # Higienização: remove rastreadores e código de terceiros
+    for tag in soup.find_all(["script", "noscript", "iframe"]):
+        tag.decompose()
+    for pattern in ("facebook", "pixel", "analytics", "googletagmanager", "doubleclick", "hotjar", "clarity"):
+        for img in soup.find_all("img", src=lambda src: src and pattern in src.lower()):
+            img.decompose()
+        for link in soup.find_all("link", href=lambda href: href and pattern in href.lower()):
+            link.decompose()
+    for comment in soup.find_all(string=lambda text: isinstance(text, str) and text.strip().startswith(("<!--", "<!["))):
+        comment.extract()
+
+    title = soup.title.get_text(strip=True) if soup.title else url
+    meta = soup.new_tag("meta")
+    meta.attrs["name"] = "generator"
+    meta.attrs["content"] = "ProdMaker (clone higienizado)"
+    if soup.head:
+        soup.head.append(meta)
+    return str(soup), title

package/app/services/database.py

@@ -48,6 +48,55 @@ def ensure_db() -> None:
             )
             """
         )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS paginas (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                titulo TEXT NOT NULL,
+                tipo TEXT NOT NULL,
+                produto_id INTEGER,
+                idioma TEXT NOT NULL DEFAULT 'Portugues',
+                html_path TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'rascunho',
+                published_url TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS dominios (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                nome TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'pendente',
+                cf_zone_id TEXT NOT NULL DEFAULT '',
+                ns_data TEXT NOT NULL DEFAULT '',
+                a_data TEXT NOT NULL DEFAULT '',
+                tags TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS visitas (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                event TEXT NOT NULL DEFAULT '',
+                page TEXT NOT NULL DEFAULT '',
+                gclid TEXT NOT NULL DEFAULT '',
+                utm_source TEXT NOT NULL DEFAULT '',
+                utm_medium TEXT NOT NULL DEFAULT '',
+                utm_campaign TEXT NOT NULL DEFAULT '',
+                ref TEXT NOT NULL DEFAULT '',
+                ip TEXT NOT NULL DEFAULT '',
+                user_agent TEXT NOT NULL DEFAULT '',
+                extra TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
         columns = [row["name"] for row in conn.execute("PRAGMA table_info(produtos)")]
         if "analysis" not in columns:
             conn.execute("ALTER TABLE produtos ADD COLUMN analysis TEXT NOT NULL DEFAULT ''")

package/app/services/dominios.py

@@ -0,0 +1,78 @@
+"""AdsHosting — verificação de domínios via Cloudflare API + DNS público."""
+import json
+
+import httpx
+
+from .llm import LLMError
+
+CF_BASE = "https://api.cloudflare.com/client/v4"
+
+
+def _cloudflare_token() -> str:
+    from .store import get_settings
+
+    keys = (get_settings().get("api_keys") or {}).get("cloudflare") or {}
+    return (keys.get("api_token") or "").strip()
+
+
+def _dns_query_ns(nome: str) -> list[str]:
+    try:
+        import dns.resolver
+
+        answers = dns.resolver.Resolver().resolve(nome, "NS")
+        return sorted(str(rdata.target).rstrip(".").lower() for rdata in answers)
+    except Exception:
+        return []
+
+
+def _dns_query_a(nome: str) -> list[str]:
+    try:
+        import dns.resolver
+
+        answers = dns.resolver.Resolver().resolve(nome, "A")
+        return sorted(str(rdata) for rdata in answers)
+    except Exception:
+        return []
+
+
+def verificar_dominio(nome: str) -> dict:
+    """Verifica NS/A via DNS público e status na Cloudflare (se token configurado).
+
+    Nunca inventa dados: sem token, usa apenas DNS; sem DNS, marca como pendente.
+    """
+    nome = (nome or "").strip().lower().rstrip(".")
+    if not nome or "." not in nome:
+        raise LLMError("Informe um domínio válido (ex.: meusite.com).")
+
+    resultado = {
+        "ns": _dns_query_ns(nome),
+        "a": _dns_query_a(nome),
+        "ns_cloudflare": False,
+        "cf_status": "",
+        "cf_zone_id": "",
+        "cf_name_servers": [],
+    }
+    resultado["ns_cloudflare"] = any("ns.cloudflare.com" in ns for ns in resultado["ns"])
+
+    token = _cloudflare_token()
+    if token:
+        try:
+            with httpx.Client(timeout=30.0) as client:
+                response = client.get(f"{CF_BASE}/zones", headers={"Authorization": f"Bearer {token}"}, params={"name": nome})
+                if response.status_code == 200:
+                    payload = response.json()
+                    zones = (payload.get("result") or [])
+                    if zones:
+                        zone = zones[0]
+                        resultado["cf_status"] = zone.get("status") or ""
+                        resultado["cf_zone_id"] = zone.get("id") or ""
+                        resultado["cf_name_servers"] = zone.get("name_servers") or []
+                        resultado["ns_cloudflare"] = resultado["ns_cloudflare"] or bool(resultado["cf_name_servers"]) and zone.get("status") == "active"
+                elif response.status_code in (401, 403):
+                    raise LLMError("Cloudflare rejeitou o token (401/403) — confira o API Token em Chaves de API.")
+        except httpx.HTTPError as exc:
+            raise LLMError(f"Falha de conexão com a Cloudflare: {exc}") from exc
+
+    online = resultado["ns_cloudflare"] or resultado["cf_status"] == "active"
+    resultado["status"] = "online" if online else "pendente"
+    return resultado