@danhachuel/thunderbolt 0.7.30 → 0.7.32

package/app/main.py

@@ -1,6 +1,8 @@
 import os
 import sys
 import io
+import shutil
+import subprocess
 
 os.environ["PYTHONIOENCODING"] = "utf-8"
 os.environ["PYTHONUTF8"] = "1"
@@ -139,6 +141,7 @@ from hermes_ui.growth_tiktok import render_growth_tiktok
 from hermes_ui.growth_instagram import render_growth_instagram
 from hermes_ui.growth_facebook_pages import render_growth_facebook_pages
 from hermes_ui.growth_bilibili import render_growth_bilibili
+from hermes_ui.facebook_automation import caption_images, collect_images, create_post, generate_article, generate_theme, list_posts, publish_to_facebook, save_post
 from hermes_ui.canva_auth import authorization_url, create_pkce_pair, create_state, exchange_code
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
 from integrations.tiktok_public import fetch_public_tiktok_profile, normalize_tiktok_reference
@@ -632,6 +635,32 @@ def _library_card_key(kind: str, path: Path) -> str:
     return hashlib.sha1(f"{kind}:{path.resolve()}".encode("utf-8")).hexdigest()[:12]
 
 
+def _video_thumbnail(path: Path) -> bytes | None:
+    """Create a small cached preview frame for a local video card."""
+    if not path.is_file():
+        return None
+    thumbnail_dir = STORAGE / "ui_cache" / "video_thumbnails"
+    thumbnail_dir.mkdir(parents=True, exist_ok=True)
+    target = thumbnail_dir / f"{hashlib.sha1(str(path.resolve()).encode('utf-8')).hexdigest()}.jpg"
+    try:
+        if target.is_file() and target.stat().st_mtime >= path.stat().st_mtime:
+            return target.read_bytes()
+        ffmpeg = shutil.which("ffmpeg")
+        if not ffmpeg:
+            return None
+        completed = subprocess.run(
+            [ffmpeg, "-y", "-hide_banner", "-loglevel", "error", "-ss", "00:00:01", "-i", str(path), "-frames:v", "1", "-vf", "scale=640:-2", str(target)],
+            capture_output=True,
+            check=False,
+            timeout=20,
+        )
+        if completed.returncode == 0 and target.is_file():
+            return target.read_bytes()
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return None
+
+
 def _render_library_name_editor(kind: str, path: Path, current_name: str) -> str:
     """Render the inline name editor while keeping the physical filename unchanged."""
     edit_key = f"rename_{kind}_{_library_card_key(kind, path)}"
@@ -4832,12 +4861,7 @@ def render_media_download():
 
 def render_cuts():
     st.title("Cortes")
-    st.caption("Crie clips verticais, quadrados ou horizontais a partir de vídeos longos, com um fluxo local inspirado no Clip Generator do OpenShorts.")
-
-    st.markdown(
-        "<div class='tb-cuts-hero'><div class='tb-cuts-kicker'>01 · CLIP GENERATOR</div><h2>Create Viral Shorts</h2><p>Escolha um vídeo longo, defina o formato e gere clips locais sem sobrescrever a fonte.</p></div>",
-        unsafe_allow_html=True,
-    )
+    st.caption("Crie clips verticais, quadrados ou horizontais a partir de vídeos longos, sem sobrescrever a fonte.")
 
     source_path = None
     source_tab, url_tab, generated_tab, folder_tab = render_localized_tabs(["Upload ficheiro", "URL de vídeo", "Vídeos gerados", "Pasta local"])
@@ -4869,14 +4893,27 @@ def render_cuts():
     with generated_tab:
         generated_paths = list_cut_generated_videos(read_json("tasks.json", []))
         if not generated_paths:
-            st.info("Ainda não existem vídeos gerados com caminho registado na pipeline.")
+            st.info("Ainda não existem vídeos prontos na pipeline.")
         else:
-            generated_labels = [f"{path.name} — {path}" for path in generated_paths]
-            selected_generated = st.selectbox("Vídeo gerado", range(len(generated_paths)), format_func=lambda index: generated_labels[index], key="cuts_generated_index")
-            if st.button("Usar vídeo seleccionado", key="cuts_use_generated", width="stretch"):
-                source_path = generated_paths[selected_generated]
-                st.session_state["cuts_source_path"] = str(source_path)
-                st.session_state["cuts_source_label"] = f"Pipeline · {source_path.name}"
+            st.caption(f"{len(generated_paths)} vídeo(s) pronto(s) disponível(is).")
+            for index, generated_path in enumerate(generated_paths):
+                with st.expander(generated_path.stem, expanded=False):
+                    card_cols = st.columns([1.35, 2.4, 1.1])
+                    with card_cols[0]:
+                        thumbnail = _video_thumbnail(generated_path)
+                        if thumbnail:
+                            st.image(thumbnail, width="stretch")
+                        else:
+                            st.video(str(generated_path))
+                    with card_cols[1]:
+                        st.markdown(f"**{generated_path.stem}**")
+                        st.caption(f"Vídeo pronto · {generated_path.suffix.lstrip('.').upper()}")
+                        st.caption(f"{generated_path.stat().st_size / (1024 * 1024):.2f} MB")
+                    with card_cols[2]:
+                        if st.button("Usar vídeo", key=f"cuts_use_generated_{index}_{_library_card_key('cuts', generated_path)}", type="primary", width="stretch"):
+                            st.session_state["cuts_source_path"] = str(generated_path)
+                            st.session_state["cuts_source_label"] = f"Pipeline · {generated_path.stem}"
+                            st.rerun()
     with folder_tab:
         folder_value = st.text_input("Pasta de vídeos", value=str(STORAGE / "videos"), key="cuts_video_folder")
         folder_paths = list_cut_video_files(folder_value)
@@ -5027,11 +5064,28 @@ def render_python_editor():
             tasks = read_json("tasks.json", [])
             generated_paths = list_generated_videos(tasks)
             if not generated_paths:
-                st.info("Ainda não existem vídeos gerados com caminho registado nos artefactos da pipeline.")
+                st.info("Ainda não existem vídeos prontos nos artefactos da pipeline.")
             else:
-                labels = [f"{path.name} — {path}" for path in generated_paths]
-                selected_index = st.selectbox("Vídeo gerado", range(len(generated_paths)), format_func=lambda index: labels[index], key="python_editor_generated_index")
-                source_path = generated_paths[selected_index]
+                st.caption("Seleccione um vídeo pronto na pipeline.")
+                for index, generated_path in enumerate(generated_paths):
+                    with st.expander(generated_path.stem, expanded=False):
+                        card_cols = st.columns([1.35, 2.4, 1.1])
+                        with card_cols[0]:
+                            thumbnail = _video_thumbnail(generated_path)
+                            if thumbnail:
+                                st.image(thumbnail, width="stretch")
+                            else:
+                                st.video(str(generated_path))
+                        with card_cols[1]:
+                            st.markdown(f"**{generated_path.stem}**")
+                            st.caption(f"Vídeo pronto · {generated_path.suffix.lstrip('.').upper()}")
+                        with card_cols[2]:
+                            if st.button("Editar vídeo", key=f"python_use_generated_{index}_{_library_card_key('python', generated_path)}", type="primary", width="stretch"):
+                                st.session_state["python_editor_source_path"] = str(generated_path)
+                                st.rerun()
+                stored_generated = Path(str(st.session_state.get("python_editor_source_path") or ""))
+                if stored_generated.is_file() and stored_generated in generated_paths:
+                    source_path = stored_generated
         elif source_mode == "Pasta local":
             default_folder = str(STORAGE / "videos")
             folder_value = st.text_input("Pasta de vídeos", value=st.session_state.get("python_editor_folder", default_folder), key="python_editor_folder")
@@ -6283,6 +6337,130 @@ def _render_youtube_automation_cards():
                                     st.rerun()
 
 
+def _facebook_pages_for_automation() -> list[dict[str, Any]]:
+    return [channel for channel in read_json("channels.json", []) if isinstance(channel, dict) and classify_channel_platform(channel) == "facebook"]
+
+
+@st.fragment(run_every=5.0)
+def _render_facebook_automation_cards() -> None:
+    st.divider()
+    st.subheader("Posts Facebook em produção")
+    posts = list_posts()
+    if not posts:
+        st.info("Ainda não existem posts Facebook em produção.")
+        return
+    for post in posts:
+        post_id = str(post.get("id") or "")
+        with st.container(border=True):
+            cols = st.columns([2.5, 1.35, 1.15, 2.0], gap="small")
+            with cols[0]:
+                st.write(f"**{post.get('title') or post.get('theme') or 'Post sem tema'}**")
+                st.caption(f"{post.get('page_name') or 'Facebook Page'} · {post_id}")
+                st.caption(f"Etapa: {post.get('status', 'tema_pendente')}")
+                if post.get("article_text"):
+                    with st.expander("Ver artigo", expanded=False):
+                        st.text_area("Artigo", value=str(post["article_text"]), height=220, key=f"facebook_article_{post_id}", disabled=True)
+                image_records = post.get("images") if isinstance(post.get("images"), list) else []
+                if image_records:
+                    image_cols = st.columns(min(5, len(image_records)))
+                    for image_col, image in zip(image_cols, image_records):
+                        image_path = Path(str(image.get("captioned_path") or image.get("path") or ""))
+                        with image_col:
+                            if image_path.is_file():
+                                st.image(str(image_path), use_container_width=True)
+                            st.caption(str(image.get("status") or "pendente"))
+            with cols[1]:
+                st.caption("Estado")
+                st.write(str(post.get("status") or "tema_pendente").replace("_", " ").capitalize())
+                st.progress({"tema_pendente": 0, "artigo_pendente": 20, "imagens_pendentes": 45, "legendas_pendentes": 70, "pronto_upload": 90, "publicado": 100}.get(str(post.get("status")), 0), text=f"{len(post.get('images') or [])}/5 imagens")
+            with cols[2]:
+                st.caption("Imagens")
+                st.write(f"{len(post.get('images') or [])} previstas")
+                st.caption("Google Imagens ou IA")
+            with cols[3]:
+                settings = read_json("settings.json", {})
+                pages = _facebook_pages_for_automation()
+                page = next((item for item in pages if str(item.get("id")) == str(post.get("page_id"))), {})
+                if st.button("Gerar tema", key=f"facebook_generate_theme_{post_id}", disabled=str(post.get("status")) not in {"tema_pendente", "erro"}, width="stretch"):
+                    try:
+                        generate_theme(settings, post, page)
+                        st.success("Tema criado pelo LLM.")
+                        st.rerun()
+                    except Exception as exc:
+                        st.error(str(exc))
+                if st.button("Criar artigo", key=f"facebook_generate_article_{post_id}", disabled=str(post.get("status")) != "artigo_pendente", width="stretch"):
+                    try:
+                        generate_article(settings, post, page)
+                        st.success("Artigo e prompts de imagens criados pelo LLM.")
+                        st.rerun()
+                    except Exception as exc:
+                        st.error(str(exc))
+                source = st.selectbox("Fonte das imagens", ["Google Imagens", "Gerar com IA"], key=f"facebook_image_source_{post_id}")
+                if st.button("Buscar/Gerar imagens", key=f"facebook_collect_images_{post_id}", disabled=str(post.get("status")) != "imagens_pendentes", width="stretch"):
+                    try:
+                        collect_images(settings, post, source="google" if source == "Google Imagens" else "ai")
+                        st.success("Imagens processadas.")
+                        st.rerun()
+                    except Exception as exc:
+                        st.error(str(exc))
+                if st.button("Legendar imagens", key=f"facebook_caption_images_{post_id}", disabled=str(post.get("status")) != "legendas_pendentes", width="stretch"):
+                    try:
+                        caption_images(post)
+                        st.success("Textos aplicados nas imagens com Pillow.")
+                        st.rerun()
+                    except Exception as exc:
+                        st.error(str(exc))
+                if st.button("Upload para Facebook", key=f"facebook_publish_{post_id}", type="primary", disabled=str(post.get("status")) != "pronto_upload", width="stretch"):
+                    try:
+                        publish_to_facebook(post, page)
+                        st.success("Post publicado na Facebook Page.")
+                        st.rerun()
+                    except Exception as exc:
+                        st.error(str(exc))
+
+
+def render_facebook_automation() -> None:
+    st.title("Automação Facebook")
+    st.caption("Fluxo local de posts: Ideia/Tema → LLM → Artigo → Google Imagens ou IA → textos e legendas → Upload pela Meta Graph API.")
+    st.info("Esta página não usa planilhas nem Google Drive. Os artigos, imagens, legendas e estados ficam no armazenamento local do Thunderbolt.")
+    pages = _facebook_pages_for_automation()
+    settings = read_json("settings.json", {})
+    if not pages:
+        st.warning("Cadastre primeiro uma página em Canais e Perfis de Vídeos > Facebook Pages.")
+        return
+    with st.expander("Configurar API Facebook da página", expanded=False):
+        for page in pages:
+            page_id = str(page.get("id") or "")
+            with st.form(f"facebook_page_api_{page_id}"):
+                st.write(f"**{page.get('name') or 'Facebook Page'}**")
+                meta_page_id = st.text_input("Page ID da Meta", value=str(page.get("page_id") or page.get("facebook_page_id") or ""), key=f"facebook_meta_page_id_{page_id}")
+                access_token = st.text_input("Access Token da Page", value=str(page.get("access_token") or page.get("facebook_access_token") or ""), type="password", key=f"facebook_meta_token_{page_id}")
+                if st.form_submit_button("Guardar credenciais Facebook", type="primary"):
+                    update_channel(page_id, {"page_id": meta_page_id.strip(), "facebook_page_id": meta_page_id.strip(), "access_token": access_token.strip(), "facebook_access_token": access_token.strip()})
+                    st.success("Credenciais da página guardadas localmente.")
+                    st.rerun()
+    with st.form("facebook_automation_new_post"):
+        page_options = [str(page.get("id")) for page in pages]
+        page_labels = {str(page.get("id")): str(page.get("name") or "Facebook Page") for page in pages}
+        selected_page = st.selectbox("Facebook Page", page_options, format_func=lambda value: page_labels.get(value, value))
+        form_cols = st.columns([2.2, 1, 1.3])
+        with form_cols[0]:
+            theme = st.text_input("Tema/ideia opcional", placeholder="Deixe vazio para o LLM sugerir um tema")
+        with form_cols[1]:
+            image_count = st.number_input("Imagens", min_value=1, max_value=5, value=3, step=1)
+        with form_cols[2]:
+            start_stage = st.selectbox("Iniciar por", ["Ideia / Tema", "Tema já definido"])
+        create_clicked = st.form_submit_button("Criar post na fila", type="primary", width="stretch")
+    if create_clicked:
+        page = next(page for page in pages if str(page.get("id")) == selected_page)
+        post = create_post(page, image_count=int(image_count), theme=theme)
+        if start_stage == "Tema já definido" and theme.strip():
+            save_post({**post, "status": "artigo_pendente"})
+        st.success("Post criado na fila local. Execute cada etapa pelos botões do card.")
+        st.rerun()
+    _render_facebook_automation_cards()
+
+
 def render_automation():
     st.title("Automação Youtube")
     st.caption("Agendamento diário da geração por canal. O worker verifica o relógio local do computador e coloca os lotes agendados na fila.")
@@ -9847,7 +10025,7 @@ def main():
         "Facebook Pages": render_facebook_pages,
         "Automação Youtube": render_automation,
         "Automação Tiktok": render_tiktok_automation,
-        "Automação Facebook": lambda: None,
+        "Automação Facebook": render_facebook_automation,
         "Automação Musicas": lambda: None,
         "Automação UGC": lambda: None,
         "Automação Influencer Content": lambda: None,

package/hermes_ui/cuts.py

@@ -121,6 +121,10 @@ def list_video_files(folder: str | Path) -> list[Path]:
 def list_generated_videos(tasks: Iterable[dict[str, Any]]) -> list[Path]:
     paths: dict[str, Path] = {}
     for task in tasks:
+        # Um caminho pode existir enquanto a tarefa ainda está a ser processada;
+        # só artefactos explicitamente prontos devem entrar nesta biblioteca.
+        if "video_ready" in task and not bool(task.get("video_ready")):
+            continue
         artifacts = task.get("artifacts") or {}
         value = artifacts.get("video")
         if isinstance(value, str) and value.strip():

package/hermes_ui/facebook_automation.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import json
+import re
+import textwrap
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping
+
+import requests
+from PIL import Image, ImageDraw, ImageFont
+
+from .creative_generation import CreativeGenerationError, _chat_json
+from .media_generation import generate_image_for_card
+from .storage import STORAGE, read_json, write_json
+
+POSTS_FILE = "facebook_automation_posts.json"
+POSTS_DIR = STORAGE / "facebook_automation"
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _posts() -> list[dict[str, Any]]:
+    value = read_json(POSTS_FILE, [])
+    return [dict(item) for item in value if isinstance(item, Mapping)] if isinstance(value, list) else []
+
+
+def list_posts() -> list[dict[str, Any]]:
+    return sorted(_posts(), key=lambda item: str(item.get("created_at") or ""), reverse=True)
+
+
+def save_post(post: Mapping[str, Any]) -> dict[str, Any]:
+    value = dict(post)
+    value.setdefault("id", f"fbpost_{uuid.uuid4().hex[:12]}")
+    value.setdefault("created_at", _now())
+    entries = _posts()
+    for index, existing in enumerate(entries):
+        if str(existing.get("id")) == str(value["id"]):
+            entries[index] = value
+            break
+    else:
+        entries.append(value)
+    write_json(POSTS_FILE, entries)
+    return value
+
+
+def create_post(page: Mapping[str, Any], *, image_count: int = 3, theme: str = "") -> dict[str, Any]:
+    post_id = f"fbpost_{uuid.uuid4().hex[:12]}"
+    folder = POSTS_DIR / post_id / "images"
+    folder.mkdir(parents=True, exist_ok=True)
+    return save_post({
+        "id": post_id,
+        "page_id": str(page.get("id") or ""),
+        "page_name": str(page.get("name") or "Facebook Page"),
+        "page_url": str(page.get("url") or ""),
+        "theme": theme.strip(),
+        "tone": "Motivacional/Superação",
+        "image_count": max(1, min(5, int(image_count))),
+        "status": "tema_pendente",
+        "created_at": _now(),
+        "folder": str(folder),
+        "images": [],
+    })
+
+
+def generate_theme(settings: dict[str, Any], post: Mapping[str, Any], page: Mapping[str, Any], context: str = "") -> dict[str, Any]:
+    system = (
+        "És um curador de temas para posts virais de storytelling em português para uma Facebook Page. "
+        "Escolhe um tema específico, novo e visualmente forte, com contexto, obstáculo e reviravolta. "
+        "Não inventes factos sobre pessoas reais; quando não houver pessoa indicada, cria uma história genérica plausível. "
+        "Responde apenas JSON válido com as chaves tema e tom."
+    )
+    result = _chat_json(settings, system, json.dumps({
+        "page": {"name": page.get("name"), "description": page.get("description"), "niche": page.get("niche"), "country": page.get("country")},
+        "context": context or post.get("theme") or "",
+        "tone_options": ["Motivacional/Superação", "Curiosidade Histórica", "Biografia de Empresário"],
+    }, ensure_ascii=False))
+    theme = str(result.get("tema") or result.get("theme") or "").strip()
+    tone = str(result.get("tom") or result.get("tone") or "Motivacional/Superação").strip()
+    if not theme:
+        raise CreativeGenerationError("O LLM não devolveu um tema válido para a página Facebook.")
+    return save_post({**post, "theme": theme, "tone": tone, "status": "artigo_pendente"})
+
+
+def generate_article(settings: dict[str, Any], post: Mapping[str, Any], page: Mapping[str, Any]) -> dict[str, Any]:
+    image_count = max(1, min(5, int(post.get("image_count") or 3)))
+    system = (
+        "És um roteirista de posts virais de storytelling para Facebook, em português. "
+        "Gera um artigo completo com aproximadamente 650 a 900 palavras, semelhante ao formato de storytelling do exemplo: "
+        "frases curtas, uma ideia por linha, quebras frequentes, contexto de ano/lugar, factos e números concretos, "
+        "obstáculos, reviravoltas e uma frase final de efeito. Não inventes factos sobre pessoas reais. "
+        f"Depois do artigo, gera exatamente {image_count} cards em ordem cronológica. Cada card deve conter "
+        "index, search_query e overlay_text com no máximo 25 palavras. Responde apenas JSON válido com title, article_text e images."
+    )
+    result = _chat_json(settings, system, json.dumps({
+        "page": {"name": page.get("name"), "description": page.get("description"), "niche": page.get("niche"), "country": page.get("country")},
+        "theme": post.get("theme"), "tone": post.get("tone"), "image_count": image_count,
+        "requirements": {"approximate_words": "650-900", "language": "pt-BR", "format": "one idea per line"},
+    }, ensure_ascii=False))
+    article = str(result.get("article_text") or result.get("article") or "").strip()
+    title = str(result.get("title") or post.get("theme") or "Post Facebook").strip()
+    images = result.get("images") if isinstance(result.get("images"), list) else []
+    normalized_images = []
+    for index, item in enumerate(images[:image_count], start=1):
+        if isinstance(item, Mapping):
+            normalized_images.append({"index": index, "search_query": str(item.get("search_query") or "").strip(), "overlay_text": str(item.get("overlay_text") or "").strip()})
+    if not article or not normalized_images:
+        raise CreativeGenerationError("O LLM devolveu um artigo ou cards de imagem incompletos.")
+    return save_post({**post, "title": title, "article_text": article, "images": normalized_images, "status": "imagens_pendentes"})
+
+
+def _download_image(url: str, destination: Path) -> Path:
+    response = requests.get(url, timeout=45, headers={"User-Agent": "Thunderbolt Facebook Automation/1.0"})
+    response.raise_for_status()
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.write_bytes(response.content)
+    return destination
+
+
+def collect_images(settings: dict[str, Any], post: Mapping[str, Any], *, source: str = "google") -> dict[str, Any]:
+    folder = Path(str(post.get("folder") or POSTS_DIR / str(post.get("id"))) / "images")
+    images = []
+    custom_key = str(settings.get("google_custom_search_api_key") or settings.get("google_images_api_key") or "").strip()
+    custom_cx = str(settings.get("google_custom_search_cx") or settings.get("google_images_cx") or "").strip()
+    for index, item in enumerate(post.get("images") or [], start=1):
+        query = str(item.get("search_query") or post.get("theme") or "").strip()
+        image_record = dict(item)
+        try:
+            destination = folder / f"image-{index}.jpg"
+            if source == "google" and custom_key and custom_cx:
+                payload = requests.get("https://www.googleapis.com/customsearch/v1", params={"key": custom_key, "cx": custom_cx, "q": query, "searchType": "image", "num": 1, "safe": "active"}, timeout=30).json()
+                link = str(((payload.get("items") or [{}])[0]).get("link") or "")
+                if not link:
+                    raise ValueError("A pesquisa Google não devolveu uma imagem.")
+                _download_image(link, destination)
+                image_record["source"] = "google_images"
+            else:
+                cards = settings.get("media_provider_cards") if isinstance(settings.get("media_provider_cards"), list) else []
+                card = next((c for c in cards if isinstance(c, Mapping) and bool(c.get("enabled", True)) and str(c.get("kind") or c.get("type") or "image").lower() in {"image", "images", ""}), None)
+                if not card:
+                    raise ValueError("Configure um provider de imagens IA em Configuração API.")
+                generated = generate_image_for_card(settings, card, query, topic=str(post.get("title") or post.get("theme") or "Facebook"), variant_index=index - 1)
+                destination = Path(generated)
+                image_record["source"] = "ai"
+            image_record["path"] = str(destination)
+            image_record["status"] = "imagem_baixada"
+        except Exception as exc:
+            image_record["status"] = "erro"
+            image_record["error"] = str(exc)[:300]
+        images.append(image_record)
+    return save_post({**post, "images": images, "status": "legendas_pendentes" if any(item.get("path") for item in images) else "imagens_pendentes"})
+
+
+def _font(size: int) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+    candidates = ["/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", "/usr/share/fonts/truetype/liberation2/LiberationSans-Bold.ttf"]
+    for candidate in candidates:
+        if Path(candidate).is_file():
+            return ImageFont.truetype(candidate, size=size)
+    return ImageFont.load_default()
+
+
+def caption_images(post: Mapping[str, Any]) -> dict[str, Any]:
+    updated = []
+    for index, item in enumerate(post.get("images") or [], start=1):
+        record = dict(item)
+        raw_path = str(record.get("path") or "")
+        if raw_path and Path(raw_path).is_file():
+            source = Path(raw_path)
+            output = source.with_name(f"captioned-{source.stem}.jpg")
+            with Image.open(source).convert("RGB") as image:
+                image.thumbnail((1600, 1600))
+                canvas = Image.new("RGB", image.size, "black")
+                canvas.paste(image, ((canvas.width - image.width) // 2, (canvas.height - image.height) // 2))
+                draw = ImageDraw.Draw(canvas)
+                text = str(record.get("overlay_text") or "").strip()
+                font = _font(max(28, min(64, canvas.width // 22)))
+                lines = textwrap.wrap(text, width=max(18, canvas.width // 32))
+                line_height = int(font.size * 1.2) if hasattr(font, "size") else 40
+                box_height = line_height * len(lines) + 48
+                y = canvas.height - box_height - 24
+                draw.rounded_rectangle((24, y, canvas.width - 24, canvas.height - 24), radius=18, fill=(0, 0, 0, 190))
+                for line in lines:
+                    bbox = draw.textbbox((0, 0), line, font=font)
+                    x = (canvas.width - (bbox[2] - bbox[0])) // 2
+                    draw.text((x + 2, y + 16), line, font=font, fill="black")
+                    draw.text((x, y + 14), line, font=font, fill="white")
+                    y += line_height
+                canvas.save(output, "JPEG", quality=92)
+            record["captioned_path"] = str(output)
+            record["status"] = "legendada"
+        updated.append(record)
+    return save_post({**post, "images": updated, "status": "pronto_upload" if any(item.get("captioned_path") for item in updated) else "legendas_pendentes"})
+
+
+def publish_to_facebook(post: Mapping[str, Any], page: Mapping[str, Any]) -> dict[str, Any]:
+    page_id = str(page.get("page_id") or page.get("facebook_page_id") or "").strip()
+    token = str(page.get("access_token") or page.get("facebook_access_token") or "").strip()
+    if not page_id or not token:
+        raise ValueError("Configure o Page ID e o Access Token da Meta nesta página Facebook antes de publicar.")
+    message = f"{post.get('title') or post.get('theme') or ''}\n\n{post.get('article_text') or ''}".strip()
+    published = []
+    for item in post.get("images") or []:
+        path = Path(str(item.get("captioned_path") or item.get("path") or ""))
+        if not path.is_file():
+            continue
+        with path.open("rb") as handle:
+            response = requests.post(f"https://graph.facebook.com/v20.0/{page_id}/photos", data={"caption": message, "published": "false", "access_token": token}, files={"source": (path.name, handle, "image/jpeg")}, timeout=90)
+        payload = response.json() if response.content else {}
+        if response.status_code >= 400 or payload.get("error"):
+            raise ValueError(str(payload.get("error", {}).get("message") or f"Meta Graph API HTTP {response.status_code}"))
+        published.append(payload)
+    if not published:
+        raise ValueError("Não existe nenhuma imagem legendada para publicar.")
+    return save_post({**post, "status": "publicado", "published_at": _now(), "facebook_media_ids": published})
+
+
+__all__ = ["POSTS_DIR", "caption_images", "collect_images", "create_post", "generate_article", "generate_theme", "list_posts", "publish_to_facebook", "save_post"]

package/hermes_ui/python_editor.py

@@ -96,6 +96,8 @@ def list_video_files(folder: str | Path) -> list[Path]:
 def list_generated_videos(tasks: list[dict[str, Any]]) -> list[Path]:
     paths: dict[str, Path] = {}
     for task in tasks:
+        if "video_ready" in task and not bool(task.get("video_ready")):
+            continue
         artifacts = task.get("artifacts") or {}
         value = artifacts.get("video")
         if isinstance(value, str) and value.strip():

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.7.30",
+  "version": "0.7.32",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",