@danhachuel/prodmaker 0.1.14 → 0.1.15

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 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.15 — 2026-10-31
+
+- **Fase 11 — TikTok Ads real + Anti-Fraude AdsPixel (Redis).**
+- **TikTok Ads (publicação automática):** `publish_tiktok.py` — troca do auth_code por
+  access_token/refresh_token (`POST /api/tiktok/token`) e criação de campanha + grupo
+  PAUSADOS via Marketing API v1.3 (objective CONVERSIONS, budget diário US$,
+  placement automático); passo final do criativo com instrução honesta quando não há
+  mídia. Erros da API atribuídos. Card TikTok em Chaves de API ganhou auth_code +
+  botão "Trocar auth_code por token". AdsCreator passa a publicar TikTok de verdade.
+- **Anti-Fraude (AdsPixel):** `fraude.py` seguindo o padrão do redis-datasets/fraud-detection —
+  **IP blacklist (Redis Cuckoo Filter)** + **click spamming (Sorted Set com janela de 60s e
+  limite de 10 cliques)**; **fallback SQLite automático sem Redis**; página **Anti-Fraude**
+  (/tracking/fraude) com status do motor, bloqueio/desbloqueio manual, cópia da lista e
+  métricas de spam 24h. O `/track` agora avalia IP bloqueado antes de gravar e o pixel
+  nunca quebra a página do visitante. Card **Redis** em Chaves de API (REDIS_URL).
+- OAuth Google Ads (item 1 da Fase 11) já estava entregue na 0.1.12.
+
 ## 0.1.14 — 2026-10-31
 
 - **Fase 10 — REVISÃO (fechamento das lacunas apontadas na criação de produto/PDF).**

package/app/api/ads.py

@@ -143,11 +143,9 @@ def campanhas_publicar(campanha_id: int):
         elif plataforma == "meta":
             resultado = publish_ads.publicar_meta(campanha)
         else:
-            resultado = {
-                "plataforma": "tiktok",
-                "etapas": [{"etapa": "manual", "observacao": "TikTok: siga o checklist do plano (formato 9:16 UGC) e crie manualmente no TikTok Ads Manager."}],
-                "observacao": "Plano manual — crie manualmente no TikTok Ads Manager.",
-            }
+            from ..services import publish_tiktok
+
+            resultado = publish_tiktok.publicar_campanha(campanha)
     except LLMError as exc:
         campaigns.marcar_publicada(campanha_id, {}, status="erro", erro=str(exc))
         raise HTTPException(status_code=400, detail=str(exc))

package/app/api/fraude.py

@@ -0,0 +1,35 @@
+"""Anti-Fraude (AdsPixel) — painel de IPs bloqueados, bloqueio/desbloqueio e resumo."""
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import fraude
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/fraude", tags=["anti-fraude"])
+
+
+class BloquearBody(BaseModel):
+    ip: str
+    motivo: str = "manual"
+
+
+@router.get("/resumo")
+def resumo():
+    return fraude.resumo()
+
+
+@router.post("/bloquear")
+def bloquear(body: BloquearBody):
+    try:
+        return fraude.bloquear_ip(body.ip, body.motivo)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.delete("/ips/{ip}")
+def desbloquear(ip: str):
+    try:
+        fraude.desbloquear_ip(ip)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {"ok": True}

package/app/api/tiktok.py

@@ -0,0 +1,16 @@
+"""TikTok Ads — troca do auth_code por access_token (1 clique)."""
+from fastapi import APIRouter, HTTPException
+
+from ..services.llm import LLMError
+from ..services.publish_tiktok import trocar_auth_code
+
+router = APIRouter(prefix="/api/tiktok", tags=["tiktok"])
+
+
+@router.post("/token")
+def token():
+    """Troca o auth_code salvo em Chaves de API por access_token + refresh_token."""
+    try:
+        return trocar_auth_code()
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))

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_master_code, get_settings, save_settings
 
-APP_VERSION = "0.1.14"
+APP_VERSION = "0.1.15"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 MASTER_ALIAS = "admin"
@@ -41,6 +41,8 @@ from .api import guias as guias_router  # noqa: E402
 from .api import contas as contas_router  # noqa: E402
 from .api import invest as invest_router  # noqa: E402
 from .api import builder as builder_router  # noqa: E402
+from .api import fraude as fraude_router  # noqa: E402
+from .api import tiktok as tiktok_router  # noqa: E402
 
 app.include_router(llm_router.router)
 app.include_router(infoprodutos_router.router)
@@ -58,6 +60,8 @@ app.include_router(guias_router.router)
 app.include_router(contas_router.router)
 app.include_router(invest_router.router)
 app.include_router(builder_router.router)
+app.include_router(fraude_router.router)
+app.include_router(tiktok_router.router)
 
 ensure_db()
 
@@ -264,7 +268,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.14"}
+    return {"version": APP_VERSION, "canonical": "0.1.15"}
 
 
 @app.get("/api/settings")
@@ -300,6 +304,20 @@ def track(request: Request):
     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"}
+
+    # Anti-fraude (AdsPixel): IP bloqueado nao entra no tracking; spam e sinalizado
+    from .services import fraude
+
+    try:
+        avaliacao = fraude.avaliar_visita(ip)
+        if avaliacao.get("bloqueado"):
+            # IP na blacklist: nao grava a visita (o pixel segue respondendo 204)
+            return Response(status_code=204, headers={"Access-Control-Allow-Origin": "*"})
+        if params.get("event") == "cta_click":
+            fraude.registrar_clique(ip, params.get("page", ""))
+    except Exception:
+        pass  # anti-fraude nunca quebra o pixel
+    extra_params = json.dumps({k: v for k, v in params.items() if k not in known}, ensure_ascii=False)
     try:
         with get_db() as conn:
             conn.execute(
@@ -314,7 +332,7 @@ def track(request: Request):
                     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),
+                    extra_params,
                     now_str(),
                 ),
             )

package/app/services/database.py

@@ -1,17 +1,17 @@
-"""Banco de dados — façade sobre dbengine (SQLite padrão, PostgreSQL/Supabase via DATABASE_URL).
+"""Banco de dados — fachada sobre dbengine (SQLite padrao, PostgreSQL/Supabase via DATABASE_URL).
 
-Esquema único para os dois engines. Todas as tabelas carregam `user_id` (preparação
-multi-tenant — hoje vazio). `ensure_db()` cria o que falta e aplica ALTERs de migração.
+Esquema unico para os dois engines. Todas as tabelas carregam `user_id` (preparacao
+multi-tenant — hoje vazio). `ensure_db()` cria o que falta e aplica ALTERs de migracao.
 """
 from .dbengine import (
     add_column_if_missing,
     is_postgres,
-    now_str,  # noqa: F401  (reexportado para os serviços)
-    row_to_dict,  # noqa: F401  (reexportado para os serviços)
+    now_str,  # noqa: F401  (reexportado para os servicos)
+    row_to_dict,  # noqa: F401  (reexportado para os servicos)
 )
 
 # ---------------------------------------------------------------------------
-# Esquema — SQLite DDL; para PostgreSQL as mesmas definições são traduzidas.
+# Esquema — SQLite DDL; para PostgreSQL as mesmas definicoes sao traduzidas.
 # ---------------------------------------------------------------------------
 
 TABLES = {
@@ -201,6 +201,26 @@ TABLES = {
             created_at TEXT NOT NULL
         )
     """,
+    "ips_bloqueados": """
+        CREATE TABLE IF NOT EXISTS ips_bloqueados (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id TEXT NOT NULL DEFAULT '',
+            ip TEXT NOT NULL,
+            motivo TEXT NOT NULL DEFAULT 'manual',
+            origem TEXT NOT NULL DEFAULT 'sqlite',
+            created_at TEXT NOT NULL
+        )
+    """,
+    "fraude_eventos": """
+        CREATE TABLE IF NOT EXISTS fraude_eventos (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id TEXT NOT NULL DEFAULT '',
+            ip TEXT NOT NULL,
+            page TEXT NOT NULL DEFAULT '',
+            created_epoch REAL NOT NULL DEFAULT 0,
+            created_at TEXT NOT NULL
+        )
+    """,
 }
 
 ALL_TABLES = list(TABLES.keys())
@@ -225,11 +245,9 @@ def ensure_db() -> None:
         else:
             for ddl in TABLES.values():
                 conn.execute(ddl)
-            # Migração: bancos criados antes da coluna user_id / da tabela investimentos
+            # Migracao: bancos criados antes da coluna user_id / da tabela investimentos
             for table in ALL_TABLES:
                 add_column_if_missing(conn, table, "user_id TEXT NOT NULL DEFAULT ''", "user_id")
-            if "investimentos" not in [row["name"] for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")]:
-                conn.execute(TABLES["investimentos"])
         conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_gclid ON vendas (gclid)")
         conn.execute("CREATE INDEX IF NOT EXISTS idx_visitas_gclid ON visitas (gclid)")
 

package/app/services/fraude.py

@@ -0,0 +1,174 @@
+"""Anti-Fraude do AdsPixel — padrão do redis-datasets/fraud-detection:
+IP blacklisting (Redis Cuckoo Filter) + click spamming (Redis Sorted Set).
+
+- Redis é OPCIONAL: sem Redis, tudo cai em SQLite local (tabelas ips_bloqueados /
+  fraude_eventos) — bloqueio e detecção continuam funcionando.
+- O pixel NUNCA quebra a página do visitante: avaliação em falha = segue normalmente.
+"""
+import json
+import os
+import time
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+from .store import get_settings
+
+CUCKOO_KEY = "prodmaker:ip_blacklist_cf"      # Redis Cuckoo Filter (IP_BLOCKED)
+SPAM_KEY = "prodmaker:click_spamming"          # Redis Sorted Set (IP -> timestamp)
+SPAM_JANELA_SEGUNDOS = int(os.environ.get("PRODMAKER_SPAM_JANELA") or "60")
+SPAM_LIMITE = int(os.environ.get("PRODMAKER_SPAM_LIMITE") or "10")
+
+
+def _redis_url() -> str | None:
+    env = (os.environ.get("REDIS_URL") or "").strip()
+    if env:
+        return env
+    keys = (get_settings().get("api_keys") or {}).get("redis") or {}
+    return (keys.get("url") or "").strip() or None
+
+
+def _redis():
+    url = _redis_url()
+    if not url:
+        return None
+    try:
+        import redis
+
+        client = redis.Redis.from_url(url, decode_responses=True, socket_timeout=2)
+        client.ping()
+        return client
+    except Exception:
+        return None  # sem Redis: fallback SQLite
+
+
+def redis_ativo() -> bool:
+    return _redis() is not None
+
+
+# ---------------------------------------------------------------------------
+# Blacklist (Cuckoo Filter quando há Redis; tabela local sempre)
+# ---------------------------------------------------------------------------
+
+
+def _bloqueados_locais() -> dict[str, str]:
+    with get_db() as conn:
+        rows = conn.execute("SELECT ip, motivo FROM ips_bloqueados ORDER BY id DESC").fetchall()
+    return {row["ip"]: row["motivo"] for row in rows}
+
+
+def bloquear_ip(ip: str, motivo: str = "manual") -> dict:
+    ip = (ip or "").strip()
+    if not ip:
+        raise LLMError("Informe o IP a bloquear.")
+    client = _redis()
+    if client:
+        try:
+            client.execute_command("CF.ADDR", CUCKOO_KEY, ip)
+        except Exception:
+            pass  # filtro ausente no servidor: fica só local
+    with get_db() as conn:
+        existe = conn.execute("SELECT id FROM ips_bloqueados WHERE ip = ?", (ip,)).fetchone()
+        if not existe:
+            conn.execute(
+                "INSERT INTO ips_bloqueados (ip, motivo, origem, created_at) VALUES (?, ?, ?, ?)",
+                (ip, motivo, "redis" if client else "sqlite", now_str()),
+            )
+    return {"ok": True, "ip": ip, "engine": "redis" if client else "sqlite"}
+
+
+def desbloquear_ip(ip: str) -> None:
+    with get_db() as conn:
+        cursor = conn.execute("DELETE FROM ips_bloqueados WHERE ip = ?", (ip.strip(),))
+        if cursor.rowcount == 0:
+            raise LLMError("IP não encontrado na lista de bloqueio.")
+
+
+def ip_bloqueado(ip: str) -> bool:
+    if not ip:
+        return False
+    client = _redis()
+    if client:
+        try:
+            resposta = client.execute_command("CF.EXISTS", CUCKOO_KEY, ip)
+            if isinstance(resposta, list):
+                resposta = resposta[0] if resposta else 0
+            if int(resposta):
+                return True
+        except Exception:
+            pass  # redis sem o módulo RedisBloom: cai no local
+    return (ip or "").strip() in _bloqueados_locais()
+
+
+# ---------------------------------------------------------------------------
+# Click spamming (Sorted Set quando há Redis)
+# ---------------------------------------------------------------------------
+
+
+def registrar_clique(ip: str, page: str = "") -> dict:
+    """Registra um clique e devolve {spam: bool, cliques_janela: N}."""
+    ip = (ip or "").strip()
+    if not ip:
+        return {"spam": False, "cliques_janela": 0, "bloqueado": False}
+    agora = time.time()
+    cliques = 0
+    client = _redis()
+    if client:
+        try:
+            member = f"{int(agora * 1000)}:{ip}"
+            pipeline = client.pipeline()
+            pipeline.execute_command("ZADD", SPAM_KEY, agora, member)
+            pipeline.execute_command("ZREMRANGEBYSCORE", SPAM_KEY, 0, agora - SPAM_JANELA_SEGUNDOS)
+            pipeline.execute_command(
+                "ZCOUNT", SPAM_KEY, (int((agora - SPAM_JANELA_SEGUNDOS) * 1000)), int(agora * 1000)
+            )
+            cliques = int(pipeline.execute()[-1])
+        except Exception:
+            cliques = _cliques_local(ip, agora, page)
+    else:
+        cliques = _cliques_local(ip, agora, page)
+    spam = cliques >= SPAM_LIMITE
+    return {"spam": spam, "cliques_janela": cliques, "bloqueado": ip_bloqueado(ip)}
+
+
+def _cliques_local(ip: str, agora: float, page: str = "") -> int:
+    with get_db() as conn:
+        conn.execute("DELETE FROM fraude_eventos WHERE created_epoch < ?", (agora - SPAM_JANELA_SEGUNDOS * 2,))
+        conn.execute("INSERT INTO fraude_eventos (ip, page, created_epoch, created_at) VALUES (?, ?, ?, ?)", (ip, page or "", agora, now_str()))
+        row = conn.execute(
+            "SELECT COUNT(*) AS n FROM fraude_eventos WHERE ip = ? AND created_epoch > ?",
+            (ip, agora - SPAM_JANELA_SEGUNDOS),
+        ).fetchone()
+    return int(row["n"])
+
+
+# ---------------------------------------------------------------------------
+# Painel / API
+# ---------------------------------------------------------------------------
+
+
+def resumo() -> dict:
+    bloqueados = _bloqueados_locais()
+    spam_24h = 0
+    with get_db() as conn:
+        row = conn.execute(
+            "SELECT COUNT(*) AS n FROM fraude_eventos WHERE created_at >= datetime('now', '-1 day') GROUP BY ip HAVING COUNT(*) >= ?",
+            (SPAM_LIMITE,),
+        ).fetchone()
+        spam_24h = row["n"] if row else 0
+    return {
+        "redis_ativo": redis_ativo(),
+        "ips_bloqueados": [
+            {"ip": ip, "motivo": motivo} for ip, motivo in bloqueados.items()
+        ],
+        "total_bloqueados": len(bloqueados),
+        "spam_ultimas_24h": spam_24h,
+        "janela_segundos": SPAM_JANELA_SEGUNDOS,
+        "limite_cliques": SPAM_LIMITE,
+    }
+
+
+def avaliar_visita(ip: str) -> dict:
+    """Chamado pelo /track: decide se a visita entra no tracking."""
+    if ip_bloqueado(ip):
+        return {"bloqueado": True, "motivo": _bloqueados_locais().get((ip or "").strip(), "blacklist")}
+    return {"bloqueado": False}

package/app/services/publish_ads.py

@@ -1,6 +1,7 @@
-"""Engines de publicação de campanhas — Google Ads (REST mutates) e Meta Ads (Marketing API).
+"""Engines de publicação de campanhas — Google Ads (REST mutates), Meta Ads
+(Marketing API) e TikTok Ads (Marketing API OAuth).
 
-Best-effort com erros atribuídos por etapa. TikTok permanece manual (guia no plano).
+Best-effort com erros atribuídos por etapa. Tudo é criado PAUSADO para revisão.
 """
 import httpx
 

package/app/services/publish_tiktok.py

@@ -0,0 +1,155 @@
+"""TikTok Ads — publicação automática via Marketing API (OAuth + campaign/adgroup).
+
+Fluxo: auth_code (do portal TikTok) -> access_token (24h) -> refresh_token ->
+campanha PAUSADA -> grupo de anúncios. O criativo (vídeo/imagem) exige upload de
+arquivo local: sem vídeo informado, a campanha e o grupo são criados e o passo
+final (anúncio) fica como instrução honesta — nenhum hack é inventado.
+"""
+import time
+
+import httpx
+
+from .llm import LLMError
+from .store import get_settings, save_settings
+
+TIKTOK_API = "https://business-api.tiktok.com/open_api/v1.3"
+
+
+def _keys() -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("tiktok") or {}
+    return {
+        "app_id": (keys.get("app_id") or "").strip(),
+        "app_secret": (keys.get("app_secret") or "").strip(),
+        "auth_code": (keys.get("auth_code") or "").strip(),
+        "access_token": (keys.get("access_token") or "").strip(),
+        "refresh_token": (keys.get("refresh_token") or "").strip(),
+        "advertiser_id": (keys.get("advertiser_id") or "").strip(),
+    }
+
+
+def _check(required: list[str]) -> None:
+    config = _keys()
+    missing = [field for field in required if not config[field]]
+    if missing:
+        raise LLMError(
+            "TikTok Ads requer em Chaves de API: " + ", ".join(missing) + ".",
+            provider="tiktok",
+        )
+
+
+def trocar_auth_code() -> dict:
+    """Troca o auth_code (portal TikTok) por access_token + refresh_token."""
+    config = _keys()
+    _check(["app_id", "app_secret", "auth_code"])
+    try:
+        response = httpx.post(
+            f"{TIKTOK_API}/oauth2/access_token/",
+            json={"app_id": config["app_id"], "secret": config["app_secret"], "auth_code": config["auth_code"]},
+            timeout=30.0,
+        )
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com o TikTok: {exc}", provider="tiktok", transient=True) from exc
+    payload = response.json() or {}
+    if payload.get("code") != 0:
+        raise LLMError(
+            f"TikTok rejeitou o auth_code ({payload.get('code')}): {payload.get('message')} — gere um novo código no portal.",
+            provider="tiktok",
+        )
+    data = payload.get("data") or {}
+    access_token = data.get("access_token")
+    refresh_token = data.get("refresh_token")
+    advertiser_ids = data.get("advertiser_ids") or []
+    if not access_token:
+        raise LLMError("TikTok não devolveu access_token.", provider="tiktok")
+
+    settings = get_settings()
+    tiktok = settings.setdefault("api_keys", {}).setdefault("tiktok", {})
+    tiktok["access_token"] = access_token
+    tiktok["refresh_token"] = refresh_token
+    tiktok["connected_at"] = time.strftime("%Y-%m-%dT%H:%M:%S")
+    if advertiser_ids and not (tiktok.get("advertiser_id") or "").strip():
+        tiktok["advertiser_id"] = str(advertiser_ids[0])
+    save_settings(settings)
+    return {
+        "ok": True,
+        "connected_at": tiktok["connected_at"],
+        "advertiser_ids": advertiser_ids,
+        "advertiser_id": tiktok.get("advertiser_id"),
+    }
+
+
+def _post(path: str, body: dict, token: str) -> dict:
+    try:
+        response = httpx.post(
+            f"{TIKTOK_API}{path}",
+            headers={"Access-Token": token, "Content-Type": "application/json"},
+            json=body,
+            timeout=60.0,
+        )
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com o TikTok: {exc}", provider="tiktok", transient=True) from exc
+    payload = response.json() or {}
+    if payload.get("code") != 0:
+        raise LLMError(
+            f"TikTok API ({path}) {payload.get('code')}: {payload.get('message')}",
+            provider="tiktok",
+        )
+    return payload.get("data") or {}
+
+
+def publicar_campanha(campanha: dict) -> dict:
+    """Cria campanha (PAUSADA) + grupo de anúncios. Criativo final = instrução honesta."""
+    config = _keys()
+    _check(["app_id", "app_secret", "advertiser_id", "access_token"])
+    plano = campanha.get("plano") or {}
+    nome = campanha["nome"]
+    orcamento_dia = float(campanha.get("orcamento_diario") or 0)
+    if orcamento_dia <= 0:
+        orcamento_dia = 15.0
+    budget_cents = int(orcamento_dia * 100)
+
+    etapas = []
+    campaign = _post(
+        "/campaign/create/",
+        {
+            "advertiser_id": config["advertiser_id"],
+            "campaign_name": nome,
+            "objective_type": "CONVERSIONS",
+            "budget_mode": "BUDGET_MODE_DAY",
+            "budget": budget_cents,
+            "operation_status": "DISABLE",
+        },
+        config["access_token"],
+    )
+    campaign_id = campaign.get("campaign_id")
+    etapas.append({"etapa": "campanha", "id": campaign_id, "status": "PAUSED"})
+
+    adgroup = _post(
+        "/adgroup/create/",
+        {
+            "advertiser_id": config["advertiser_id"],
+            "campaign_id": campaign_id,
+            "adgroup_name": f"{nome} — Grupo 1",
+            "placement_type": "PLACEMENT_TYPE_AUTOMATIC",
+            "budget_mode": "BUDGET_MODE_DAY",
+            "budget": budget_cents,
+            "schedule_type": "SCHEDULE_START_END",
+            "optimization_goal": "CONVERT",
+            "billing_event": "OCPM",
+            "operation_status": "DISABLE",
+        },
+        config["access_token"],
+    )
+    adgroup_id = adgroup.get("adgroup_id")
+    etapas.append({"etapa": "grupo", "id": adgroup_id, "status": "PAUSED"})
+
+    return {
+        "plataforma": "tiktok",
+        "etapas": etapas,
+        "campaign": campaign_id,
+        "adgroup": adgroup_id,
+        "observacao": (
+            "Campanha e grupo criados PAUSADOS. Passo final (anúncio): suba o vídeo vertical 9:16 "
+            "em TikTok Ads Manager ou use o upload de criativo — o ProdMaker avisa quando não há mídia informada."
+        ),
+    }