@danhachuel/prodmaker 0.1.9 → 0.1.10

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 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.10 — 2026-10-30
+
+- **Parte 8 — AdsBot (Lançamento Assistido) + Dashboard real + Notificações (adsNotify).**
+- **AdsBot:** wizard de 6 etapas (Produto → Página → Publicar → Campanhas → Tracking →
+  Conclusão) com progresso salvo no banco e retomável; marcação de etapas concluídas;
+  **Relatório de Lançamento** (produto + resumo da análise IA, páginas vinculadas com URLs
+  públicas, campanhas com CPA/orçamento e o checklist final do seed).
+- **Dashboard com dados reais:** conversões, receita, comissão, visitas, produtos, páginas,
+  campanhas e infoprodutos; banner do lançamento em andamento ("faltam X passos" — efeito
+  meta); últimas vendas e últimas páginas. ROAS explicitamente ausente até haver registro
+  de investimento (nunca inventado).
+- **Notificações (adsNotify):** toggles por evento (venda recebida, campanha publicada,
+  página publicada, infoproduto gerado), canais apprise por URL (Telegram entra
+  automaticamente quando Bot Token + Chat ID estão em Chaves de API), teste de envio e
+  histórico local com status/erro. Hooks disparados nos fluxos reais — falha de envio
+  nunca quebra a operação principal.
+- Novas tabelas: `lancamentos`, `notificacoes`. Novos endpoints: `/api/lancamentos/*`,
+  `/api/notificacoes/*`, `/api/dashboard`.
+
 ## 0.1.09 — 2026-10-30
 
 - **Parte 7 — AdsWords & AdsCreator (palavras-chave e campanhas).**

package/app/api/dashboard.py

@@ -0,0 +1,67 @@
+"""Dashboard — agregação de dados reais de todos os módulos."""
+from fastapi import APIRouter
+
+from ..services.database import get_db
+
+router = APIRouter(prefix="/api/dashboard", tags=["dashboard"])
+
+
+@router.get("")
+def dashboard():
+    with get_db() as conn:
+        produtos = {
+            "total": conn.execute("SELECT COUNT(*) AS n FROM produtos").fetchone()["n"],
+            "aprovados": conn.execute("SELECT COUNT(*) AS n FROM produtos WHERE status = 'aprovado'").fetchone()["n"],
+            "em_analise": conn.execute("SELECT COUNT(*) AS n FROM produtos WHERE status = 'em_analise'").fetchone()["n"],
+        }
+        paginas = {
+            "total": conn.execute("SELECT COUNT(*) AS n FROM paginas").fetchone()["n"],
+            "publicadas": conn.execute("SELECT COUNT(*) AS n FROM paginas WHERE status = 'publicada'").fetchone()["n"],
+            "rascunho": conn.execute("SELECT COUNT(*) AS n FROM paginas WHERE status != 'publicada'").fetchone()["n"],
+        }
+        campanhas = {
+            "total": conn.execute("SELECT COUNT(*) AS n FROM campanhas").fetchone()["n"],
+            "publicadas": conn.execute("SELECT COUNT(*) AS n FROM campanhas WHERE status = 'publicada'").fetchone()["n"],
+            "rascunho": conn.execute("SELECT COUNT(*) AS n FROM campanhas WHERE status = 'rascunho'").fetchone()["n"],
+            "erro": conn.execute("SELECT COUNT(*) AS n FROM campanhas WHERE status = 'erro'").fetchone()["n"],
+        }
+        vendas_row = conn.execute(
+            "SELECT COUNT(*) AS n, COALESCE(SUM(valor),0) AS receita, COALESCE(SUM(comissao),0) AS comissao FROM vendas WHERE status = 'aprovada'"
+        ).fetchone()
+        infoprodutos = {"total": conn.execute("SELECT COUNT(*) AS n FROM infoprodutos").fetchone()["n"]}
+        tracking = {
+            "visitas": conn.execute("SELECT COUNT(*) AS n FROM visitas WHERE event = 'pageview'").fetchone()["n"],
+            "cliques": conn.execute("SELECT COUNT(*) AS n FROM visitas WHERE event = 'cta_click'").fetchone()["n"],
+            "conversoes_pendentes": conn.execute(
+                "SELECT COUNT(*) AS n FROM vendas WHERE status = 'aprovada' AND gclid != '' AND conversao_status != 'enviada'"
+            ).fetchone()["n"],
+        }
+        ultimas_vendas = [
+            {key: row[key] for key in row.keys()}
+            for row in conn.execute("SELECT id, produto_nome, valor, fonte, status, created_at FROM vendas ORDER BY id DESC LIMIT 5")
+        ]
+        ultimas_paginas = [
+            {key: row[key] for key in row.keys()}
+            for row in conn.execute("SELECT id, titulo, tipo, status, created_at FROM paginas ORDER BY id DESC LIMIT 5")
+        ]
+
+    from ..services.lancamentos import atual, progresso
+    lancamento_atual = atual()
+    progresso_atual = progresso(lancamento_atual) if lancamento_atual else None
+
+    return {
+        "produtos": produtos,
+        "paginas": paginas,
+        "campanhas": campanhas,
+        "infoprodutos": infoprodutos,
+        "vendas": {
+            "total": vendas_row["n"],
+            "receita": round(vendas_row["receita"], 2),
+            "comissao": round(vendas_row["comissao"], 2),
+        },
+        "tracking": tracking,
+        "ultimas_vendas": ultimas_vendas,
+        "ultimas_paginas": ultimas_paginas,
+        "lancamento": lancamento_atual,
+        "progresso": progresso_atual,
+    }

package/app/api/infoprodutos.py

@@ -88,7 +88,16 @@ def create_infoproduto(body: InfoprodutoBody):
                 (provider, rel_pdf, rel_md, record_id),
             )
             row = conn.execute("SELECT * FROM infoprodutos WHERE id = ?", (record_id,)).fetchone()
-        return row_to_dict(row)
+        record = row_to_dict(row)
+
+        from ..services.notify import notify_event
+
+        notify_event(
+            "infoproduto_gerado",
+            "Infoproduto gerado",
+            f"{record['titulo']} ({record['formato']}) — {record['provider']}",
+        )
+        return record
     except (LLMError, gamma_service.GammaError, RuntimeError) as exc:
         with get_db() as conn:
             conn.execute("DELETE FROM infoprodutos WHERE id = ?", (record_id,))

package/app/api/lancamentos.py

@@ -0,0 +1,81 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import lancamentos
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/lancamentos", tags=["lancamentos"])
+
+
+class IniciarBody(BaseModel):
+    produto_id: int | None = None
+
+
+class EtapaBody(BaseModel):
+    etapa: int
+    dados: dict = {}
+
+
+class ProdutoBody(BaseModel):
+    produto_id: int
+
+
+@router.get("/etapas")
+def etapas():
+    return lancamentos.ETAPAS
+
+
+@router.get("/atual")
+def lancamento_atual():
+    return lancamentos.atual()
+
+
+@router.get("")
+def listar():
+    return lancamentos.listar()
+
+
+@router.post("")
+def iniciar(body: IniciarBody):
+    return lancamentos.iniciar(body.produto_id)
+
+
+@router.post("/{lancamento_id}/etapa")
+def salvar_etapa(lancamento_id: int, body: EtapaBody):
+    try:
+        return lancamentos.salvar_etapa(lancamento_id, body.etapa, body.dados)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/{lancamento_id}/produto")
+def definir_produto(lancamento_id: int, body: ProdutoBody):
+    try:
+        return lancamentos.definir_produto(lancamento_id, body.produto_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+
+@router.get("/{lancamento_id}/relatorio")
+def relatorio(lancamento_id: int):
+    try:
+        return lancamentos.relatorio(lancamento_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+
+@router.get("/{lancamento_id}/progresso")
+def progresso(lancamento_id: int):
+    try:
+        record = lancamentos._get_row(lancamento_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return lancamentos.progresso(record)
+
+
+@router.post("/{lancamento_id}/concluir")
+def concluir(lancamento_id: int):
+    try:
+        return lancamentos.concluir(lancamento_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))

package/app/api/notificacoes.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import notify
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/notificacoes", tags=["notificacoes"])
+
+
+class ConfigBody(BaseModel):
+    eventos: dict = {}
+    targets: list = []
+
+
+class TesteBody(BaseModel):
+    titulo: str = "Teste ProdMaker"
+    mensagem: str = "Notificação de teste do ProdMaker."
+
+
+@router.get("")
+def config():
+    return notify.listar_config()
+
+
+@router.put("")
+def salvar(body: ConfigBody):
+    return notify.salvar_config(body.eventos, body.targets)
+
+
+@router.get("/historico")
+def historico():
+    return notify.historico()
+
+
+@router.post("/teste")
+def teste(body: TesteBody):
+    try:
+        return notify.enviar("teste", body.titulo, body.mensagem, forcar=True)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))

package/app/api/paginas.py

@@ -130,6 +130,14 @@ def publicar(page_id: int):
         )
     updated = _get_or_404(page_id)
     updated["publish_result"] = result
+
+    from ..services.notify import notify_event
+
+    notify_event(
+        "pagina_publicada",
+        "Página publicada",
+        f"{updated['titulo']} — {result['pages_url']}",
+    )
     return updated
 
 

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.09"
+APP_VERSION = "0.1.10"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 MASTER_ALIAS = "admin"
@@ -32,6 +32,9 @@ 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
 from .api import ads as ads_router  # noqa: E402
+from .api import lancamentos as lancamentos_router  # noqa: E402
+from .api import notificacoes as notificacoes_router  # noqa: E402
+from .api import dashboard as dashboard_router  # noqa: E402
 
 app.include_router(llm_router.router)
 app.include_router(infoprodutos_router.router)
@@ -40,6 +43,9 @@ app.include_router(dominios_router.router)
 app.include_router(tracking_router.router)
 app.include_router(vendas_router.router)
 app.include_router(ads_router.router)
+app.include_router(lancamentos_router.router)
+app.include_router(notificacoes_router.router)
+app.include_router(dashboard_router.router)
 
 ensure_db()
 
@@ -246,7 +252,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.9"}
+    return {"version": APP_VERSION, "canonical": "0.1.10"}
 
 
 @app.get("/api/settings")

package/app/services/campaigns.py

@@ -144,6 +144,11 @@ def marcar_publicada(campanha_id: int, resultado: dict, status: str = "publicada
             "UPDATE campanhas SET status = ?, resultado_json = ?, erro = ?, updated_at = ? WHERE id = ?",
             (status, json.dumps(resultado, ensure_ascii=False), erro[:2000], now_str(), campanha_id),
         )
+    if status == "publicada":
+        from .notify import notify_event
+
+        campanha = get(campanha_id)
+        notify_event("campanha_publicada", f"Campanha publicada ({campanha['plataforma']})", f"{campanha['nome']} — criada PAUSADA para revisão.")
     return get(campanha_id)
 
 

package/app/services/database.py

@@ -163,6 +163,33 @@ def ensure_db() -> None:
         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 ''")
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS lancamentos (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                produto_id INTEGER,
+                etapa_atual INTEGER NOT NULL DEFAULT 1,
+                status TEXT NOT NULL DEFAULT 'em_andamento',
+                dados_json TEXT NOT NULL DEFAULT '{}',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS notificacoes (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                event TEXT NOT NULL DEFAULT '',
+                titulo TEXT NOT NULL DEFAULT '',
+                mensagem TEXT NOT NULL DEFAULT '',
+                canal TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'pendente',
+                erro TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
 
 
 def now_str() -> str:

package/app/services/lancamentos.py

@@ -0,0 +1,148 @@
+"""AdsBot — Lançamento Assistido: wizard persistido + Relatório de Lançamento."""
+import json
+from pathlib import Path
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+ETAPAS = [
+    {"numero": 1, "nome": "Produto", "emoji": "📦", "rota": "/"},
+    {"numero": 2, "nome": "Página", "emoji": "🛡️", "rota": "/adspages"},
+    {"numero": 3, "nome": "Publicar", "emoji": "🌐", "rota": "/hosting/paginas"},
+    {"numero": 4, "nome": "Campanhas", "emoji": "🎯", "rota": "/adscreator"},
+    {"numero": 5, "nome": "Tracking", "emoji": "🔄", "rota": "/tracking/visitas"},
+    {"numero": 6, "nome": "Conclusão", "emoji": "✅", "rota": "/adsbot"},
+]
+
+
+def _decode(record: dict) -> dict:
+    try:
+        record["dados"] = json.loads(record.get("dados_json") or "{}")
+    except Exception:  # noqa: BLE001
+        record["dados"] = {}
+    return record
+
+
+def _get_row(lancamento_id: int) -> dict:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM lancamentos WHERE id = ?", (lancamento_id,)).fetchone()
+    if not row:
+        raise LLMError("Lançamento não encontrado.")
+    return row_to_dict(row)
+
+
+def atual() -> dict | None:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM lancamentos WHERE status = 'em_andamento' ORDER BY id DESC LIMIT 1").fetchone()
+    return _decode(row_to_dict(row)) if row else None
+
+
+def listar() -> list[dict]:
+    with get_db() as conn:
+        rows = conn.execute("SELECT * FROM lancamentos ORDER BY id DESC").fetchall()
+    return [_decode(row_to_dict(row)) for row in rows]
+
+
+def iniciar(produto_id: int | None = None) -> dict:
+    existing = atual()
+    if existing:
+        if produto_id and not existing.get("produto_id"):
+            return definir_produto(existing["id"], produto_id)
+        return existing
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO lancamentos (produto_id, etapa_atual, status, dados_json, created_at, updated_at) VALUES (?, 1, 'em_andamento', '{}', ?, ?)",
+            (produto_id, timestamp, timestamp),
+        )
+        row = conn.execute("SELECT * FROM lancamentos WHERE id = ?", (cursor.lastrowid,)).fetchone()
+    return _decode(row_to_dict(row))
+
+
+def definir_produto(lancamento_id: int, produto_id: int) -> dict:
+    with get_db() as conn:
+        conn.execute("UPDATE lancamentos SET produto_id = ?, updated_at = ? WHERE id = ?", (produto_id, now_str(), lancamento_id))
+    return _get_row(lancamento_id)
+
+
+def salvar_etapa(lancamento_id: int, etapa: int, dados: dict) -> dict:
+    if not 1 <= etapa <= len(ETAPAS):
+        raise LLMError(f"Etapa inválida (1–{len(ETAPAS)}).")
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM lancamentos WHERE id = ?", (lancamento_id,)).fetchone()
+        if not row:
+            raise LLMError("Lançamento não encontrado.")
+        merged = {}
+        try:
+            merged = json.loads(row["dados_json"] or "{}")
+        except Exception:  # noqa: BLE001
+            merged = {}
+        merged.update(dados or {})
+        conn.execute(
+            "UPDATE lancamentos SET etapa_atual = ?, dados_json = ?, updated_at = ? WHERE id = ?",
+            (max(etapa, row["etapa_atual"] if row["status"] == "concluido" else 0), json.dumps(merged, ensure_ascii=False), now_str(), lancamento_id),
+        )
+    return _get_row(lancamento_id)
+
+
+def concluir(lancamento_id: int) -> dict:
+    with get_db() as conn:
+        conn.execute("UPDATE lancamentos SET status = 'concluido', etapa_atual = ?, updated_at = ? WHERE id = ?", (len(ETAPAS), now_str(), lancamento_id))
+    return relatorio(lancamento_id)
+
+
+def relatorio(lancamento_id: int) -> dict:
+    record = _get_row(lancamento_id)
+    dados = json.loads(record.get("dados_json") or "{}")
+    produto_id = record.get("produto_id") or dados.get("produto_id")
+    produto = None
+    analysis = None
+    paginas = []
+    campanhas = []
+    if produto_id:
+        with get_db() as conn:
+            produto_row = conn.execute("SELECT * FROM produtos WHERE id = ?", (produto_id,)).fetchone()
+            if produto_row:
+                produto = row_to_dict(produto_row)
+        if produto and produto.get("analysis"):
+            try:
+                analysis = json.loads(produto["analysis"])
+            except Exception:  # noqa: BLE001
+                analysis = None
+        with get_db() as conn:
+            paginas = [row_to_dict(r) for r in conn.execute("SELECT * FROM paginas WHERE produto_id = ? ORDER BY id DESC", (produto_id,)).fetchall()]
+            campanhas = [row_to_dict(r) for r in conn.execute("SELECT * FROM campanhas WHERE produto_id = ? ORDER BY id DESC", (produto_id,)).fetchall()]
+    checklist_path = SEED_DIR / "checklists" / "lancamento.md"
+    checklist = ""
+    if checklist_path.exists():
+        checklist = checklist_path.read_text(encoding="utf-8")
+    return {
+        "lancamento": record,
+        "produto": produto,
+        "analysis": analysis,
+        "paginas": [
+            {"id": p["id"], "titulo": p["titulo"], "tipo": p["tipo"], "status": p["status"], "published_url": p["published_url"]}
+            for p in paginas
+        ],
+        "campanhas": [
+            {"id": c["id"], "nome": c["nome"], "plataforma": c["plataforma"], "status": c["status"], "cpa_alvo": c["cpa_alvo"], "orcamento_diario": c["orcamento_diario"]}
+            for c in campanhas
+        ],
+        "checklist": checklist,
+        "etapas": ETAPAS,
+    }
+
+
+def progresso(record: dict) -> dict:
+    etapa = record.get("etapa_atual") or 1
+    total = len(ETAPAS)
+    concluido = record.get("status") == "concluido"
+    percentual = 100 if concluido else round((etapa - 1) / total * 100)
+    return {
+        "etapa": etapa,
+        "total": total,
+        "percentual": percentual,
+        "faltam": 0 if concluido else total - etapa + 1,
+        "status": record.get("status"),
+    }

package/app/services/notify.py

@@ -0,0 +1,127 @@
+"""AdsNotify — notificações push (apprise) + histórico local.
+
+- Canais: URLs apprise configuradas em settings.notifications.targets. Se houver Telegram
+  configurado em Chaves de API, o destino t://TOKEN/CHATID entra automaticamente.
+- Eventos com toggle em settings.notifications.eventos (default: desligados).
+- Falha de envio NUNCA quebra o fluxo — apenas registra no histórico.
+"""
+import json
+import time
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+from .store import get_settings
+
+EVENTOS = {
+    "venda_recebida": "Venda recebida",
+    "campanha_publicada": "Campanha publicada",
+    "pagina_publicada": "Página publicada",
+    "infoproduto_gerado": "Infoproduto gerado",
+}
+
+
+def _telegram_target() -> str | None:
+    keys = (get_settings().get("api_keys") or {}).get("telegram") or {}
+    token = (keys.get("bot_token") or "").strip()
+    chat_id = (keys.get("chat_id") or "").strip()
+    if token and chat_id:
+        return f"tgram://{token}/{chat_id}"
+    return None
+
+
+def listar_config() -> dict:
+    settings = get_settings()
+    notifications = settings.get("notifications") or {}
+    return {
+        "eventos": {key: bool((notifications.get("eventos") or {}).get(key, False)) for key in EVENTOS},
+        "targets": notifications.get("targets") or [],
+        "eventos_disponiveis": EVENTOS,
+        "canal_telegram": bool(_telegram_target()),
+    }
+
+
+def salvar_config(eventos: dict, targets: list) -> dict:
+    settings = get_settings()
+    current = settings.get("notifications") or {}
+    merged_eventos = {key: bool((current.get("eventos") or {}).get(key, False)) for key in EVENTOS}
+    merged_eventos.update({key: bool(value) for key, value in (eventos or {}).items() if key in EVENTOS})
+    settings["notifications"] = {"eventos": merged_eventos, "targets": [str(item).strip() for item in (targets or []) if str(item).strip()]}
+    from .store import save_settings
+
+    save_settings(settings)
+    return listar_config()
+
+
+def historico(limit: int = 50) -> list[dict]:
+    with get_db() as conn:
+        rows = conn.execute("SELECT * FROM notificacoes ORDER BY id DESC LIMIT ?", (limit,)).fetchall()
+    return [row_to_dict(row) for row in rows]
+
+
+def _registrar(event: str, titulo: str, mensagem: str, canal: str, status: str, erro: str = "") -> None:
+    with get_db() as conn:
+        conn.execute(
+            "INSERT INTO notificacoes (event, titulo, mensagem, canal, status, erro, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (event, titulo, mensagem, canal, status, erro[:2000], now_str()),
+        )
+
+
+def _alvos() -> list[str]:
+    settings = get_settings()
+    targets = list((settings.get("notifications") or {}).get("targets") or [])
+    telegram = _telegram_target()
+    if telegram and telegram not in targets:
+        targets.insert(0, telegram)
+    return [item for item in targets if item.strip()]
+
+
+def _is_enabled(event: str) -> bool:
+    settings = get_settings()
+    return bool(((settings.get("notifications") or {}).get("eventos") or {}).get(event, False))
+
+
+def enviar(event: str, titulo: str, mensagem: str, forcar: bool = False) -> dict:
+    """Envia uma notificação pelos canais configurados (best-effort)."""
+    if not forcar and not _is_enabled(event):
+        return {"enviado": False, "motivo": "evento desligado"}
+    alvos = _alvos()
+    if not alvos:
+        erro = "Nenhum canal configurado (settings.notifications.targets ou Telegram em Chaves de API)."
+        _registrar(event, titulo, mensagem, "", "erro", erro)
+        if forcar:
+            raise LLMError(erro)
+        return {"enviado": False, "motivo": erro}
+    try:
+        import apprise
+    except ImportError as exc:
+        _registrar(event, titulo, mensagem, ",".join(alvos), "erro", f"apprise ausente ({exc.name}) — rode 'prodmaker install'.")
+        return {"enviado": False, "motivo": "apprise não instalado"}
+    apobj = apprise.Apprise()
+    enviados = []
+    erros = []
+    for alvo in alvos:
+        if apobj.add(alvo):
+            enviados.append(alvo)
+        else:
+            erros.append(f"canal inválido: {alvo}")
+    if not enviados:
+        erro = "; ".join(erros)
+        _registrar(event, titulo, mensagem, ",".join(alvos), "erro", erro)
+        raise LLMError(erro)
+    ok = apobj.notify(title=titulo, body=mensagem)
+    if ok:
+        _registrar(event, titulo, mensagem, ",".join(enviados), "enviada")
+        return {"enviado": True, "canais": enviados}
+    erro = "apprise não conseguiu entregar (verifique tokens/chat id)."
+    _registrar(event, titulo, mensagem, ",".join(enviados), "erro", erro)
+    raise LLMError(erro)
+
+
+def notify_event(event: str, titulo: str, mensagem: str) -> None:
+    """Hook seguro: usado pelos fluxos de venda/página/campanha/infoproduto."""
+    try:
+        enviar(event, titulo, mensagem)
+    except LLMError:
+        pass
+    except Exception:  # noqa: BLE001 — notificação nunca quebra a operação principal
+        pass

package/app/services/vendas.py

@@ -214,7 +214,17 @@ def registrar_venda(data: dict) -> dict:
             ),
         )
         row = conn.execute("SELECT * FROM vendas WHERE id = ?", (cursor.lastrowid,)).fetchone()
-    return row_to_dict(row)
+    record = row_to_dict(row)
+
+    from .notify import notify_event
+
+    notify_event(
+        "venda_recebida",
+        "Nova venda recebida",
+        f"{record.get('produto_nome') or 'Produto'} — R$ {record.get('valor')} ({record.get('fonte')})"
+        + (f" · GCLID {record['gclid'][:20]}" if record.get("gclid") else ""),
+    )
+    return record
 
 
 def list_vendas(limit: int = 300) -> list[dict]: