@danhachuel/leadmaster 0.0.0-stage → 0.1.0

package/backend/services/extractors.py

@@ -0,0 +1,322 @@
+"""Extratores de leads: Google Maps, Instagram e CNPJ.
+
+Princípios:
+- Nenhuma extração importa automaticamente: o frontend pré-visualiza e o
+  usuário confirma a importação.
+- Toda integração externa falha graciosamente com instruções acionáveis.
+- Os comandos de CLI usam templates de argumentos configuráveis, porque as
+  flags dos projetos upstream podem variar entre versões.
+"""
+
+import csv
+import json
+import subprocess
+import tempfile
+from pathlib import Path
+
+import httpx
+
+from . import storage
+
+
+class ExtratorNaoConfigurado(Exception):
+    pass
+
+
+class ExtratorErro(Exception):
+    pass
+
+
+def _conf() -> dict:
+    return storage.get_config()["extratores"]
+
+
+def _novo_lead_parcial() -> dict:
+    return {"tags": [], "observacoes": "", "score": 50}
+
+
+# ---------------------------------------------------------------------------
+# Google Maps (gosom/google-maps-scraper via CLI)
+# ---------------------------------------------------------------------------
+
+def extrair_google_maps(palavra_chave: str, localizacao: str, max_resultados: int = 100) -> dict:
+    conf = _conf()
+    cli = conf.get("google_maps_cli", "")
+    if not cli or not Path(cli).exists():
+        raise ExtratorNaoConfigurado(
+            "Google Maps Scraper não configurado. Instale https://github.com/gosom/google-maps-scraper "
+            "e informe o caminho do binário em Ferramentas → Extratores."
+        )
+    with tempfile.TemporaryDirectory(prefix="leadmaster-maps-") as tmp:
+        outdir = Path(tmp)
+        args_template = conf.get(
+            "google_maps_args",
+            '--kw "{palavra_chave}" --loc "{localizacao}" --lang pt --email --max {max_resultados} --outdir "{outdir}"',
+        )
+        cmd = [cli] + _formatar_args(
+            args_template,
+            palavra_chave=palavra_chave,
+            localizacao=localizacao,
+            max_resultados=max_resultados,
+            outdir=str(outdir),
+        )
+        try:
+            resultado = subprocess.run(cmd, capture_output=True, text=True, timeout=1800, shell=False)
+        except FileNotFoundError as e:
+            raise ExtratorNaoConfigurado(f"Não foi possível executar o CLI do Google Maps Scraper: {e}") from e
+        if resultado.returncode != 0:
+            raise ExtratorErro(
+                f"Google Maps Scraper terminou com código {resultado.returncode}: {resultado.stderr[-400:]}. "
+                "Confira as flags do template em Ferramentas → Extratores."
+            )
+        leads = _parse_resultados_diretorio(outdir, fonte="Google Maps")
+    return {"leads": leads, "comando": " ".join(cmd[:4]) + " ..."}
+
+
+# ---------------------------------------------------------------------------
+# Instagram (lucasoal/igmapper via CLI)
+# ---------------------------------------------------------------------------
+
+def extrair_instagram(profile_url: str) -> dict:
+    conf = _conf()
+    cli = conf.get("igmapper_cli", "")
+    if not cli or not Path(cli).exists():
+        raise ExtratorNaoConfigurado(
+            "igmapper não configurado. Instale https://github.com/lucasoal/igmapper "
+            "e informe o caminho em Ferramentas → Extratores."
+        )
+    with tempfile.TemporaryDirectory(prefix="leadmaster-ig-") as tmp:
+        outdir = Path(tmp)
+        args_template = conf.get("igmapper_args", "--profile {url} --outdir {outdir}")
+        cmd = [cli] + _formatar_args(args_template, url=profile_url, outdir=str(outdir))
+        try:
+            resultado = subprocess.run(cmd, capture_output=True, text=True, timeout=900, shell=False)
+        except FileNotFoundError as e:
+            raise ExtratorNaoConfigurado(f"Não foi possível executar o igmapper: {e}") from e
+        if resultado.returncode != 0:
+            raise ExtratorErro(f"igmapper terminou com código {resultado.returncode}: {resultado.stderr[-400:]}")
+        leads = _parse_resultados_diretorio(outdir, fonte="Instagram")
+    if not leads:
+        raise ExtratorErro(
+            "igmapper rodou mas não retornou dados reconhecíveis. Confira o formato de saída "
+            "(esperado CSV/JSON com username, full_name, followers, phone, email)."
+        )
+    return {"leads": leads, "comando": " ".join(cmd[:4]) + " ..."}
+
+
+# ---------------------------------------------------------------------------
+# CNPJ — consulta direta (BrasilAPI) e busca por CNAE/UF (provedor configurável)
+# ---------------------------------------------------------------------------
+
+def _so_digitos(texto: str) -> str:
+    return "".join(c for c in texto or "" if c.isdigit())
+
+
+def consulta_cnpj(cnpj: str) -> dict:
+    cnpj = _so_digitos(cnpj)
+    if len(cnpj) != 14:
+        raise ExtratorErro("CNPJ inválido: use 14 dígitos (com ou sem pontuação).")
+    try:
+        r = httpx.get(f"https://brasilapi.com.br/api/cnpj/v1/{cnpj}", timeout=30)
+    except httpx.HTTPError as e:
+        raise ExtratorErro(f"Falha ao consultar a BrasilAPI: {e}") from e
+    if r.status_code == 404:
+        raise ExtratorErro("CNPJ não encontrado na BrasilAPI.")
+    if r.status_code >= 400:
+        raise ExtratorErro(f"BrasilAPI respondeu HTTP {r.status_code}: {r.text[:200]}")
+    d = r.json()
+    endereco = " ".join(
+        p
+        for p in [
+            d.get("logradouro"),
+            d.get("numero"),
+            d.get("bairro"),
+        ]
+        if p
+    )
+    lead = _novo_lead_parcial()
+    lead.update(
+        {
+            "nome": d.get("razao_social") or d.get("nome_fantasia") or "",
+            "empresa": d.get("nome_fantasia") or d.get("razao_social") or "",
+            "cnpj": cnpj,
+            "telefone": d.get("ddd_telefone_1") or "",
+            "endereco": endereco,
+            "cidade": f"{d.get('municipio', '')}/{d.get('uf', '')}",
+            "email": "",
+            "fonte": "CNPJ",
+            "etapa": "leads",
+        }
+    )
+    lead["score"] = 55
+    return lead
+
+
+def buscar_cnpj_cnae(cnae: str, uf: str, quantidade: int = 20) -> dict:
+    """Busca empresas por CNAE + UF no provedor configurável (padrão: OpenCNPJ).
+
+    O formato pode variar; o parser é tolerante (aceita lista, {"results": ...},
+    {"data": ...} e vários nomes de campos).
+    """
+    conf = _conf()
+    base = (conf.get("cnpj_provedor_busca") or "https://api.opencnpj.org").rstrip("/")
+    params = {"cnae": _so_digitos(cnae), "uf": uf.strip().upper(), "quantidade": str(max(1, min(quantidade, 100)))}
+    try:
+        r = httpx.get(base, params=params, timeout=60)
+    except httpx.HTTPError as e:
+        raise ExtratorErro(
+            f"Falha ao consultar o provedor de busca ({base}): {e}. "
+            "Verifique a URL do provedor em Ferramentas → Extratores."
+        ) from e
+    if r.status_code >= 400:
+        raise ExtratorErro(
+            f"Provedor de busca ({base}) respondeu HTTP {r.status_code}: {r.text[:200]}. "
+            "O provedor é configurável em Ferramentas → Extratores."
+        )
+    try:
+        corpo = r.json()
+    except ValueError:
+        raise ExtratorErro(f"Provedor de busca devolveu resposta não-JSON: {r.text[:200]}")
+    itens = []
+    if isinstance(corpo, list):
+        itens = corpo
+    elif isinstance(corpo, dict):
+        itens = corpo.get("results") or corpo.get("data") or corpo.get("items") or []
+    leads = []
+    for item in itens[:quantidade]:
+        if not isinstance(item, dict):
+            continue
+        lead = _novo_lead_parcial()
+        lead.update(
+            {
+                "nome": _primeiro(item, "razao_social", "nome", "razaoSocial", "company_name"),
+                "empresa": _primeiro(item, "nome_fantasia", "fantasia", "nomeFantasia", "trade_name") or "",
+                "cnpj": _so_digitos(_primeiro(item, "cnpj", "cnpj_raiz", "document")),
+                "telefone": _primeiro(item, "telefone", "phone", "ddd_telefone_1") or "",
+                "email": _primeiro(item, "email", "contact_email") or "",
+                "cidade": f"{_primeiro(item, 'municipio', 'city', 'municipio') or ''}/{_primeiro(item, 'uf', 'state', 'uf') or ''}",
+                "fonte": "CNPJ",
+                "etapa": "leads",
+            }
+        )
+        lead["score"] = 45
+        leads.append(lead)
+    return {"leads": leads, "provedor": base}
+
+
+def enriquecer_com_site(website: str) -> dict:
+    """Scraping profundo de contatos no site da empresa, via Scrapling (opcional)."""
+    conf = _conf()
+    cli = conf.get("scrapling_cli", "")
+    if not cli or not Path(cli).exists():
+        raise ExtratorNaoConfigurado(
+            "Scrapling não configurado. Instale https://github.com/D4Vinci/Scrapling "
+            "e informe o caminho em Ferramentas → Extratores."
+        )
+    try:
+        resultado = subprocess.run(
+            [cli, "extract", website],
+            capture_output=True,
+            text=True,
+            timeout=300,
+            shell=False,
+        )
+    except FileNotFoundError as e:
+        raise ExtratorNaoConfigurado(f"Não foi possível executar o Scrapling: {e}") from e
+    if resultado.returncode != 0:
+        raise ExtratorErro(f"Scrapling falhou: {resultado.stderr[-400:]}")
+    return {"saidas": resultado.stdout[-2000:]}
+
+
+# ---------------------------------------------------------------------------
+# Utilitários de parsing tolerante
+# ---------------------------------------------------------------------------
+
+def _primeiro(d: dict, *chaves: str):
+    for chave in chaves:
+        if d.get(chave):
+            return d[chave]
+    return ""
+
+
+def _formatar_args(template: str, **valores: str) -> list[str]:
+    """Converte '--kw "a b" --n 5' em ['--kw', 'a b', '--n', '5'] respeitando aspas."""
+    texto = template.format(**valores)
+    partes, atual, aspas = [], "", None
+    for ch in texto:
+        if ch in "\"'":
+            aspas = None if aspas == ch else ch
+            continue
+        if ch == " " and not aspas:
+            if atual:
+                partes.append(atual)
+            atual = ""
+        else:
+            atual += ch
+    if atual:
+        partes.append(atual)
+    return partes
+
+
+def _mapear_linha(linha: dict, fonte: str) -> dict:
+    lead = _novo_lead_parcial()
+    nome = _primeiro(linha, "nome", "name", "title", "razao_social", "full_name", "username")
+    lead.update(
+        {
+            "nome": nome or "Sem nome",
+            "telefone": _primeiro(linha, "telefone", "phone", "phone_number", "public_phone", "ddd_telefone_1"),
+            "email": _primeiro(linha, "email", "email_address", "business_email"),
+            "empresa": _primeiro(linha, "empresa", "company", "site_name", "nome_fantasia"),
+            "endereco": _primeiro(linha, "endereco", "address", "full_address", "street"),
+            "cidade": _primeiro(linha, "cidade", "city", "locality"),
+            "site": _primeiro(linha, "site", "website", "web_site"),
+            "fonte": fonte,
+            "etapa": "leads",
+        }
+    )
+    extras = {}
+    if _primeiro(linha, "rating", "nota"):
+        extras["avaliacao"] = linha.get("rating") or linha.get("nota")
+    if _primeiro(linha, "reviews", "avaliacoes"):
+        extras["qtd_avaliacoes"] = linha.get("reviews") or linha.get("avaliacoes")
+    if _primeiro(linha, "followers", "seguidores"):
+        extras["seguidores"] = linha.get("followers") or linha.get("seguidores")
+    if _primeiro(linha, "biography", "bio"):
+        extras["bio"] = (linha.get("biography") or linha.get("bio"))[:200]
+    lead["extras"] = extras
+    lead["score"] = 40 + (10 if lead["telefone"] else 0) + (10 if lead["email"] else 0)
+    return lead
+
+
+def _parse_resultados_diretorio(outdir: Path, fonte: str) -> list:
+    leads = []
+    for arquivo in sorted(outdir.iterdir()):
+        if arquivo.suffix.lower() == ".csv":
+            with arquivo.open(encoding="utf-8-sig", newline="") as fh:
+                for linha in csv.DictReader(fh):
+                    lead = _mapear_linha(linha, fonte)
+                    if lead["nome"] != "Sem nome":
+                        leads.append(lead)
+        elif arquivo.suffix.lower() == ".json":
+            try:
+                dados = json.loads(arquivo.read_text(encoding="utf-8"))
+            except (ValueError, OSError):
+                continue
+            itens = dados if isinstance(dados, list) else [dados]
+            for item in itens:
+                if isinstance(item, dict):
+                    lead = _mapear_linha(item, fonte)
+                    if lead["nome"] != "Sem nome":
+                        leads.append(lead)
+    # dedup por telefone/email
+    vistos, unicos = set(), []
+    for lead in leads:
+        chave = (lead.get("telefone") or "", (lead.get("email") or "").lower())
+        if chave[0] and chave[0] in vistos:
+            continue
+        if chave[1] and chave[1] in vistos:
+            continue
+        vistos.add(chave[0])
+        vistos.add(chave[1])
+        unicos.append(lead)
+    return unicos

package/backend/services/llm.py

@@ -0,0 +1,189 @@
+"""Cliente LLM (API OpenAI-compatível) com fallback local para roteiros.
+
+A configuração fica em `config.json → llm` (provedor, base_url, api_key, modelo).
+Se o LLM não estiver configurado, os roteiros são gerados por um modelo local
+(template estruturado) e a origem é sempre informada ao usuário — nunca fingimos
+uma geração por IA.
+"""
+
+import httpx
+
+from . import storage
+
+
+class LLMNaoConfigurado(Exception):
+    """LLM não configurado — mensagem acionável para Ferramentas → LLM."""
+
+
+class LLMErro(Exception):
+    """LLM configurado, mas a chamada falhou."""
+
+
+def _conf() -> dict:
+    return storage.get_config().get("llm", {})
+
+
+def configurado() -> bool:
+    c = _conf()
+    return bool(c.get("api_key") and c.get("base_url"))
+
+
+def chat(mensagens: list, temperature: float = 0.7, max_tokens: int = 4000) -> str:
+    c = _conf()
+    if not configurado():
+        raise LLMNaoConfigurado(
+            "LLM não configurado. Vá em Ferramentas → LLM, informe base_url, api_key e modelo."
+        )
+    url = c["base_url"].rstrip("/") + "/chat/completions"
+    try:
+        r = httpx.post(
+            url,
+            headers={"Authorization": f"Bearer {c['api_key']}"},
+            json={
+                "model": c.get("modelo", "gpt-4o-mini"),
+                "messages": mensagens,
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+            },
+            timeout=180,
+        )
+        r.raise_for_status()
+        return r.json()["choices"][0]["message"]["content"]
+    except httpx.HTTPStatusError as e:
+        raise LLMErro(f"LLM respondeu HTTP {e.response.status_code}: {e.response.text[:300]}") from e
+    except httpx.HTTPError as e:
+        raise LLMErro(f"Falha de conexão com o LLM ({url}): {e}") from e
+
+
+def testar_conexao() -> dict:
+    try:
+        resposta = chat(
+            [{"role": "user", "content": "Responda apenas com: OK"}],
+            temperature=0,
+            max_tokens=8,
+        )
+        return {"ok": True, "resposta": resposta.strip()[:100]}
+    except LLMNaoConfigurado as e:
+        return {"ok": False, "mensagem": str(e)}
+    except LLMErro as e:
+        return {"ok": False, "mensagem": str(e)}
+
+
+# ---------------------------------------------------------------------------
+# Roteiro (7k–9k caracteres)
+# ---------------------------------------------------------------------------
+
+def gerar_roteiro(tema: str, titulo: str = "", tom: str = "informativo", duracao_min: int = 8) -> dict:
+    """Gera o roteiro do vídeo faceless. Retorna {roteiro, origem, aviso}."""
+    if configurado():
+        sistema = (
+            "Você é um roteirista profissional de vídeos faceless para YouTube, "
+            "especialista em retenção. Escreva em português do Brasil."
+        )
+        usuario = (
+            f"Escreva um roteiro completo para um vídeo faceless de YouTube sobre: {tema}.\n"
+            f"Título de trabalho: {titulo or '(crie um título)'}\n"
+            f"Tom: {tom}. Duração estimada: {duracao_min} minutos.\n"
+            "REQUISITOS:\n"
+            "- Entre 7000 e 9000 caracteres de texto corrido (sem marcadores de cena).\n"
+            "- Comece com um gancho de 2 frases que prende na primeira.\n"
+            "- Use seções lógicas, exemplos concretos e números.\n"
+            "- Termine com CTA para inscrever-se no canal.\n"
+            "- Apenas o texto do roteiro, sem títulos em markdown."
+        )
+        try:
+            texto = chat(
+                [{"role": "system", "content": sistema}, {"role": "user", "content": usuario}],
+                temperature=0.8,
+                max_tokens=6000,
+            )
+            return {"roteiro": texto.strip(), "origem": "llm", "aviso": ""}
+        except LLMErro as e:
+            raise  # configurado mas falhou: etapa deve falhar com mensagem acionável
+    return {
+        "roteiro": _roteiro_local(tema, titulo, tom, duracao_min),
+        "origem": "local",
+        "aviso": "LLM não configurado — roteiro gerado por modelo local (rascunho). Configure o LLM em Ferramentas para roteiros completos de 7k–9k caracteres.",
+    }
+
+
+def _roteiro_local(tema: str, titulo: str, tom: str, duracao_min: int) -> str:
+    """Rascunho estruturado, honesto sobre sua origem local."""
+    titulo = titulo or f"{tema}: o guia definitivo"
+    blocos = max(3, duracao_min)
+    linhas = [
+        f"[GANCHO] {titulo}. Nos próximos {duracao_min} minutos você vai entender exatamente "
+        f"como {tema.lower()} funciona na prática — e por que quase todo mundo erra nisso. Fica até o final.",
+        "",
+        "[INTRODUÇÃO]",
+        f"Antes de qualquer coisa: o que é {tema.lower()}? É a diferença entre agir no escuro "
+        "e agir com método. Neste vídeo eu vou te mostrar o passo a passo completo.",
+        "",
+    ]
+    for i in range(1, blocos + 1):
+        linhas += [
+            f"[PARTE {i} — PONTO-CHAVE {i}]",
+            f"Primeiro, o contexto: a maior parte das pessoas que tenta {tema.lower()} falha porque "
+            "pula a etapa de preparação. Não faça isso. Comece pelo diagnóstico simples: onde você "
+            "está hoje e qual é o resultado mínimo que já mudaria seu jogo.",
+            f"Segundo, a execução: escolha UMA estratégia de {tema.lower()} e execute-a por 14 dias "
+            "sem mudar de rota. Registre os números. O que não é medido não melhora.",
+            f"Terceiro, o erro comum da parte {i}: fazer mais do mesmo esperando resultado diferente. "
+            "Ajuste uma variável por vez e observe.",
+            "",
+        ]
+    linhas += [
+        "[ENCERRAMENTO E CTA]",
+        "Se esse vídeo te ajudou, se inscreve no canal e ativa o sininho — toda semana tem "
+        f"conteúdo novo sobre {tema.lower()}. Comenta aqui qual etapa você vai aplicar primeiro. Até o próximo!",
+        "",
+        "(Rascunho gerado localmente pelo LeadMaster, sem LLM. Configure seu LLM em "
+        "Ferramentas para gerar roteiros completos de 7.000 a 9.000 caracteres.)",
+    ]
+    return "\n".join(linhas)
+
+
+def gerar_titulo_e_thumbnail(tema: str, roteiro: str) -> dict:
+    """Gera título otimizado + prompt de thumbnail. Retorna {titulo, titulo_alternativo, thumbnail_prompt, origem}."""
+    if configurado():
+        try:
+            resposta = chat(
+                [
+                    {
+                        "role": "system",
+                        "content": (
+                            "Você é especialista em SEO de YouTube. Responda APENAS com JSON válido, "
+                            'sem markdown, no formato: {"titulo": "...", "titulo_alternativo": "...", '
+                            '"thumbnail_prompt": "..."}. Títulos com até 60 caracteres, thumbnail_prompt '
+                            "em português, descrevendo imagem sem texto legível."
+                        ),
+                    },
+                    {
+                        "role": "user",
+                        "content": f"Tema do vídeo: {tema}\n\nRoteiro (início):\n{roteiro[:1500]}",
+                    },
+                ],
+                temperature=0.6,
+                max_tokens=500,
+            )
+            import json as _json
+
+            inicio = resposta.find("{")
+            dados = _json.loads(resposta[inicio:] if inicio >= 0 else resposta)
+            return {
+                "titulo": dados.get("titulo", ""),
+                "titulo_alternativo": dados.get("titulo_alternativo", ""),
+                "thumbnail_prompt": dados.get("thumbnail_prompt", ""),
+                "origem": "llm",
+            }
+        except (LLMErro, ValueError, KeyError):
+            pass  # cai no fallback local abaixo
+    return {
+        "titulo": f"{tema}: o guia definitivo (passo a passo)",
+        "titulo_alternativo": f"Como dominar {tema} em pouco tempo",
+        "thumbnail_prompt": (
+            f"Imagem 16:9 vibrante sobre {tema}, estilo minimalista de alto contraste, "
+            "pessoa em silhueta olhando para resultado crescente, cores indigo e roxo, sem texto."
+        ),
+        "origem": "local",
+    }

package/backend/services/moneyprinter.py

@@ -0,0 +1,102 @@
+"""Integração com o MoneyPrinterTurbo (produção de vídeos wide 16:9).
+
+API esperada (padrão do projeto): POST http://localhost:8080/api/v1/videos
+Cria a tarefa e consulta o progresso até o vídeo ficar pronto.
+"""
+
+import time
+
+import httpx
+
+from . import storage
+
+
+class ServicoIndisponivel(Exception):
+    """MoneyPrinterTurbo não está rodando — mensagem acionável."""
+
+
+class ProducaoErro(Exception):
+    """O serviço respondeu, mas a produção falhou."""
+
+
+def _conf() -> dict:
+    return storage.get_config()["integracoes"]["moneyprinter"]
+
+
+def _url() -> str:
+    return _conf()["url"].rstrip("/")
+
+
+def verificar() -> bool:
+    """True se o serviço responde (qualquer código HTTP conta como 'vivo')."""
+    try:
+        httpx.get(_url() + "/docs", timeout=2)
+        return True
+    except httpx.HTTPError:
+        try:
+            httpx.get(_url(), timeout=2)
+            return True
+        except httpx.HTTPError:
+            return False
+
+
+def criar_video_wide(
+    subject: str,
+    script: str,
+    terms: str = "",
+    duracao_segundos: int = 60,
+    voz: str = "pt-BR-Standard",
+) -> str:
+    """Cria a tarefa de vídeo wide (16:9). Retorna o task_id."""
+    payload = {
+        "video_subject": subject,
+        "video_script": script,
+        "video_terms": terms or subject,
+        "video_aspect": "16:9",
+        "video_clip_duration": min(duracao_segundos, 20),
+        "video_source_provider": "pexels",
+        "voice_volume": 1.0,
+        "voice_rate": 1.0,
+    }
+    try:
+        r = httpx.post(_url() + "/api/v1/videos", json=payload, timeout=120)
+    except httpx.HTTPError as e:
+        raise ServicoIndisponivel(
+            f"MoneyPrinterTurbo não respondeu em {_url()}. "
+            "Inicie o serviço (uvicorn app.server:app) e clique em Repetir."
+        ) from e
+    if r.status_code >= 400:
+        raise ProducaoErro(f"MoneyPrinterTurbo rejeitou a tarefa (HTTP {r.status_code}): {r.text[:300]}")
+    task_id = (r.json().get("data") or {}).get("task_id")
+    if not task_id:
+        raise ProducaoErro(f"Resposta sem task_id: {r.text[:300]}")
+    return task_id
+
+
+def aguardar_video(task_id: str, timeout_min: int = 20, a_cada_progresso=None) -> dict:
+    """Sonda a tarefa até concluir. Retorna {progresso, videos, saidas}."""
+    limite = time.time() + timeout_min * 60
+    while time.time() < limite:
+        try:
+            r = httpx.get(_url() + "/api/v1/tasks", params={"task_id": task_id}, timeout=15)
+        except httpx.HTTPError as e:
+            raise ServicoIndisponivel(
+                f"MoneyPrinterTurbo sumiu durante a produção: {e}. Clique em Repetir com o serviço ativo."
+            ) from e
+        if r.status_code >= 500:
+            time.sleep(5)
+            continue
+        data = (r.json() or {}).get("data") or {}
+        task = data
+        if isinstance(data.get("tasks"), list) and data["tasks"]:
+            task = data["tasks"][0]
+        progresso = task.get("progress") or 0
+        if a_cada_progresso:
+            a_cada_progresso(progresso)
+        if task.get("videos"):
+            return {"progresso": 100, "videos": task["videos"], "saidas": task.get("progress_details", {})}
+        time.sleep(5)
+    raise ProducaoErro(
+        f"A tarefa {task_id} não ficou pronta em {timeout_min} minutos. "
+        "Verifique o MoneyPrinterTurbo e use Repetir."
+    )

package/backend/services/openmontage.py

@@ -0,0 +1,62 @@
+"""Integração com o OpenMontage (CLI local, fallback de produção de vídeos).
+
+O caminho do executável é configurável em Ferramentas → OpenMontage.
+Como as flags do CLI podem variar entre versões, usamos um template de
+argumentos configurável com os placeholders {roteiro} e {saida}.
+"""
+
+import subprocess
+from pathlib import Path
+
+from . import storage
+
+
+class IntegracaoNaoConfigurada(Exception):
+    """Caminho do CLI não configurado — mensagem acionável."""
+
+
+class ExecucaoErro(Exception):
+    """O CLI falhou; stderr vai na mensagem."""
+
+
+def _conf() -> dict:
+    return storage.get_config()["integracoes"]["openmontage"]
+
+
+def disponivel() -> bool:
+    cli = _conf().get("cli_path", "")
+    return bool(cli) and Path(cli).exists()
+
+
+def produzir(job_id: str, roteiro_path: str) -> dict:
+    """Executa o OpenMontage com o roteiro e devolve {video_path}."""
+    conf = _conf()
+    cli = conf.get("cli_path", "")
+    if not cli or not Path(cli).exists():
+        raise IntegracaoNaoConfigurada(
+            "OpenMontage não configurado. Informe o caminho do executável em "
+            "Ferramentas → OpenMontage (https://github.com/openmotional/OpenMontage) "
+            "ou mantenha o MoneyPrinterTurbo ativo."
+        )
+    saida = storage.videos_dir() / job_id
+    saida.mkdir(parents=True, exist_ok=True)
+    try:
+        resultado = subprocess.run(
+            [cli, roteiro_path, "--output", str(saida)],
+            capture_output=True,
+            text=True,
+            timeout=1800,
+            shell=False,
+        )
+    except FileNotFoundError as e:
+        raise IntegracaoNaoConfigurada(f"Não foi possível executar o CLI do OpenMontage: {e}") from e
+    except subprocess.TimeoutExpired as e:
+        raise ExecucaoErro("OpenMontage passou de 30 minutos sem concluir.") from e
+    if resultado.returncode != 0:
+        raise ExecucaoErro(f"OpenMontage terminou com código {resultado.returncode}: {resultado.stderr[-400:]}")
+    mp4 = sorted(saida.glob("*.mp4"))
+    return {
+        "video_path": str(mp4[-1]) if mp4 else None,
+        "pasta_saida": str(saida),
+        "observacao": "" if mp4 else "Execução OK, mas nenhum .mp4 encontrado na pasta de saída.",
+    }