@danhachuel/prodmaker 0.1.6 → 0.1.8

package/CHANGELOG.md

@@ -3,6 +3,42 @@
 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.08 — 2026-10-30
+
+- **Parte 6 — Minhas Vendas & Conversões GCLID.**
+- **Vendas funcionais:** tabela com cards (vendas aprovadas, receita, comissão, conversões
+  pendentes), adição manual, **importação CSV** (colunas em ordem livre + upload de arquivo),
+  exclusão e filtro por status de conversão.
+- **Webhooks de venda públicos:** `POST /api/webhook/sale/{hotmart|clickbank|digistore24|
+  kiify|cakto}` com parser **tolerante** (percorre o JSON procurando valor, comissão, e-mail,
+  transação, GCLID, produto e status — cada plataforma usa nomes diferentes; aceita JSON e form).
+  Página lista as URLs prontas para copiar no postback de cada plataforma.
+- **Matching por GCLID:** ao registrar venda com GCLID, o sistema cruza com a visita
+  correspondente na tabela `visitas` (página, IP, origem) e marca 🎯 no GCLID rastreado.
+- **Conversões offline (GCLID):** enxuta implementação REST `uploadClickConversions`
+  (`services/gads.py`): refresh token OAuth → POST Google Ads API (versão configurável,
+  default v22); upload individual ou **em lote** das pendentes; status por venda
+  (pendente/enviada/erro) com erro atribuído; exige Google Ads completo em Chaves de API
+  (developer token, client, refresh token, customer_id e **conversion_action**).
+- Nova tabela `vendas` (com índices em gclid/created_at). Sem novas dependências Python
+  (upload via httpx já incluso).
+
+## 0.1.07 — 2026-10-27
+
+- **Código de Ativação Mestre:** o login local agora valida o código de verdade.
+  O backend define `MASTER_CODE` (`get_master_code()` — default `1234`, sobrescrevível
+  via variável `PRODMAKER_MASTER_CODE`) e o alias **`admin`** também é sempre aceito;
+  qualquer e-mail + código mestre entram. Códigos comuns deixam de ser aceitos
+  (antes qualquer código ≥ 4 caracteres passava na validação simulada).
+- **Launcher imprime o código ao iniciar:** o box de inicialização agora mostra
+  `CODIGO DE ATIVACAO: <código>` (buscado direto do backend — fonte única de verdade,
+  com fallback para env/default). Sessões já autenticadas continuam válidas (JWT 30 dias).
+- **Robustez de boot:** imports de dependências de serviço (markdown, xhtml2pdf, httpx,
+  bs4, dns) tornados preguiçosos — o servidor sobe com qualquer Python que tenha
+  fastapi/uvicorn, e o erro claro (com instrução `prodmaker install`) aparece apenas na
+  ação que precisa da dependência.
+- Docs: MANUAL-INSTALACAO e README atualizados com o fluxo de login pelo código mestre.
+
 ## 0.1.06 — 2026-10-26
 
 - **Parte 5 — AdsTracking: Minhas Visitas (AdsPixel) funcional, layout AdsX 1:1.**

package/MANUAL-INSTALACAO.md

@@ -45,9 +45,12 @@ O terminal imprimirá:
 ```
 
 **Abra a URL manualmente.** O ProdMaker nunca abre o navegador sozinho (REGRA ZERO).
+O box de inicialização também imprime o **Código de Ativação Mestre** (default: `1234`) —
+no login, use qualquer e-mail + esse código (ou digite `admin` como código).
+Código customizado: variável de ambiente `PRODMAKER_MASTER_CODE`.
 Se a porta 8188 estiver ocupada, o launcher usará automaticamente 8189–8199 e informará.
 
-- Login: informe e-mail e código de ativação (no modo local simulado, qualquer e-mail válido + código com 4+ caracteres).
+- Login: informe qualquer e-mail e o **Código de Ativação Mestre** impresso no terminal ao iniciar (default: `1234`; ou digite `admin`).
 - Para encerrar: `Ctrl+C` no terminal.
 
 ## Diagnóstico

package/README.md

@@ -18,7 +18,7 @@ npx --yes @danhachuel/prodmaker@0.1.1
 
 1. `install` cria a pasta de dados (`PRODMAKER_HOME`), o storage local e instala as dependências Python.
 2. O segundo comando inicia o servidor em `http://localhost:8188` e imprime a URL no terminal.
-3. **Abra a URL manualmente no navegador**, faça login (e-mail + código de ativação) e acesse o painel.
+3. **Abra a URL manualmente no navegador**, faça login (qualquer e-mail + o **Código de Ativação Mestre** impresso no terminal — default `1234` — ou `admin`) e acesse o painel.
 
 ## O que está incluído (0.1.01 — Parte 2: Frontend)
 

package/app/api/vendas.py

@@ -0,0 +1,167 @@
+import json
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import Response
+from pydantic import BaseModel
+
+from ..services import gads, vendas
+from ..services.database import get_db, now_str, row_to_dict
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api", tags=["vendas"])
+
+WEBHOOK_FONTES = ("hotmart", "clickbank", "digistore24", "kiify", "cakto")
+
+
+class VendaBody(BaseModel):
+    produto_nome: str = ""
+    produto_id: int | None = None
+    valor: float = 0
+    comissao: float = 0
+    gclid: str = ""
+    comprador_email: str = ""
+    transacao_id: str = ""
+
+
+class CsvBody(BaseModel):
+    csv: str
+
+
+# ---------------------------------------------------------------------------
+# Vendas
+# ---------------------------------------------------------------------------
+
+
+@router.get("/vendas")
+def list_vendas():
+    return vendas.list_vendas()
+
+
+@router.get("/vendas/resumo")
+def resumo_vendas():
+    return vendas.resumo()
+
+
+@router.post("/vendas")
+def create_venda(body: VendaBody):
+    if not body.produto_nome.strip():
+        raise HTTPException(status_code=400, detail="Informe o nome do produto.")
+    return vendas.registrar_venda(
+        {
+            "fonte": "manual",
+            "produto_id": body.produto_id,
+            "produto_nome": body.produto_nome.strip(),
+            "valor": body.valor,
+            "comissao": body.comissao or round(body.valor * 0.5, 2),
+            "gclid": body.gclid.strip(),
+            "comprador_email": body.comprador_email.strip(),
+            "transacao_id": body.transacao_id.strip(),
+            "status": "aprovada",
+        }
+    )
+
+
+@router.delete("/vendas/{venda_id}")
+def delete_venda(venda_id: int):
+    vendas.delete_venda(venda_id)
+    return {"ok": True}
+
+
+@router.post("/vendas/csv")
+def importar_csv(body: CsvBody):
+    if not body.csv.strip():
+        raise HTTPException(status_code=400, detail="CSV vazio.")
+    try:
+        return vendas.importar_csv(body.csv)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# Conversões GCLID (upload offline ao Google Ads)
+# ---------------------------------------------------------------------------
+
+
+@router.post("/vendas/{venda_id}/conversao")
+def upload_conversao(venda_id: int):
+    venda = vendas.get_venda(venda_id)
+    if venda["conversao_status"] == "enviada":
+        raise HTTPException(status_code=400, detail="Conversão desta venda já foi enviada.")
+    try:
+        resultado = gads.upload_conversao(venda["gclid"], venda["valor"], venda["created_at"])
+    except LLMError as exc:
+        vendas.marcar_conversao(venda_id, "erro", str(exc))
+        raise HTTPException(status_code=400, detail=str(exc))
+    vendas.marcar_conversao(venda_id, "enviada")
+    return {"ok": True, "venda": vendas.get_venda(venda_id), "resultado": resultado}
+
+
+@router.post("/vendas/conversoes/upload")
+def upload_conversoes_pendentes():
+    """Envia todas as vendas aprovadas com GCLID cuja conversão ainda está pendente."""
+    enviadas = []
+    erros = []
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT * FROM vendas WHERE status = 'aprovada' AND gclid != '' AND conversao_status != 'enviada' ORDER BY id"
+        ).fetchall()
+    for row in rows:
+        venda = row_to_dict(row)
+        try:
+            gads.upload_conversao(venda["gclid"], venda["valor"], venda["created_at"])
+            vendas.marcar_conversao(venda["id"], "enviada")
+            enviadas.append(venda["id"])
+        except LLMError as exc:
+            vendas.marcar_conversao(venda["id"], "erro", str(exc))
+            erros.append(f"#{venda['id']}: {exc}")
+    return {"enviadas": enviadas, "erros": erros}
+
+
+# ---------------------------------------------------------------------------
+# Webhooks de vendas (públicos — POST das plataformas de afiliados)
+# ---------------------------------------------------------------------------
+
+
+@router.options("/webhook/sale/{fonte}")
+def webhook_options(fonte: str):
+    return Response(
+        status_code=204,
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "POST, OPTIONS",
+            "Access-Control-Allow-Headers": "*",
+        },
+    )
+
+
+@router.post("/webhook/sale/{fonte}")
+async def webhook_sale(fonte: str, request: Request):
+    fonte = fonte.lower()
+    if fonte not in WEBHOOK_FONTES:
+        raise HTTPException(status_code=404, detail=f"Fonte desconhecida. Suportadas: {', '.join(WEBHOOK_FONTES)}")
+    raw = await request.body()
+    payload = None
+    try:
+        parsed = json.loads(raw)
+        if isinstance(parsed, dict):
+            payload = parsed
+    except Exception:
+        pass
+    if payload is None:
+        # Plataformas que postam em application/x-www-form-urlencoded
+        from urllib.parse import parse_qs
+
+        form = parse_qs(raw.decode("utf-8", errors="replace"))
+        payload = {key: values[0] if len(values) == 1 else values for key, values in form.items()}
+    if not payload:
+        raise HTTPException(status_code=400, detail="Payload vazio ou não reconhecido (envie JSON ou form-urlencoded).")
+    try:
+        data = vendas.parse_webhook(fonte, payload)
+    except Exception as exc:  # noqa: BLE001
+        raise HTTPException(status_code=400, detail=f"Payload não processado: {exc}")
+    venda = vendas.registrar_venda(data)
+    return Response(
+        content=json.dumps({"ok": True, "id": venda["id"]}, ensure_ascii=False),
+        media_type="application/json",
+        headers={"Access-Control-Allow-Origin": "*"},
+    )

package/app/main.py

@@ -13,11 +13,12 @@ from pydantic import BaseModel
 
 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
+from .services.store import PRODMAKER_HOME, STORAGE, STATE, ensure_state_dir, get_master_code, get_settings, save_settings
 
-APP_VERSION = "0.1.06"
+APP_VERSION = "0.1.08"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
+MASTER_ALIAS = "admin"
 
 DIST_DIR = Path(__file__).resolve().parent.parent / "frontend" / "dist"
 LEGAL_DIR = Path(__file__).resolve().parent.parent / "legal"
@@ -29,12 +30,14 @@ 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
+from .api import vendas as vendas_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)
+app.include_router(vendas_router.router)
 
 ensure_db()
 
@@ -86,12 +89,22 @@ class LoginBody(BaseModel):
     activation_code: str
 
 
+def is_master_code(code: str) -> bool:
+    """Código Mestre (MASTER_CODE) ou o alias 'admin' liberam o login com qualquer e-mail."""
+    return code == get_master_code() or code.strip().lower() == MASTER_ALIAS
+
+
 @app.post("/api/auth/login")
 def auth_login(body: LoginBody, response: Response):
     email = body.email.strip()
     code = body.activation_code.strip()
-    if "@" not in email or len(code) < 4:
-        raise HTTPException(status_code=400, detail="E-mail inválido ou código de ativação muito curto (mínimo 4 caracteres).")
+    if "@" not in email:
+        raise HTTPException(status_code=400, detail="Informe um e-mail válido.")
+    if not is_master_code(code):
+        raise HTTPException(
+            status_code=400,
+            detail="Código de ativação inválido. Use o Código de Ativação Mestre impresso no terminal ao iniciar o ProdMaker (ou digite 'admin').",
+        )
     ensure_state_dir()
     license_path = STATE / "license.json"
     if not license_path.exists():
@@ -231,7 +244,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.6"}
+    return {"version": APP_VERSION, "canonical": "0.1.8"}
 
 
 @app.get("/api/settings")

package/app/services/clone.py

@@ -1,12 +1,16 @@
 """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."""
+    try:
+        import httpx
+        from bs4 import BeautifulSoup
+    except ImportError as exc:
+        raise LLMError(
+            f"Dependência de clonagem ausente ({exc.name}) — rode 'prodmaker install' para concluir a instalação."
+        ) from exc
     if not url.strip().startswith(("http://", "https://")):
         raise LLMError("Informe uma URL válida (http/https) para clonar.")
     try:

package/app/services/database.py

@@ -97,6 +97,33 @@ def ensure_db() -> None:
             )
             """
         )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS vendas (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                fonte TEXT NOT NULL DEFAULT 'manual',
+                produto_id INTEGER,
+                produto_nome TEXT NOT NULL DEFAULT '',
+                transacao_id TEXT NOT NULL DEFAULT '',
+                comprador_email TEXT NOT NULL DEFAULT '',
+                valor REAL NOT NULL DEFAULT 0,
+                comissao REAL NOT NULL DEFAULT 0,
+                gclid TEXT NOT NULL DEFAULT '',
+                utm_source TEXT NOT NULL DEFAULT '',
+                utm_medium TEXT NOT NULL DEFAULT '',
+                utm_campaign TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'aprovada',
+                conversao_status TEXT NOT NULL DEFAULT 'pendente',
+                conversao_erro TEXT NOT NULL DEFAULT '',
+                gclid_match TEXT NOT NULL DEFAULT '',
+                raw TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_gclid ON vendas (gclid)")
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_created ON vendas (created_at)")
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_visitas_gclid ON visitas (gclid)")
         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

@@ -1,8 +1,6 @@
 """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"
@@ -56,6 +54,8 @@ def verificar_dominio(nome: str) -> dict:
 
     token = _cloudflare_token()
     if token:
+        import httpx
+
         try:
             with httpx.Client(timeout=30.0) as client:
                 response = client.get(f"{CF_BASE}/zones", headers={"Authorization": f"Bearer {token}"}, params={"name": nome})

package/app/services/gads.py

@@ -0,0 +1,109 @@
+"""Google Ads — upload de conversões offline (click conversions via GCLID).
+
+Implementação enxuta via REST (httpx), sem SDK pesado:
+1. refresh_token -> access_token (OAuth2)
+2. POST /{version}/customers/{customer_id}:uploadClickConversions
+
+Best-effort: a versão da API é configurável (settings.api_keys['google-ads'].api_version,
+default v22) e erros da API são devolvidos com attribution clara.
+"""
+import time
+
+import httpx
+
+from .llm import LLMError
+from .store import get_settings
+
+DEFAULT_API_VERSION = "v22"
+TOKEN_URL = "https://oauth2.googleapis.com/token"
+ADS_BASE = "https://googleads.googleapis.com"
+
+
+def _google_ads_config() -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("google-ads") or {}
+    return {
+        "developer_token": (keys.get("developer_token") or "").strip(),
+        "client_id": (keys.get("client_id") or "").strip(),
+        "client_secret": (keys.get("client_secret") or "").strip(),
+        "refresh_token": (keys.get("refresh_token") or "").strip(),
+        "customer_id": (keys.get("customer_id") or "").strip().replace("-", ""),
+        "conversion_action": (keys.get("conversion_action") or "").strip(),
+        "api_version": (keys.get("api_version") or "").strip() or DEFAULT_API_VERSION,
+    }
+
+
+def _access_token(client_id: str, client_secret: str, refresh_token: str) -> str:
+    try:
+        response = httpx.post(
+            TOKEN_URL,
+            data={
+                "client_id": client_id,
+                "client_secret": client_secret,
+                "refresh_token": refresh_token,
+                "grant_type": "refresh_token",
+            },
+            timeout=30.0,
+        )
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com o OAuth do Google: {exc}", provider="google-ads", transient=True) from exc
+    if response.status_code != 200:
+        raise LLMError(
+            f"Google OAuth rejeitou as credenciais ({response.status_code}): {response.text[:200]} — confira client_id/client_secret/refresh_token em Chaves de API.",
+            provider="google-ads",
+        )
+    return (response.json() or {}).get("access_token", "")
+
+
+def upload_conversao(gclid: str, valor: float, ocorrido_em: str | None = None, currency: str = "BRL") -> dict:
+    """Envia uma conversão offline (GCLID) ao Google Ads. Retorna dict de resultado."""
+    config = _google_ads_config()
+    missing = [field for field in ("developer_token", "client_id", "client_secret", "refresh_token", "customer_id", "conversion_action") if not config[field]]
+    if missing:
+        raise LLMError(
+            "Conversões GCLID requerem Google Ads configurado em Chaves de API: " + ", ".join(missing) + ".",
+            provider="google-ads",
+        )
+    if not gclid:
+        raise LLMError("Venda sem GCLID — não é possível enviar conversão offline.", provider="google-ads")
+
+    try:
+        access_token = _access_token(config["client_id"], config["client_secret"], config["refresh_token"])
+    except LLMError:
+        raise
+    if not access_token:
+        raise LLMError("OAuth do Google não devolveu access_token.", provider="google-ads")
+
+    ocorrido_em = ocorrido_em or time.strftime("%Y-%m-%d %H:%M:%S%z")
+    if "%z" in ocorrido_em:
+        # Formato esperado pelo Google Ads: yyyy-mm-dd hh:mm:ss+|-hh:mm
+        ocorrido_em = ocorrido_em.replace("+0000", "+00:00")
+        if len(ocorrido_em) >= 5 and ocorrido_em[-5] in "+-":
+            ocorrido_em = ocorrido_em[:-2] + ":" + ocorrido_em[-2:]
+    url = f"{ADS_BASE}/{config['api_version']}/customers/{config['customer_id']}:uploadClickConversions"
+    body = {
+        "conversions": [
+            {
+                "gclid": gclid,
+                "conversionAction": config["conversion_action"],
+                "conversionDateTime": ocorrido_em,
+                "conversionValue": valor,
+                "currencyCode": currency,
+            }
+        ],
+        "partialFailure": True,
+    }
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "developer-token": config["developer_token"],
+        "Content-Type": "application/json",
+    }
+    try:
+        response = httpx.post(url, headers=headers, json=body, timeout=60.0)
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com a Google Ads API: {exc}", provider="google-ads", transient=True) from exc
+    if response.status_code == 200:
+        return {"ok": True, "resultado": response.json()}
+    raise LLMError(
+        f"Google Ads API respondeu {response.status_code}: {response.text[:300]} (API {config['api_version']}).",
+        provider="google-ads",
+    )

package/app/services/gamma.py

@@ -4,8 +4,6 @@ Base URL configurável em Chaves de API (padrão https://api.gamma.app).
 """
 import time
 
-import httpx
-
 
 class GammaError(Exception):
     pass
@@ -16,6 +14,8 @@ def _headers(api_key: str) -> dict:
 
 
 def gerar_pdf_gamma(api_key: str, base_url: str, titulo: str, prompt: str, total_timeout: float = 600.0) -> bytes:
+    import httpx
+
     base = (base_url or "https://api.app.gamma").rstrip("/")
     started = time.time()
     with httpx.Client(timeout=60.0) as client:

package/app/services/pdf.py

@@ -2,8 +2,6 @@
 import re
 from pathlib import Path
 
-import markdown
-
 EMOJI_RE = re.compile("[\U00010000-\U0010FFFF]")
 
 A4_CSS = """
@@ -24,7 +22,13 @@ li { margin-bottom: 3pt; }
 
 def markdown_para_pdf(md_text: str, output_path: Path) -> Path:
     """Converte Markdown em PDF A4. Retorna o caminho do PDF gerado."""
-    from xhtml2pdf import pisa
+    try:
+        import markdown
+        from xhtml2pdf import pisa
+    except ImportError as exc:
+        raise RuntimeError(
+            f"Dependência de PDF ausente ({exc.name}) — rode 'prodmaker install' para concluir a instalação."
+        ) from exc
 
     clean = EMOJI_RE.sub("", md_text or "")
     body = markdown.markdown(clean, extensions=["extra", "toc"])

package/app/services/publish.py

@@ -5,8 +5,6 @@ está conectado a um projeto do Cloudflare Pages (conexão única, feita no pain
 """
 import base64
 
-import httpx
-
 from .llm import LLMError
 
 GITHUB_API = "https://api.github.com"
@@ -22,6 +20,8 @@ def _github_config() -> tuple[str, str]:
 
 
 def publicar_pagina(page_id: int, titulo: str, html: str) -> dict:
+    import httpx
+
     token, repo = _github_config()
     if not token or not repo:
         raise LLMError(

package/app/services/store.py

@@ -23,6 +23,16 @@ def ensure_state_dir() -> None:
     STATE.mkdir(parents=True, exist_ok=True)
 
 
+def get_master_code() -> str:
+    """Código de Ativação Mestre — aceito com qualquer e-mail no login local.
+
+    Pode ser sobrescrito pela variável de ambiente PRODMAKER_MASTER_CODE.
+    O alias literal 'admin' também é sempre aceito (ver app.main.is_master_code).
+    """
+    code = (os.environ.get("PRODMAKER_MASTER_CODE") or "").strip()
+    return code or "1234"
+
+
 def get_settings() -> dict:
     settings_path = STATE / "settings.json"
     if not settings_path.exists():