@danhachuel/prodmaker 0.1.15 → 0.1.16

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 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.16 — 2026-10-31
+
+- **Fase 12 — Billing Stripe + E-mail Marketing (AdsAcademy) + Supabase multi-tenant pronto.**
+- **Billing:** `seed/planos.json` (Local grátis / Lançador PRO R$97 / Escala AGENCY R$297),
+  página **Plano & Assinatura** com cards, e-mail de conta e botão Assinar (abre o
+  Checkout do Stripe em nova aba); `POST /api/billing/checkout`, `/api/billing/assinatura`,
+  `/api/billing/historico` e **webhook público** `/api/billing/webhook` com verificação
+  de assinatura HMAC-SHA256 (t=...,v1=...) processando checkout.session.completed,
+  invoice.paid e customer.subscription.deleted. Sem chaves Stripe o app segue 100%
+  liberado em modo local (nenhuma trava de pré-registo).
+- **E-mail Marketing (AdsAcademy):** sequências com gatilho (`venda_recebida` dispara
+  automaticamente a cada webhook de venda, `produto_salvo`, `manual`), variáveis
+  {{nome}}/{{produto}}/{{valor}}/{{link}}, envio pelo apprise já integrado (mailtos://,
+  tgram://...), editor de sequências, envio manual e histórico com status/erro. A
+  plataforma completa emareach fica como backlog da nuvem.
+- **Supabase multi-tenant:** `DATABASE_URL` agora também aceita o alias **`SUPABASE_DB_URL`**
+  (connection string do Supabase) mantendo SQLite como fallback — user_id já cobre as
+  15 tabelas; a ativação do multi-tenant depende apenas do Supabase Auth (backlog).
+- Novas tabelas: `assinaturas`, `email_sequencias`, `email_envios`.
+
 ## 0.1.15 — 2026-10-31
 
 - **Fase 11 — TikTok Ads real + Anti-Fraude AdsPixel (Redis).**

package/app/api/billing.py

@@ -0,0 +1,63 @@
+"""Billing — planos (seed), checkout Stripe, webhook público e status da assinatura."""
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import Response
+from pydantic import BaseModel
+
+from ..services import stripe_billing
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/billing", tags=["billing"])
+
+
+class CheckoutBody(BaseModel):
+    plano_id: str
+    email: str
+
+
+@router.get("/planos")
+def planos():
+    return stripe_billing.planos_local()
+
+
+@router.get("/assinatura")
+def assinatura():
+    return stripe_billing.assinatura_atual()
+
+
+@router.get("/historico")
+def historico():
+    return stripe_billing.historico()
+
+
+@router.post("/checkout")
+def checkout(body: CheckoutBody, request: Request):
+    base = f"{request.url.scheme}://{request.headers.get('host', 'localhost:8188')}"
+    try:
+        return stripe_billing.criar_checkout(
+            body.plano_id,
+            body.email,
+            f"{base}/configuracoes?checkout=ok",
+            f"{base}/configuracoes?checkout=cancelado",
+        )
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.options("/webhook")
+def webhook_options():
+    return Response(status_code=204)
+
+
+@router.post("/webhook")
+async def webhook_stripe(request: Request):
+    """Webhook público do Stripe — verifica assinatura e processa o evento."""
+    body = await request.body()
+    if not stripe_billing.verificar_assinatura(body, request.headers.get("stripe-signature", "")):
+        raise HTTPException(status_code=400, detail="Assinatura do webhook inválida.")
+    import json
+
+    try:
+        evento = json.loads(body)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Payload inválido.")
+    return stripe_billing.processar_webhook(evento)

package/app/api/email_mkt.py

@@ -0,0 +1,65 @@
+"""E-mail Marketing (AdsAcademy) — sequências com gatilho, envio manual e histórico."""
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import email_mkt
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/email", tags=["email"])
+
+
+class SequenciaBody(BaseModel):
+    nome: str
+    gatilho: str
+    assunto: str
+    corpo: str
+    ativo: bool = True
+
+
+class EnviarBody(BaseModel):
+    sequencia_id: int
+    destinos: list = []
+    variaveis: dict = {}
+
+
+@router.get("/sequencias")
+def sequencias():
+    return email_mkt.listar()
+
+
+@router.post("/sequencias")
+def criar(body: SequenciaBody):
+    try:
+        return email_mkt.salvar(body.nome, body.gatilho, body.assunto, body.corpo, body.ativo)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.put("/sequencias/{sequencia_id}")
+def atualizar(sequencia_id: int, body: SequenciaBody):
+    try:
+        return email_mkt.salvar(body.nome, body.gatilho, body.assunto, body.corpo, body.ativo, sequencia_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.delete("/sequencias/{sequencia_id}")
+def remover(sequencia_id: int):
+    try:
+        email_mkt.remover(sequencia_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {"ok": True}
+
+
+@router.post("/enviar")
+def enviar(body: EnviarBody):
+    try:
+        return email_mkt.enviar_manual(body.sequencia_id, body.destinos, body.variaveis)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.get("/historico")
+def historico():
+    return email_mkt.historico()

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.15"
+APP_VERSION = "0.1.16"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 MASTER_ALIAS = "admin"
@@ -43,6 +43,8 @@ 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
+from .api import billing as billing_router  # noqa: E402
+from .api import email_mkt as email_mkt_router  # noqa: E402
 
 app.include_router(llm_router.router)
 app.include_router(infoprodutos_router.router)
@@ -62,6 +64,8 @@ app.include_router(invest_router.router)
 app.include_router(builder_router.router)
 app.include_router(fraude_router.router)
 app.include_router(tiktok_router.router)
+app.include_router(billing_router.router)
+app.include_router(email_mkt_router.router)
 
 ensure_db()
 
@@ -268,7 +272,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.15"}
+    return {"version": APP_VERSION, "canonical": "0.1.16"}
 
 
 @app.get("/api/settings")

package/app/services/database.py

@@ -221,6 +221,42 @@ TABLES = {
             created_at TEXT NOT NULL
         )
     """,
+    "assinaturas": """
+        CREATE TABLE IF NOT EXISTS assinaturas (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id TEXT NOT NULL DEFAULT '',
+            plano TEXT NOT NULL DEFAULT '',
+            email TEXT NOT NULL DEFAULT '',
+            stripe_ref TEXT NOT NULL DEFAULT '',
+            status TEXT NOT NULL DEFAULT 'checkout',
+            current_period_end TEXT NOT NULL DEFAULT '',
+            created_at TEXT NOT NULL
+        )
+    """,
+    "email_sequencias": """
+        CREATE TABLE IF NOT EXISTS email_sequencias (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id TEXT NOT NULL DEFAULT '',
+            nome TEXT NOT NULL,
+            gatilho TEXT NOT NULL DEFAULT 'manual',
+            assunto TEXT NOT NULL,
+            corpo TEXT NOT NULL,
+            ativo INTEGER NOT NULL DEFAULT 1,
+            created_at TEXT NOT NULL
+        )
+    """,
+    "email_envios": """
+        CREATE TABLE IF NOT EXISTS email_envios (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id TEXT NOT NULL DEFAULT '',
+            sequencia_id INTEGER NOT NULL DEFAULT 0,
+            destino TEXT NOT NULL DEFAULT '',
+            assunto TEXT NOT NULL DEFAULT '',
+            status TEXT NOT NULL DEFAULT 'pendente',
+            erro TEXT NOT NULL DEFAULT '',
+            created_at TEXT NOT NULL
+        )
+    """,
 }
 
 ALL_TABLES = list(TABLES.keys())

package/app/services/dbengine.py

@@ -31,7 +31,8 @@ def row_to_dict(row) -> dict:
 
 
 def dsn() -> str | None:
-    return (os.environ.get("DATABASE_URL") or "").strip() or None
+    """Connection string do PostgreSQL — aceita DATABASE_URL ou SUPABASE_DB_URL."""
+    return (os.environ.get("DATABASE_URL") or os.environ.get("SUPABASE_DB_URL") or "").strip() or None
 
 
 def is_postgres() -> bool:

package/app/services/email_mkt.py

@@ -0,0 +1,146 @@
+"""E-mail Marketing / AdsAcademy — sequências transacionais via apprise.
+
+Emareach (plataforma completa self-hosted) fica como backlog da nuvem; aqui o
+motor honesto é o apprise já integrado: sequências com gatilho (venda recebida,
+produto salvo, manual), variáveis {{nome}}, {{produto}}, {{valor}}, {{link}} e
+histórico de envios. Sem canais configurados: erro claro, nunca silencioso.
+"""
+import re
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+
+
+def _render(texto: str, variaveis: dict) -> str:
+    for chave, valor in (variaveis or {}).items():
+        texto = texto.replace("{{" + chave + "}}", str(valor or ""))
+    return texto
+
+
+def listar(gatilho: str = "") -> list[dict]:
+    query = "SELECT * FROM email_sequencias"
+    params: tuple = ()
+    if gatilho:
+        query += " WHERE gatilho = ?"
+        params = (gatilho,)
+    query += " ORDER BY id DESC"
+    with get_db() as conn:
+        rows = conn.execute(query, params).fetchall()
+    return [row_to_dict(row) for row in rows]
+
+
+def salvar(nome: str, gatilho: str, assunto: str, corpo: str, ativo: bool = True, sequencia_id: int | None = None) -> dict:
+    if not nome.strip() or not assunto.strip() or not corpo.strip():
+        raise LLMError("Informe nome, assunto e corpo da sequência.")
+    if gatilho not in ("venda_recebida", "produto_salvo", "manual"):
+        raise LLMError("Gatilho inválido: use venda_recebida, produto_salvo ou manual.")
+    with get_db() as conn:
+        if sequencia_id:
+            cursor = conn.execute(
+                "UPDATE email_sequencias SET nome = ?, gatilho = ?, assunto = ?, corpo = ?, ativo = ? WHERE id = ?",
+                (nome.strip(), gatilho, assunto.strip(), corpo, bool(ativo), sequencia_id),
+            )
+            if cursor.rowcount == 0:
+                raise LLMError("Sequência não encontrada.")
+        else:
+            cursor = conn.execute(
+                "INSERT INTO email_sequencias (nome, gatilho, assunto, corpo, ativo, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+                (nome.strip(), gatilho, assunto.strip(), corpo, bool(ativo), now_str()),
+            )
+            sequencia_id = cursor.lastrowid
+        row = conn.execute("SELECT * FROM email_sequencias WHERE id = ?", (sequencia_id,)).fetchone()
+    return row_to_dict(row)
+
+
+def remover(sequencia_id: int) -> None:
+    with get_db() as conn:
+        cursor = conn.execute("DELETE FROM email_sequencias WHERE id = ?", (sequencia_id,))
+        if cursor.rowcount == 0:
+            raise LLMError("Sequência não encontrada.")
+
+
+def _variaveis_padrao() -> dict:
+    settings_nome = "cliente"
+    return {"nome": settings_nome, "produto": "seu produto", "valor": "", "link": ""}
+
+
+def aplicar_gatilho(gatilho: str, variaveis: dict, destinos: list[str] | None = None) -> dict:
+    """Dispara as sequências ativas do gatilho (usado pelos hooks de venda/produto)."""
+    enviados = []
+    erros = []
+    for sequencia in listar(gatilho):
+        if not sequencia["ativo"]:
+            continue
+        assunto = _render(sequencia["assunto"], variaveis)
+        corpo = _render(sequencia["corpo"], variaveis)
+        try:
+            _enviar(sequencia, destinos or [], assunto, corpo)
+            enviados.append(sequencia["id"])
+        except LLMError as exc:
+            _registrar_envio(sequencia["id"], "", assunto, "erro", str(exc))
+            erros.append(str(exc))
+    return {"enviados": enviados, "erros": erros}
+
+
+def enviar_manual(sequencia_id: int, destinos: list[str], variaveis: dict) -> dict:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM email_sequencias WHERE id = ?", (sequencia_id,)).fetchone()
+    if not row:
+        raise LLMError("Sequência não encontrada.")
+    sequencia = row_to_dict(row)
+    if not destinos:
+        raise LLMError("Informe ao menos um destino (URL apprise, ex.: mailtos://user:senha@smtp.com).")
+    assunto = _render(sequencia["assunto"], {**_variaveis_padrao(), **(variaveis or {})})
+    corpo = _render(sequencia["corpo"], {**_variaveis_padrao(), **(variaveis or {})})
+    _enviar(sequencia, destinos, assunto, corpo)
+    return {"ok": True, "assunto": assunto}
+
+
+def _enviar(sequencia: dict, destinos: list, assunto: str, corpo: str) -> None:
+    from . import notify
+
+    alvos = [str(item).strip() for item in (destinos or []) if str(item).strip()]
+    if not alvos:
+        config = notify.listar_config()
+        alvos = [item for item in (config.get("targets") or [])]
+    if not alvos:
+        erro = "Nenhum canal apprise configurado (settings.notifications.targets)."
+        _registrar_envio(sequencia["id"], "", assunto, "erro", erro)
+        raise LLMError(erro)
+    telegram = notify._telegram_target()
+    if telegram and telegram not in alvos:
+        alvos.insert(0, telegram)
+    try:
+        import apprise
+
+        apobj = apprise.Apprise()
+        validos = [alvo for alvo in alvos if apobj.add(alvo)]
+        if not validos:
+            erro = "Nenhum canal apprise válido."
+            _registrar_envio(sequencia["id"], ",".join(alvos), assunto, "erro", erro)
+            raise LLMError(erro)
+        if apobj.notify(title=assunto, body=corpo):
+            _registrar_envio(sequencia["id"], ",".join(validos), assunto, "enviada")
+        else:
+            erro = "apprise não conseguiu entregar."
+            _registrar_envio(sequencia["id"], ",".join(validos), assunto, "erro", erro)
+            raise LLMError(erro)
+    except ImportError as exc:
+        erro = f"apprise ausente ({exc.name}) — rode 'prodmaker install'."
+        _registrar_envio(sequencia["id"], "", assunto, "erro", erro)
+        raise LLMError(erro)
+
+
+def _registrar_envio(sequencia_id: int, destino: str, assunto: str, status: str, erro: str = "") -> None:
+    with get_db() as conn:
+        conn.execute(
+            "INSERT INTO email_envios (sequencia_id, destino, assunto, status, erro, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+            (sequencia_id, destino, assunto[:180], status, erro[:500], now_str()),
+        )
+
+
+def historico(limit: int = 50) -> dict:
+    with get_db() as conn:
+        envios = [row_to_dict(row) for row in conn.execute("SELECT * FROM email_envios ORDER BY id DESC LIMIT ?", (limit,))]
+        totais = {row["status"]: row["n"] for row in conn.execute("SELECT status, COUNT(*) AS n FROM email_envios GROUP BY status")}
+    return {"envios": envios, "totais": totais}

package/app/services/stripe_billing.py

@@ -0,0 +1,147 @@
+"""Stripe — planos, checkout sessions e webhooks de assinatura (infraestrutura pronta).
+
+Modo local primeiro: sem chaves Stripe, o app segue 100% liberado (nenhuma trava).
+Com stripe_secret_key + stripe_price_id configurados, o checkout e os webhooks
+passam a operar. Verificação de assinatura do webhook (t=...,v1=...) via HMAC-SHA256.
+"""
+import hashlib
+import hmac
+import json
+import time
+from pathlib import Path
+
+import httpx
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+from .store import get_settings, save_settings
+
+STRIPE_API = "https://api.stripe.com/v1"
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+
+
+def _keys() -> dict:
+    keys = (get_settings().get("api_keys") or {}).get("stripe") or {}
+    return {
+        "secret_key": (keys.get("secret_key") or "").strip(),
+        "webhook_secret": (keys.get("webhook_secret") or "").strip(),
+    }
+
+
+def planos_local() -> dict:
+    path = SEED_DIR / "planos.json"
+    if path.exists():
+        return json.loads(path.read_text(encoding="utf-8"))
+    return {"planos": [], "nota": "seed/planos.json ausente."}
+
+
+def _plano(plano_id: str) -> dict | None:
+    for plano in planos_local().get("planos") or []:
+        if plano.get("id") == plano_id:
+            return plano
+    return None
+
+
+def criar_checkout(plano_id: str, email: str, sucesso_url: str, cancelamento_url: str) -> dict:
+    config = _keys()
+    plano = _plano(plano_id)
+    if not plano:
+        raise LLMError(f"Plano '{plano_id}' não encontrado em seed/planos.json.")
+    price_id = (plano.get("stripe_price_id") or "").strip()
+    if not config["secret_key"] or not price_id:
+        raise LLMError(
+            "Assinatura requer Stripe configurado: stripe_secret_key e o stripe_price_id do plano "
+            "(em seed/planos.json / Chaves de API). Sem isso, o app segue liberado em modo local."
+        )
+    try:
+        response = httpx.post(
+            f"{STRIPE_API}/checkout/sessions",
+            headers={"Authorization": f"Bearer {config['secret_key']}"},
+            data={
+                "mode": "subscription",
+                "customer_email": email,
+                "client_reference_id": plano_id,
+                "line_items[0][price]": price_id,
+                "line_items[0][quantity]": "1",
+                "success_url": sucesso_url,
+                "cancel_url": cancelamento_url,
+            },
+            timeout=30.0,
+        )
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com o Stripe: {exc}", provider="stripe", transient=True) from exc
+    payload = response.json() or {}
+    if response.status_code >= 400:
+        raise LLMError(
+            f"Stripe rejeitou o checkout ({response.status_code}): {(payload.get('error') or {}).get('message', payload)}",
+            provider="stripe",
+        )
+    _registrar(plano_id, email, "checkout_criado", payload.get("id", ""), payload)
+    return {"ok": True, "checkout_url": payload.get("url"), "session_id": payload.get("id")}
+
+
+def verificar_assinatura(payload_body: bytes, cabecalho: str) -> bool:
+    """Stripe-Signature: t=<ts>,v1=<hmac_sha256(secret, ts.body)>"""
+    secret = _keys()["webhook_secret"]
+    if not secret:
+        return True  # sem segredo configurado não há como verificar localmente
+    partes = {}
+    for item in cabecalho.split(","):
+        key, _, valor = item.strip().partition("=")
+        partes[key] = valor
+    timestamp = partes.get("t", "")
+    assinatura = partes.get("v1", "")
+    if not timestamp or not assinatura:
+        return False
+    esperado = hmac.new(secret.encode(), f"{timestamp}.".encode() + payload_body, hashlib.sha256).hexdigest()
+    return hmac.compare_digest(esperado, assinatura)
+
+
+def processar_webhook(evento: dict) -> dict:
+    tipo = evento.get("type", "")
+    objeto = (evento.get("data") or {}).get("object") or {}
+    if tipo == "checkout.session.completed":
+        plano_id = objeto.get("client_reference_id") or ""
+        email = (objeto.get("customer_details") or {}).get("email") or objeto.get("customer_email") or ""
+        _registrar(plano_id, email, "assinatura_ativa", objeto.get("subscription") or objeto.get("id", ""), objeto)
+    elif tipo in ("customer.subscription.deleted", "customer.subscription.paused"):
+        _registrar("", "", "assinatura_cancelada", objeto.get("id", ""), objeto)
+    elif tipo == "invoice.paid":
+        _registrar("", "", "pagamento_aprovado", objeto.get("id", ""), objeto)
+    return {"ok": True, "tipo": tipo}
+
+
+def _registrar(plano_id: str, email: str, status: str, stripe_ref: str, payload: dict) -> None:
+    with get_db() as conn:
+        if status == "assinatura_ativa":
+            conn.execute(
+                "INSERT INTO assinaturas (plano, email, stripe_ref, status, current_period_end, created_at) VALUES (?, ?, ?, 'ativa', ?, ?)",
+                (plano_id, email, stripe_ref, time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(time.time() + 30 * 86400)), now_str()),
+            )
+        elif status == "assinatura_cancelada":
+            conn.execute("UPDATE assinaturas SET status = 'cancelada' WHERE stripe_ref = ?", (stripe_ref,))
+        elif status == "checkout_criado":
+            conn.execute(
+                "INSERT INTO assinaturas (plano, email, stripe_ref, status, current_period_end, created_at) VALUES (?, ?, ?, 'checkout', '', ?)",
+                (plano_id, email, stripe_ref, now_str()),
+            )
+
+
+def assinatura_atual() -> dict:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM assinaturas WHERE status IN ('ativa','checkout') ORDER BY id DESC LIMIT 1").fetchone()
+    config = _keys()
+    base = {
+        "stripe_configurado": bool(config["secret_key"]),
+        "modo": "local" if not config["secret_key"] else "cloud",
+        "recursos_liberados": True,  # regra: nenhuma trava de pré-registo no app local
+    }
+    if row:
+        base["assinatura"] = row_to_dict(row)
+    return base
+
+
+def historico(limit: int = 30) -> list[dict]:
+    with get_db() as conn:
+        rows = conn.execute("SELECT * FROM assinaturas ORDER BY id DESC LIMIT ?", (limit,)).fetchall()
+    return [row_to_dict(row) for row in rows]

package/app/services/vendas.py

@@ -224,6 +224,20 @@ def registrar_venda(data: dict) -> dict:
         f"{record.get('produto_nome') or 'Produto'} — R$ {record.get('valor')} ({record.get('fonte')})"
         + (f" · GCLID {record['gclid'][:20]}" if record.get("gclid") else ""),
     )
+
+    try:
+        from . import email_mkt
+
+        email_mkt.aplicar_gatilho(
+            "venda_recebida",
+            {
+                "nome": (record.get("comprador_email") or "cliente").split("@")[0],
+                "produto": record.get("produto_nome") or "seu produto",
+                "valor": record.get("valor") or "",
+            },
+        )
+    except Exception:
+        pass  # e-mail nunca quebra o registro da venda
     return record