@danhachuel/leadmaster 0.0.0-stage → 0.1.0

package/backend/services/pipeline.py

@@ -0,0 +1,515 @@
+"""Motor do pipeline de vídeos faceless.
+
+Cada job atravessa 5 etapas:
+    roteiro → thumbnail → wide (16:9) → shorts (9:16) → upload
+
+- Cada etapa roda em uma thread própria do job, com checkpoints de PAUSAR/PARAR
+  entre etapas e persistência imediata no `pipeline.json`.
+- Falhas sempre viram mensagens acionáveis + botão Repetir no frontend.
+- O agendador publica vídeos (não listado → público) após 1h do upload.
+"""
+
+import threading
+import time
+import uuid
+from datetime import datetime, timedelta
+
+from . import agents, llm, moneyprinter, openmontage, short_video_maker, storage, youtube_upload
+
+ETAPAS = ["roteiro", "thumbnail", "wide", "shorts", "upload"]
+ETAPA_LABELS = {
+    "roteiro": "Roteiro",
+    "thumbnail": "Thumbnail/Título",
+    "wide": "Produção Wide (16:9)",
+    "shorts": "Produção Shorts (9:16)",
+    "upload": "Upload YouTube",
+}
+STATUS_JOB = ["rascunho", "em_andamento", "pausado", "concluido", "erro", "cancelado"]
+
+
+class _Parada(Exception):
+    """Sinal interno: o usuário pediu parar/cancelar o job."""
+
+
+def progresso(job: dict) -> int:
+    """Progresso 0–100 (etapas puladas contam como concluídas)."""
+    etapas = job.get("etapas", [])
+    if not etapas:
+        return 0
+    feitas = sum(1 for e in etapas if e["status"] in ("concluida", "pulada"))
+    em_curso = sum(0.5 for e in etapas if e["status"] == "em_andamento")
+    return int(round((feitas + em_curso) / len(etapas) * 100))
+
+
+def _hora() -> str:
+    return datetime.now().strftime("%H:%M:%S")
+
+
+class PipelineEngine:
+    def __init__(self):
+        self._pausas: dict[str, threading.Event] = {}
+        self._paradas: dict[str, threading.Event] = {}
+        self._threads: dict[str, threading.Thread] = {}
+
+    # ------------------------------------------------------------------
+    # Criação e consulta
+    # ------------------------------------------------------------------
+
+    def criar_job(self, dados: dict) -> dict:
+        tema = (dados.get("tema") or "").strip()
+        if not tema:
+            raise ValueError("Informe o tema do vídeo.")
+        formatos = dados.get("formatos") or ["wide", "shorts"]
+        formatos = [f for f in formatos if f in ("wide", "shorts")]
+        if not formatos:
+            raise ValueError("Selecione ao menos um formato (Wide e/ou Shorts).")
+
+        job = {
+            "id": uuid.uuid4().hex[:12],
+            "titulo": (dados.get("titulo") or "").strip(),
+            "tema": tema,
+            "tom": dados.get("tom") or "informativo",
+            "duracao_min": max(1, min(20, int(dados.get("duracao_min") or 8))),
+            "keyword_seo": (dados.get("keyword_seo") or "").strip(),
+            "formatos": formatos,
+            "criado_em": storage.now_iso(),
+            "atualizado_em": storage.now_iso(),
+            "status": "rascunho",
+            "etapa_atual": None,
+            "etapas": [
+                {
+                    "id": etapa,
+                    "nome": ETAPA_LABELS[etapa],
+                    "status": "pendente",
+                    "iniciada_em": None,
+                    "concluida_em": None,
+                    "mensagem": "",
+                    "dados": {},
+                    "logs": [],
+                }
+                for etapa in ETAPAS
+            ],
+            "dados": {},
+            "upload": {},
+        }
+        storage.upsert_job(job)
+        return job
+
+    def listar(self) -> list:
+        jobs = storage.list_jobs()
+        for job in jobs:
+            job["progresso"] = progresso(job)
+        return sorted(jobs, key=lambda j: j.get("criado_em", ""), reverse=True)
+
+    # ------------------------------------------------------------------
+    # Controles (iniciar/pausar/parar/repetir)
+    # ------------------------------------------------------------------
+
+    def agir(self, job_id: str, acao: str) -> dict:
+        if acao == "repetir":
+            self._resetar_erro(job_id)
+            return self.iniciar(job_id)
+        if acao == "iniciar":
+            return self.iniciar(job_id)
+        if acao == "pausar":
+            return self.pausar(job_id)
+        if acao == "parar":
+            return self.parar(job_id)
+        raise ValueError(f"Ação desconhecida: {acao}")
+
+    def _resetar_erro(self, job_id: str) -> None:
+        """Repetir: volta a primeira etapa com erro para pendente."""
+        job = storage.get_job(job_id)
+        if not job:
+            return
+        for etapa in job["etapas"]:
+            if etapa["status"] == "erro":
+                etapa["status"] = "pendente"
+                etapa["iniciada_em"] = None
+                etapa["concluida_em"] = None
+                etapa["mensagem"] = "Repetição solicitada pelo usuário."
+                break
+        storage.upsert_job(job)
+
+    def iniciar(self, job_id: str) -> dict:
+        job = storage.get_job(job_id)
+        if not job:
+            return {"ok": False, "mensagem": "Job não encontrado."}
+        if job["status"] == "em_andamento":
+            return {"ok": False, "mensagem": "Job já está em andamento."}
+        if job["status"] == "concluido":
+            return {"ok": False, "mensagem": "Job já concluído — crie um novo vídeo."}
+
+        self._pausas.setdefault(job_id, threading.Event())
+        self._pausas[job_id].clear()
+        self._paradas.setdefault(job_id, threading.Event())
+        self._paradas[job_id].clear()
+
+        thread = self._threads.get(job_id)
+        if thread and thread.is_alive():
+            job["status"] = "em_andamento"
+            job["atualizado_em"] = storage.now_iso()
+            storage.upsert_job(job)
+            return {"ok": True, "mensagem": "Job retomado."}
+
+        job["status"] = "em_andamento"
+        job["atualizado_em"] = storage.now_iso()
+        storage.upsert_job(job)
+        t = threading.Thread(target=self._executar, args=(job_id,), daemon=True)
+        self._threads[job_id] = t
+        t.start()
+        return {"ok": True, "mensagem": "Pipeline iniciado."}
+
+    def pausar(self, job_id: str) -> dict:
+        pausa = self._pausas.get(job_id)
+        thread = self._threads.get(job_id)
+        if not pausa or not thread or not thread.is_alive():
+            return {"ok": False, "mensagem": "Job não está em execução."}
+        pausa.set()
+        return {"ok": True, "mensagem": "Pausa solicitada — aplicada entre etapas."}
+
+    def parar(self, job_id: str) -> dict:
+        parada = self._paradas.setdefault(job_id, threading.Event())
+        parada.set()
+        pausa = self._pausas.get(job_id)
+        if pausa:
+            pausa.clear()  # destrava a espera para que a parada seja percebida
+        return {"ok": True, "mensagem": "Parada solicitada."}
+
+    # ------------------------------------------------------------------
+    # Worker
+    # ------------------------------------------------------------------
+
+    def _checar(self, job_id: str) -> None:
+        parada = self._paradas.get(job_id)
+        if parada and parada.is_set():
+            raise _Parada()
+        pausa = self._pausas.get(job_id)
+        if pausa and pausa.is_set():
+            job = storage.get_job(job_id)
+            if job and job["status"] == "em_andamento":
+                job["status"] = "pausado"
+                job["atualizado_em"] = storage.now_iso()
+                storage.upsert_job(job)
+            while pausa.is_set():
+                time.sleep(0.5)
+                if parada and parada.is_set():
+                    raise _Parada()
+            job = storage.get_job(job_id)
+            if job and job["status"] == "pausado":
+                job["status"] = "em_andamento"
+                job["atualizado_em"] = storage.now_iso()
+                storage.upsert_job(job)
+
+    def _executar(self, job_id: str) -> None:
+        try:
+            while True:
+                job = storage.get_job(job_id)
+                if not job:
+                    return
+                pendente = None
+                for etapa in job["etapas"]:
+                    if etapa["status"] == "pendente":
+                        pendente = etapa
+                        break
+                if pendente is None:
+                    # Nada mais a executar: conclui com o status correto.
+                    com_erro = any(e["status"] == "erro" for e in job["etapas"])
+                    job["status"] = "erro" if com_erro else "concluido"
+                    job["etapa_atual"] = None
+                    job["atualizado_em"] = storage.now_iso()
+                    storage.upsert_job(job)
+                    return
+                self._checar(job_id)
+                self._executar_etapa(job_id, pendente["id"])
+                # Etapa falhou? Interrompe o fluxo — "Repetir" retoma daqui.
+                job = storage.get_job(job_id)
+                if job and job["status"] == "erro":
+                    return
+        except _Parada:
+            job = storage.get_job(job_id)
+            if job:
+                job["status"] = "cancelado"
+                job["atualizado_em"] = storage.now_iso()
+                for etapa in job["etapas"]:
+                    if etapa["status"] == "em_andamento":
+                        etapa["status"] = "pendente"
+                        etapa["mensagem"] = "Etapa interrompida."
+                storage.upsert_job(job)
+        except Exception as e:  # erro inesperado fora das etapas
+            job = storage.get_job(job_id)
+            if job:
+                job["status"] = "erro"
+                job["atualizado_em"] = storage.now_iso()
+                storage.upsert_job(job)
+
+    def _executar_etapa(self, job_id: str, etapa_id: str) -> None:
+        job = storage.get_job(job_id)
+        etapa = next(e for e in job["etapas"] if e["id"] == etapa_id)
+        etapa["status"] = "em_andamento"
+        etapa["iniciada_em"] = storage.now_iso()
+        job["etapa_atual"] = etapa_id
+        job["atualizado_em"] = storage.now_iso()
+        storage.upsert_job(job)
+
+        try:
+            if etapa_id == "roteiro":
+                resultado = self._etapa_roteiro(job)
+            elif etapa_id == "thumbnail":
+                resultado = self._etapa_thumbnail(job)
+            elif etapa_id == "wide":
+                resultado = self._etapa_wide(job)
+            elif etapa_id == "shorts":
+                resultado = self._etapa_shorts(job)
+            elif etapa_id == "upload":
+                resultado = self._etapa_upload(job)
+            else:
+                raise ValueError(f"Etapa desconhecida: {etapa_id}")
+        except Exception as e:
+            job = storage.get_job(job_id)
+            etapa = next(e2 for e2 in job["etapas"] if e2["id"] == etapa_id)
+            etapa["status"] = "erro"
+            etapa["mensagem"] = str(e)
+            etapa["logs"].append(f"[{_hora()}] ✗ {e}")
+            etapa["concluida_em"] = storage.now_iso()
+            job["status"] = "erro"
+            job["atualizado_em"] = storage.now_iso()
+            storage.upsert_job(job)
+            return
+
+        job = storage.get_job(job_id)
+        etapa = next(e2 for e2 in job["etapas"] if e2["id"] == etapa_id)
+        etapa["status"] = resultado["status"]
+        etapa["mensagem"] = resultado["mensagem"]
+        etapa["dados"] = resultado.get("dados", {})
+        etapa["concluida_em"] = storage.now_iso()
+        for linha in resultado.get("logs", []):
+            etapa["logs"].append(f"[{_hora()}] {linha}")
+        job["dados"].update(resultado.get("job_dados", {}))
+        if "upload" in resultado.get("job_dados", {}):
+            job["upload"] = resultado["job_dados"]["upload"]
+        job["etapa_atual"] = None
+        job["atualizado_em"] = storage.now_iso()
+        storage.upsert_job(job)
+
+    # ------------------------------------------------------------------
+    # Etapas
+    # ------------------------------------------------------------------
+
+    def _etapa_roteiro(self, job: dict) -> dict:
+        resultado = llm.gerar_roteiro(
+            tema=job["tema"],
+            titulo=job.get("titulo", ""),
+            tom=job.get("tom", "informativo"),
+            duracao_min=job.get("duracao_min", 8),
+        )
+        roteiro = resultado["roteiro"]
+        arquivo = storage.roteiros_dir() / f"{job['id']}.txt"
+        arquivo.write_text(roteiro, encoding="utf-8")
+        logs = [
+            f"Roteiro com {len(roteiro):,} caracteres (origem: {resultado['origem']}).".replace(",", "."),
+            f"Salvo em {arquivo}",
+        ]
+        if resultado.get("aviso"):
+            logs.append(f"⚠ {resultado['aviso']}")
+        return {
+            "status": "concluida",
+            "mensagem": f"Roteiro pronto ({len(roteiro):,} caracteres — {resultado['origem']}).".replace(",", "."),
+            "job_dados": {
+                "roteiro": roteiro,
+                "roteiro_chars": len(roteiro),
+                "arquivo_roteiro": str(arquivo),
+                "origem_roteiro": resultado["origem"],
+            },
+            "logs": logs,
+        }
+
+    def _etapa_thumbnail(self, job: dict) -> dict:
+        resultado = llm.gerar_titulo_e_thumbnail(job["tema"], job.get("dados", {}).get("roteiro", ""))
+        return {
+            "status": "concluida",
+            "mensagem": (
+                f"Título e prompt de thumbnail gerados ({resultado['origem']}). "
+                "Renderize a imagem no MoneyPrinterTurbo com o prompt salvo."
+            ),
+            "job_dados": {
+                "titulo_gerado": resultado["titulo"],
+                "titulo_alternativo": resultado["titulo_alternativo"],
+                "thumbnail_prompt": resultado["thumbnail_prompt"],
+                "origem_titulo": resultado["origem"],
+            },
+            "logs": [
+                f"Título: {resultado['titulo']}",
+                f"Alternativo: {resultado['titulo_alternativo']}",
+                f"Prompt thumbnail: {resultado['thumbnail_prompt'][:120]}...",
+            ],
+        }
+
+    def _etapa_wide(self, job: dict) -> dict:
+        if "wide" not in job.get("formatos", []):
+            return {"status": "pulada", "mensagem": "Formato Wide não selecionado para este job.", "logs": []}
+        roteiro = job.get("dados", {}).get("roteiro", "")
+        subject = job.get("dados", {}).get("titulo_gerado") or job.get("titulo") or job["tema"]
+        logs = []
+        try:
+            task_id = moneyprinter.criar_video_wide(
+                subject=subject,
+                script=roteiro,
+                terms=job.get("keyword_seo") or job["tema"],
+            )
+            logs.append(f"Tarefa criada no MoneyPrinterTurbo: {task_id}")
+            resultado = moneyprinter.aguardar_video(task_id, timeout_min=20)
+            videos = resultado.get("videos", [])
+            logs.append(f"Vídeo wide pronto: {videos[0] if videos else 'sem URL listada'}")
+            return {
+                "status": "concluida",
+                "mensagem": "Vídeo wide 16:9 produzido com MoneyPrinterTurbo.",
+                "job_dados": {"videos_wide": videos, "task_id_wide": task_id, "producao_wide": "moneyprinter"},
+                "logs": logs,
+            }
+        except moneyprinter.ServicoIndisponivel as e:
+            logs.append(f"✗ {e}")
+            if openmontage.disponivel():
+                logs.append("Tentando fallback via OpenMontage...")
+                om = openmontage.produzir(job["id"], job["dados"]["arquivo_roteiro"])
+                logs.append(f"OpenMontage concluído: {om.get('video_path') or om.get('observacao')}")
+                return {
+                    "status": "concluida",
+                    "mensagem": "Vídeo wide produzido via OpenMontage (fallback).",
+                    "job_dados": {
+                        "videos_wide": [],
+                        "arquivo_local": om.get("video_path") or "",
+                        "producao_wide": "openmontage",
+                    },
+                    "logs": logs,
+                }
+            raise
+
+    def _etapa_shorts(self, job: dict) -> dict:
+        if "shorts" not in job.get("formatos", []):
+            return {"status": "pulada", "mensagem": "Formato Shorts não selecionado para este job.", "logs": []}
+        roteiro = job.get("dados", {}).get("roteiro", "")
+        titulo = job.get("dados", {}).get("titulo_gerado") or job.get("titulo") or job["tema"]
+        resultado = short_video_maker.criar_short(
+            titulo=titulo,
+            script=roteiro,
+            tema=job["tema"],
+        )
+        return {
+            "status": "concluida",
+            "mensagem": "Tarefa enviada ao Short-Video-Maker (9:16).",
+            "job_dados": {"resposta_shorts": resultado},
+            "logs": [f"HTTP {resultado['status_http']} do Short-Video-Maker."],
+        }
+
+    def _etapa_upload(self, job: dict) -> dict:
+        conf = storage.get_config()["integracoes"]["youtube_upload"]
+        if not (conf.get("url") or conf.get("uploader_mcp_path")):
+            return {
+                "status": "pulada",
+                "mensagem": (
+                    "Upload manual: nenhum uploader configurado. Configure em "
+                    "Ferramentas → Upload YouTube e clique em Repetir."
+                ),
+                "logs": ["Uploader não configurado — etapa pulada (não é erro)."],
+            }
+        videos = job.get("dados", {}).get("videos_wide") or []
+        arquivo = job.get("dados", {}).get("arquivo_local") or ""
+        if not videos and not arquivo:
+            raise youtube_upload.UploadErro(
+                "Nenhum vídeo produzido para enviar. Conclua a etapa de produção (Wide) antes do upload."
+            )
+        titulo = job.get("dados", {}).get("titulo_gerado") or job.get("titulo") or job["tema"]
+        descricao = f"{titulo}\n\n{job.get('keyword_seo') or job['tema']}\n\nGerado pelo LeadMaster."
+        resultado = youtube_upload.upload_video(
+            titulo=titulo,
+            descricao=descricao,
+            arquivo=arquivo,
+            video_url=videos[0] if videos else "",
+            tags=job.get("keyword_seo", ""),
+        )
+        upload = dict(job.get("upload") or {})
+        upload.update(
+            {
+                "video_id": resultado.get("video_id", ""),
+                "url": resultado.get("url", ""),
+                "modo_upload": resultado.get("modo", ""),
+                "status": "nao_listado",
+                "publicado_em": None,
+            }
+        )
+        logs = [f"Upload via {resultado.get('modo')} concluído: {resultado.get('url') or resultado.get('video_id')}"]
+        if conf.get("modo") == "nao_listado_1h_publico":
+            horas = max(0, int(conf.get("espera_publicacao_horas", 1)))
+            agenda = (datetime.now().astimezone() + timedelta(hours=horas)).isoformat(timespec="seconds")
+            upload["agenda_publicacao"] = agenda
+            logs.append(f"Vídeo não listado; publicação automática agendada para {agenda}.")
+            mensagem = f"Upload não listado criado. Publicação automática em {horas}h ({agenda[11:16]})."
+        else:
+            upload["agenda_publicacao"] = None
+            mensagem = "Upload criado (modo direto, sem agendamento)."
+        return {
+            "status": "concluida",
+            "mensagem": mensagem,
+            "job_dados": {"upload": upload},
+            "logs": logs,
+        }
+
+    # ------------------------------------------------------------------
+    # Agendador de publicação (não listado → público)
+    # ------------------------------------------------------------------
+
+    def iniciar_agendador(self) -> None:
+        if getattr(self, "_agendador_ativo", False):
+            return
+        self._agendador_ativo = True
+        threading.Thread(target=self._loop_agendador, daemon=True).start()
+
+    def _loop_agendador(self) -> None:
+        while True:
+            time.sleep(60)
+            try:
+                self._processar_agenda()
+            except Exception:
+                pass  # agendador é resiliente por definição
+
+    def _processar_agenda(self) -> None:
+        agora = datetime.now().astimezone()
+        for job in storage.list_jobs():
+            upload = job.get("upload") or {}
+            agenda = upload.get("agenda_publicacao")
+            if not agenda or upload.get("publicado_em"):
+                continue
+            if datetime.fromisoformat(agenda) > agora:
+                continue
+            if int(upload.get("tentativas", 0)) >= 10:
+                upload["agenda_publicacao"] = None
+                upload["status"] = "falhou"
+                job["upload"] = upload
+                storage.upsert_job(job)
+                continue
+            try:
+                youtube_upload.tornar_publico(upload.get("video_id", ""))
+                upload["publicado_em"] = storage.now_iso()
+                upload["status"] = "publico"
+                upload.pop("ultimo_erro", None)
+                job["upload"] = upload
+                storage.upsert_job(job)
+                agents.disparar_webhook("video.publicado", {"job_id": job["id"], "url": upload.get("url")})
+            except Exception as e:
+                upload["tentativas"] = int(upload.get("tentativas", 0)) + 1
+                upload["ultimo_erro"] = str(e)
+                job["upload"] = upload
+                storage.upsert_job(job)
+
+    def recuperar(self) -> None:
+        """Após reinício do servidor: jobs 'em_andamento' voltam a 'pausado'."""
+        for job in storage.list_jobs():
+            if job.get("status") == "em_andamento":
+                job["status"] = "pausado"
+                job["atualizado_em"] = storage.now_iso()
+                for etapa in job["etapas"]:
+                    if etapa["status"] == "em_andamento":
+                        etapa["status"] = "pendente"
+                        etapa["mensagem"] = "Etapa interrompida pelo reinício do servidor."
+                storage.upsert_job(job)

package/backend/services/short_video_maker.py

@@ -0,0 +1,72 @@
+"""Integração com o Short-Video-Maker (produção de Shorts 9:16).
+
+API esperada: POST http://localhost:3123/api/short-video
+Como o formato exato do projeto pode variar, a resposta bruta (truncada) é
+sempre guardada no job para inspeção.
+"""
+
+import httpx
+
+from . import storage
+
+
+class ServicoIndisponivel(Exception):
+    """Short-Video-Maker 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"]["short_video_maker"]
+
+
+def _url() -> str:
+    return _conf()["url"].rstrip("/")
+
+
+def verificar() -> bool:
+    try:
+        httpx.get(_url(), timeout=2)
+        return True
+    except httpx.HTTPError:
+        return False
+
+
+def criar_short(
+    titulo: str,
+    script: str,
+    tema: str = "",
+    voz: str = "pt-BR",
+    duracao_segundos: int = 45,
+) -> dict:
+    """Envia o roteiro cortado para o Short-Video-Maker e devolve a resposta."""
+    # Shorts usam o início do roteiro (gancho) — corte na primeira quebra limpa.
+    corte = script[:1200]
+    if len(script) > 1200:
+        fim = corte.rfind(". ")
+        corte = corte[: fim + 1] if fim > 400 else corte
+    payload = {
+        "title": titulo,
+        "script": corte,
+        "topic": tema or titulo,
+        "voice": voz,
+        "duration": duracao_segundos,
+        "aspect": "9:16",
+    }
+    try:
+        r = httpx.post(_url() + "/api/short-video", json=payload, timeout=300)
+    except httpx.HTTPError as e:
+        raise ServicoIndisponivel(
+            f"Short-Video-Maker não respondeu em {_url()}. "
+            "Inicie o serviço na porta 3123 e clique em Repetir."
+        ) from e
+    texto = r.text[:600]
+    if r.status_code >= 400:
+        raise ProducaoErro(f"Short-Video-Maker rejeitou a tarefa (HTTP {r.status_code}): {texto}")
+    try:
+        corpo = r.json()
+    except ValueError:
+        corpo = {"resposta_bruta": texto}
+    return {"status_http": r.status_code, "resposta": corpo}