@danhachuel/leadmaster 0.0.0-stage → 0.1.0

package/backend/services/storage.py

@@ -0,0 +1,460 @@
+"""Persistência 100% local em arquivos JSON.
+
+Toda a escrita é atômica (arquivo temporário + replace) e protegida por um lock
+global, para permitir o uso concorrente pelas rotas da API e pelos workers em
+background (pipeline, campanhas, agendador de publicação).
+"""
+
+import json
+import os
+import threading
+from datetime import datetime
+from pathlib import Path
+
+LOCK = threading.RLock()
+
+# Campos que nunca podem vazar para o frontend.
+SECRET_KEYS = {"api_key", "token", "senha", "password"}
+
+LEADS_FILE = "leads.json"
+CAMPAIGNS_FILE = "campaigns.json"
+PIPELINE_FILE = "pipeline.json"
+CONFIG_FILE = "config.json"
+
+
+# ---------------------------------------------------------------------------
+# Caminhos
+# ---------------------------------------------------------------------------
+
+def _repo_root() -> Path:
+    """Raiz do repositório (pasta que contém backend/). storage.py está em
+    backend/services/, então sobe três níveis."""
+    return Path(__file__).resolve().parent.parent.parent
+
+
+def get_home() -> Path:
+    """Pasta de dados (home). Ordem: env LEADMASTER_HOME → raiz do repo."""
+    env = os.environ.get("LEADMASTER_HOME")
+    if env:
+        return Path(env).resolve()
+    return _repo_root()
+
+
+def storage_dir() -> Path:
+    d = get_home() / "storage"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def roteiros_dir() -> Path:
+    d = get_home() / "roteiros"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def videos_dir() -> Path:
+    d = get_home() / "videos"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def now_iso() -> str:
+    return datetime.now().astimezone().isoformat(timespec="seconds")
+
+
+# ---------------------------------------------------------------------------
+# Leitura/escrita atômica
+# ---------------------------------------------------------------------------
+
+def _read(name: str, default):
+    with LOCK:
+        path = storage_dir() / name
+        if not path.exists():
+            return default
+        try:
+            # utf-8-sig: tolera BOM (comum em arquivos editados no Windows
+            # por PowerShell/Notepad) e é idêntico a utf-8 quando não há BOM.
+            return json.loads(path.read_text(encoding="utf-8-sig"))
+        except json.JSONDecodeError:
+            # Arquivo corrompido: preserva uma cópia para inspeção manual
+            # e devolve o padrão para não travar a aplicação.
+            try:
+                path.rename(path.with_suffix(path.suffix + ".corrompido"))
+            except OSError:
+                pass
+            return default
+
+
+def _write(name: str, data) -> None:
+    with LOCK:
+        path = storage_dir() / name
+        tmp = path.with_name(path.name + ".tmp")
+        tmp.write_text(
+            json.dumps(data, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+        tmp.replace(path)
+
+
+# ---------------------------------------------------------------------------
+# Configuração
+# ---------------------------------------------------------------------------
+
+DEFAULT_CONFIG = {
+    "perfil": {
+        "nome": "Dan",
+        "licenca": {
+            "ativa": True,
+            "expira_em": "31/12/2099 23:59",
+            "restam_dias": None,
+        },
+    },
+    "llm": {
+        "provedor": "openai-compat",
+        "base_url": "https://api.openai.com/v1",
+        "api_key": "",
+        "modelo": "gpt-4o-mini",
+    },
+    "integracoes": {
+        "moneyprinter": {"url": "http://localhost:8080"},
+        "short_video_maker": {"url": "http://localhost:3123"},
+        "openmontage": {"cli_path": ""},
+        "youtube_upload": {
+            "url": "",
+            "api_key": "",
+            "upload_path": "/api/upload",
+            "publicar_path": "/api/videos/{video_id}/publicar",
+            "modo": "nao_listado_1h_publico",
+            "limite_diario": 50,
+            "espera_publicacao_horas": 1,
+            "uploader_mcp_path": "",
+        },
+        "openoutreach": {"url": "", "send_path": "/api/send"},
+        "pipecat": {"url": ""},
+    },
+    "extratores": {
+        "google_maps_cli": "",
+        "google_maps_args": (
+            '--kw "{palavra_chave}" --loc "{localizacao}" --lang pt --email --max {max_resultados} --outdir "{outdir}"'
+        ),
+        "igmapper_cli": "",
+        "igmapper_args": "--profile {url} --outdir {outdir}",
+        "scrapling_cli": "",
+        "cnpj_provedor_busca": "https://api.opencnpj.org",
+    },
+    "agentes": {
+        "disparo": {
+            "templates": {
+                "texto": (
+                    "Olá {{primeiro_nome}}! Sou da {{minha_empresa}} e ajudo empresas como "
+                    "{{empresa}} a crescerem com conteúdo automatizado no YouTube. "
+                    "Posso te enviar uma proposta rápida?"
+                ),
+                "audio": "Olá {{primeiro_nome}}, tudo bem? Falo em nome da {{minha_empresa}}...",
+            },
+            "minha_empresa": "LeadMaster",
+            "delay_entre_envios_segundos": 3,
+        },
+        "atendimento": {"modo": "texto"},
+    },
+    "webhook": {
+        "url": "",
+        "eventos": ["lead.criado", "lead.etapa", "campanha.concluida", "video.publicado"],
+    },
+    "uploads": {"data": "", "contador": 0},
+}
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    out = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(out.get(key), dict):
+            out[key] = _deep_merge(out[key], value)
+        else:
+            out[key] = value
+    return out
+
+
+def _deep_merge_preserve_secrets(base: dict, override: dict) -> dict:
+    """Deep merge que ignora valores vazios em campos de segredo (manter atual)."""
+    out = dict(base)
+    for key, value in override.items():
+        if key in SECRET_KEYS and (value == "" or value is None) and key in out:
+            continue
+        if isinstance(value, dict) and isinstance(out.get(key), dict):
+            out[key] = _deep_merge_preserve_secrets(out[key], value)
+        else:
+            out[key] = value
+    return out
+
+
+def get_config() -> dict:
+    return _deep_merge(DEFAULT_CONFIG, _read(CONFIG_FILE, {}))
+
+
+def update_config(patch: dict) -> dict:
+    with LOCK:
+        atual = get_config()
+        novo = _deep_merge_preserve_secrets(atual, patch)
+        _write(CONFIG_FILE, novo)
+        return novo
+
+
+def redact_config(config: dict) -> dict:
+    """Copia a config substituindo segredos por vazio + flag `_configurado`."""
+    out = {}
+    for key, value in config.items():
+        if isinstance(value, dict):
+            out[key] = redact_config(value)
+        elif key in SECRET_KEYS:
+            out[key] = ""
+            out[f"{key}_configurado"] = bool(value)
+        else:
+            out[key] = value
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Leads
+# ---------------------------------------------------------------------------
+
+def list_leads() -> list:
+    return _read(LEADS_FILE, [])
+
+
+def save_leads(leads: list) -> None:
+    _write(LEADS_FILE, leads)
+
+
+def add_lead(lead: dict) -> dict:
+    with LOCK:
+        leads = list_leads()
+        lead["criado_em"] = lead.get("criado_em") or now_iso()
+        lead["atualizado_em"] = now_iso()
+        leads.append(lead)
+        save_leads(leads)
+        return lead
+
+
+def update_lead(lead_id: str, patch: dict) -> dict | None:
+    with LOCK:
+        leads = list_leads()
+        for lead in leads:
+            if lead.get("id") == lead_id:
+                lead.update(patch)
+                lead["atualizado_em"] = now_iso()
+                save_leads(leads)
+                return lead
+        return None
+
+
+def delete_lead(lead_id: str) -> bool:
+    with LOCK:
+        leads = list_leads()
+        restantes = [l for l in leads if l.get("id") != lead_id]
+        if len(restantes) == len(leads):
+            return False
+        save_leads(restantes)
+        return True
+
+
+def import_leads(novos: list, dedup: bool = True) -> dict:
+    """Importa leads em massa; retorna {importados, duplicados}."""
+    with LOCK:
+        leads = list_leads()
+        existentes = {
+            (l.get("telefone") or "").strip(),
+            (l.get("email") or "").strip().lower(),
+        }
+        importados, duplicados = [], []
+        for novo in novos:
+            tel = (novo.get("telefone") or "").strip()
+            email = (novo.get("email") or "").strip().lower()
+            if dedup and ((tel and tel in existentes) or (email and email in existentes)):
+                duplicados.append(novo)
+                continue
+            novo.setdefault("id", _novo_id())
+            novo["criado_em"] = now_iso()
+            novo["atualizado_em"] = now_iso()
+            leads.append(novo)
+            existentes.add(tel)
+            existentes.add(email)
+            importados.append(novo)
+        save_leads(leads)
+        return {"importados": importados, "duplicados": duplicados}
+
+
+def _novo_id() -> str:
+    import uuid
+
+    return uuid.uuid4().hex[:12]
+
+
+# ---------------------------------------------------------------------------
+# Campanhas
+# ---------------------------------------------------------------------------
+
+def list_campaigns() -> list:
+    return _read(CAMPAIGNS_FILE, [])
+
+
+def save_campaigns(campaigns: list) -> None:
+    _write(CAMPAIGNS_FILE, campaigns)
+
+
+def upsert_campaign(campaign: dict) -> dict:
+    with LOCK:
+        campaigns = list_campaigns()
+        for i, c in enumerate(campaigns):
+            if c.get("id") == campaign["id"]:
+                campaigns[i] = campaign
+                break
+        else:
+            campaigns.append(campaign)
+        save_campaigns(campaigns)
+        return campaign
+
+
+def get_campaign(campaign_id: str) -> dict | None:
+    for c in list_campaigns():
+        if c.get("id") == campaign_id:
+            return c
+    return None
+
+
+def delete_campaign(campaign_id: str) -> bool:
+    with LOCK:
+        campaigns = list_campaigns()
+        restantes = [c for c in campaigns if c.get("id") != campaign_id]
+        if len(restantes) == len(campaigns):
+            return False
+        save_campaigns(restantes)
+        return True
+
+
+# ---------------------------------------------------------------------------
+# Pipeline
+# ---------------------------------------------------------------------------
+
+def list_jobs() -> list:
+    data = _read(PIPELINE_FILE, {"jobs": []})
+    if isinstance(data, list):  # tolerância a formato antigo
+        data = {"jobs": data}
+    return data.get("jobs", [])
+
+
+def save_jobs(jobs: list) -> None:
+    _write(PIPELINE_FILE, {"jobs": jobs})
+
+
+def get_job(job_id: str) -> dict | None:
+    for j in list_jobs():
+        if j.get("id") == job_id:
+            return j
+    return None
+
+
+def upsert_job(job: dict) -> dict:
+    with LOCK:
+        jobs = list_jobs()
+        for i, j in enumerate(jobs):
+            if j.get("id") == job["id"]:
+                jobs[i] = job
+                break
+        else:
+            jobs.append(job)
+        save_jobs(jobs)
+        return job
+
+
+# ---------------------------------------------------------------------------
+# Seeds (primeira execução)
+# ---------------------------------------------------------------------------
+
+def _seed_leads() -> list:
+    """Leads de demonstração para o painel nascer com vida."""
+    modelos = [
+        ("Construtora Horizonte Ltda", "(11) 3344-5566", "contato@horizonte.com.br", "CNPJ", "leads", "Construtora Horizonte", "São Paulo/SP", 62),
+        ("Clínica Bem Viver", "(11) 98877-1122", "contato@bemviver.com.br", "Google Maps", "leads", "Clínica Bem Viver", "Campinas/SP", 48),
+        ("Padaria do Largo", "(21) 2233-4455", "", "Google Maps", "leads", "Padaria do Largo", "Rio de Janeiro/RJ", 25),
+        ("Academia Iron Fit", "(31) 99876-5544", "atendimento@ironfit.com.br", "Instagram", "leads", "Iron Fit", "Belo Horizonte/MG", 55),
+        ("Escritório Delta Contábil", "(41) 3322-7788", "delta@deltacontabil.com.br", "CNPJ", "em_contato", "Delta Contábil", "Curitiba/PR", 74),
+        ("Restaurante Sabor Caseiro", "(85) 98811-2233", "saborcaseiro@gmail.com", "Google Maps", "em_contato", "Sabor Caseiro", "Fortaleza/CE", 68),
+        ("Ótica Visão Clara", "(51) 3445-6677", "contato@visaoclara.com.br", "Instagram", "proposta", "Visão Clara", "Porto Alegre/RS", 88),
+        ("Mercado Central Atacado", "(62) 99555-1010", "compras@centralatacado.com.br", "CNPJ", "fechado", "Central Atacado", "Goiânia/GO", 95),
+    ]
+    leads = []
+    for nome, telefone, email, fonte, etapa, empresa, cidade, score in modelos:
+        leads.append(
+            {
+                "id": _novo_id(),
+                "nome": nome,
+                "telefone": telefone,
+                "email": email,
+                "fonte": fonte,
+                "etapa": etapa,
+                "empresa": empresa,
+                "cidade": cidade,
+                "score": score,
+                "tags": [],
+                "observacoes": "",
+                "criado_em": now_iso(),
+                "atualizado_em": now_iso(),
+            }
+        )
+    return leads
+
+
+def _seed_campaigns() -> list:
+    return [
+        {
+            "id": _novo_id(),
+            "nome": "Reativação Q4 (demonstração)",
+            "canal": "texto",
+            "template": "texto",
+            "lead_ids": [],
+            "status": "concluida",
+            "total": 50,
+            "enviadas": 47,
+            "erros": 3,
+            "criado_em": now_iso(),
+            "iniciada_em": now_iso(),
+            "concluida_em": now_iso(),
+            "eventos": [],
+        },
+        {
+            "id": _novo_id(),
+            "nome": "Boas-vindas Novos Leads (demonstração)",
+            "canal": "texto",
+            "template": "texto",
+            "lead_ids": [],
+            "status": "rascunho",
+            "total": 0,
+            "enviadas": 0,
+            "erros": 0,
+            "criado_em": now_iso(),
+            "eventos": [],
+        },
+    ]
+
+
+def ensure_seeds() -> None:
+    """Cria os arquivos de dados com seeds na primeira execução."""
+    with LOCK:
+        d = storage_dir()
+        if not (d / LEADS_FILE).exists():
+            _write(LEADS_FILE, _seed_leads())
+        if not (d / CAMPAIGNS_FILE).exists():
+            _write(CAMPAIGNS_FILE, _seed_campaigns())
+        if not (d / PIPELINE_FILE).exists():
+            _write(PIPELINE_FILE, {"jobs": []})
+        if not (d / CONFIG_FILE).exists():
+            _write(CONFIG_FILE, DEFAULT_CONFIG)
+
+
+def limpar_seeds_demo() -> None:
+    """Remove os dados de demonstração (usado quando o usuário pede)."""
+    with LOCK:
+        save_leads([])
+        save_campaigns([])
+        save_jobs([])

package/backend/services/youtube_upload.py

@@ -0,0 +1,163 @@
+"""Upload para YouTube com a estratégia do LeadMaster:
+
+1. Upload primário via serviço local "YouTube-Video-Upload-Frontend-Api"
+   (URL e caminhos configuráveis em Ferramentas → Upload YouTube).
+2. Fallback opcional via CLI do `youtube-uploader-mcp`.
+3. Publicação como **não listado**, aguardando 1h e mudando para **público**
+   (agendamento feito pelo motor do pipeline).
+4. Limite diário de 50 uploads (contagem local por data).
+
+Erros são sempre acionáveis: como instalar/configurar cada peça.
+"""
+
+import subprocess
+from datetime import date
+
+import httpx
+
+from . import storage
+
+
+class UploadNaoConfigurado(Exception):
+    pass
+
+
+class LimiteDiarioExcedido(Exception):
+    pass
+
+
+class UploadErro(Exception):
+    pass
+
+
+def _conf() -> dict:
+    return storage.get_config()["integracoes"]["youtube_upload"]
+
+
+def _contagem() -> dict:
+    return storage.get_config()["uploads"]
+
+
+def verificar() -> bool:
+    conf = _conf()
+    if not conf.get("url"):
+        return bool(conf.get("uploader_mcp_path"))
+    try:
+        httpx.get(conf["url"].rstrip("/"), timeout=2)
+        return True
+    except httpx.HTTPError:
+        return False
+
+
+def contagem_hoje() -> int:
+    c = _contagem()
+    hoje = date.today().isoformat()
+    return c["contador"] if c.get("data") == hoje else 0
+
+
+def _incrementar_contagem() -> None:
+    config = storage.get_config()
+    hoje = date.today().isoformat()
+    uploads = config.setdefault("uploads", {"data": hoje, "contador": 0})
+    if uploads.get("data") != hoje:
+        uploads.update({"data": hoje, "contador": 0})
+    uploads["contador"] = int(uploads.get("contador", 0)) + 1
+    storage.update_config({"uploads": uploads})
+
+
+def upload_video(titulo: str, descricao: str, arquivo: str = "", video_url: str = "", tags: str = "") -> dict:
+    """Faz o upload como não listado. Retorna {video_id, url, modo, aviso}."""
+    conf = _conf()
+
+    limite = int(conf.get("limite_diario", 50))
+    if contagem_hoje() >= limite:
+        raise LimiteDiarioExcedido(
+            f"Limite diário de {limite} uploads atingido (hoje: {contagem_hoje()}). "
+            "O upload continua amanhã automaticamente — clique Repetir no job."
+        )
+
+    if conf.get("url"):
+        resultado = _upload_via_servico(conf, titulo, descricao, arquivo, video_url, tags)
+    elif conf.get("uploader_mcp_path"):
+        resultado = _upload_via_mcp(conf, titulo, descricao, arquivo, video_url)
+    else:
+        raise UploadNaoConfigurado(
+            "Nenhum uploader configurado. Em Ferramentas → Upload YouTube, informe a URL do "
+            "YouTube-Video-Upload-Frontend-Api (primário) ou o caminho do youtube-uploader-mcp (fallback)."
+        )
+    _incrementar_contagem()
+    return resultado
+
+
+def _upload_via_servico(conf: dict, titulo: str, descricao: str, arquivo: str, video_url: str, tags: str) -> dict:
+    base = conf["url"].rstrip("/")
+    path = conf.get("upload_path", "/api/upload").lstrip("/")
+    payload = {
+        "title": titulo,
+        "description": descricao,
+        "tags": tags,
+        "privacy": "unlisted",  # não listado → agenda de 1h → público
+        "video_url": video_url,
+        "video_file": arquivo,
+        "api_key": conf.get("api_key", ""),
+    }
+    try:
+        r = httpx.post(f"{base}/{path}", json=payload, timeout=600)
+    except httpx.HTTPError as e:
+        raise UploadErro(
+            f"Uploader local ({base}) não respondeu: {e}. Confirme que o "
+            "YouTube-Video-Upload-Frontend-Api está ativo e clique Repetir."
+        ) from e
+    if r.status_code >= 400:
+        raise UploadErro(f"Uploader local rejeitou o vídeo (HTTP {r.status_code}): {r.text[:300]}")
+    try:
+        corpo = r.json()
+    except ValueError:
+        corpo = {"resposta_bruta": r.text[:300]}
+    video_id = corpo.get("video_id") or corpo.get("videoId") or corpo.get("id") or ""
+    return {
+        "video_id": video_id,
+        "url": corpo.get("url") or (f"https://youtu.be/{video_id}" if video_id else ""),
+        "modo": "servico_local",
+        "resposta": corpo,
+    }
+
+
+def _upload_via_mcp(conf: dict, titulo: str, descricao: str, arquivo: str, video_url: str) -> dict:
+    cli = conf.get("uploader_mcp_path", "")
+    if not arquivo:
+        raise UploadErro("O fallback youtube-uploader-mcp precisa do arquivo de vídeo local (produza o vídeo primeiro).")
+    try:
+        resultado = subprocess.run(
+            [cli, arquivo, "--title", titulo, "--description", descricao, "--privacy", "unlisted"],
+            capture_output=True,
+            text=True,
+            timeout=3600,
+            shell=False,
+        )
+    except FileNotFoundError as e:
+        raise UploadNaoConfigurado(f"Caminho do youtube-uploader-mcp inválido: {e}") from e
+    if resultado.returncode != 0:
+        raise UploadErro(f"youtube-uploader-mcp falhou: {resultado.stderr[-400:]}")
+    return {
+        "video_id": resultado.stdout.strip().splitlines()[-1] if resultado.stdout.strip() else "",
+        "url": resultado.stdout.strip().splitlines()[-1] if resultado.stdout.strip() else "",
+        "modo": "uploader_mcp",
+        "resposta": {"stdout": resultado.stdout[-500:]},
+    }
+
+
+def tornar_publico(video_id: str) -> dict:
+    """Muda o vídeo de não listado para público (chamado pelo agendador)."""
+    conf = _conf()
+    if not conf.get("url"):
+        raise UploadNaoConfigurado("Uploader local não configurado; publique manualmente o vídeo " f"{video_id}.")
+    base = conf["url"].rstrip("/")
+    path = conf.get("publicar_path", "/api/videos/{video_id}/publicar").lstrip("/")
+    try:
+        r = httpx.post(f"{base}/{path.format(video_id=video_id)}", json={"privacy": "public"}, timeout=60)
+    except httpx.HTTPError as e:
+        raise UploadErro(f"Falha ao publicar {video_id} via uploader local: {e}") from e
+    if r.status_code >= 400:
+        raise UploadErro(f"Uploader local recusou publicar {video_id} (HTTP {r.status_code}): {r.text[:300]}")
+    return {"ok": True, "resposta": r.text[:300]}