@danhachuel/thunderbolt 0.7.29 → 0.7.31

package/app/main.py

@@ -111,6 +111,7 @@ from hermes_ui.notifications import clear_notifications, list_notifications, mar
 from hermes_ui.influencers import BACKEND_OPTIONS, DOCUMENT_EXTENSIONS, IMAGE_EXTENSIONS, backend_name, backend_status, get_repository, test_backend
 from hermes_ui.logs import list_logs, logs_to_rows
 from hermes_ui.languages import LANGUAGE_CODES, VIDEO_LANGUAGE_CODES, LANGUAGE_FLAG_DATA_URIS, language_code, language_label, ui_language_menu_label, ui_text, video_language_label, video_language_options
+from hermes_ui.countries import COUNTRY_OPTIONS
 from hermes_ui.api_key_tests import test_apify_credentials, test_influencer_database, test_innertube_api_key, test_kaggle_credentials, test_material_source_credentials, test_media_provider_card, test_nano_banana_credentials, test_postiz_credentials, test_telegram_credentials, test_tiktok_credentials, test_upload_post_credentials, test_voice_provider
 from hermes_ui.tutorials import tutorial_body, tutorial_caption, tutorial_title
 from hermes_ui.update_manager import check_version, restart_current_process, update_to_latest
@@ -138,6 +139,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
@@ -1558,6 +1560,9 @@ def render_channel_edit_form(channel: dict, youtube_account_ids: list[str], yout
             edited_name = st.text_input("Nome do canal", value=str(channel.get("name") or ""))
             edited_url = st.text_input("URL", value=str(channel.get("url") or ""))
             edited_handle = st.text_input("Handle", value=str(channel.get("handle") or ""))
+            country_options = [""] + list(COUNTRY_OPTIONS)
+            current_country = str(channel.get("country") or "")
+            edited_country = st.selectbox("País", country_options, index=country_options.index(current_country) if current_country in country_options else 0)
             language_options = VIDEO_LANGUAGE_SELECTION_OPTIONS
             edited_language = st.selectbox("Idioma do roteiro", language_options, index=language_options.index(normalize_video_language(channel.get("language") or "pt")) if normalize_video_language(channel.get("language") or "pt") in language_options else 0, format_func=video_language_label)
             edited_style = st.selectbox("Fonte do vídeo", WIDE_STYLE_OPTIONS, index=WIDE_STYLE_OPTIONS.index(channel_video_source_value(channel.get("style_wide"))) if channel_video_source_value(channel.get("style_wide")) in WIDE_STYLE_OPTIONS else 0)
@@ -1588,7 +1593,7 @@ def render_channel_edit_form(channel: dict, youtube_account_ids: list[str], yout
             update_channel(channel_id, {
                 "name": edited_name.strip(), "url": edited_url.strip(), "handle": edited_handle.strip(), "language": edited_language,
                 "style_wide": channel_video_source_storage(edited_style), "video_aspect_ratio": edited_aspect,
-                "niche": edited_niche.strip(), "reference_channels": [item.strip() for item in re.split(r"[,|]", edited_niche) if item.strip()],
+                "niche": edited_niche.strip(), "reference_channels": [item.strip() for item in re.split(r"[,|]", edited_niche) if item.strip()], "country": edited_country.strip(),
                 "default_blueprint_id": edited_blueprint.strip(), "blueprint_id": edited_blueprint.strip(),
                 "default_voice": edited_voice.strip(), "voice": edited_voice.strip(),
                 "google_account_id": edited_account.strip(), "google_account_email": str(youtube_accounts_by_id.get(edited_account, {}).get("email", "")),
@@ -2381,6 +2386,8 @@ def classify_channel_platform(channel: Any) -> str:
         return "tiktok"
     if value in {"instagram", "ig"}:
         return "instagram"
+    if value in {"facebook", "facebook_page", "facebook_pages", "fb"}:
+        return "facebook"
     def has_tiktok_marker(item: Any) -> bool:
         if isinstance(item, dict):
             return any(has_tiktok_marker(key) or has_tiktok_marker(value) for key, value in item.items())
@@ -2778,6 +2785,103 @@ def _tiktok_channel_url(channel: dict[str, Any]) -> str:
         return source if source.startswith(("http://", "https://")) else ""
 
 
+def render_facebook_pages():
+    st.title("Facebook Pages")
+    st.caption("Cadastre páginas públicas do Facebook por URL. Esta área aceita apenas páginas Facebook e não perfis pessoais.")
+    with st.form("facebook_page_form"):
+        form_cols = st.columns(2)
+        with form_cols[0]:
+            name = st.text_input("Nome da página", key="facebook_page_name")
+            url = st.text_input("URL pública da página", placeholder="https://www.facebook.com/suapagina", key="facebook_page_url")
+            country_options = [""] + list(COUNTRY_OPTIONS)
+            country = st.selectbox("País", country_options, key="facebook_page_country")
+        with form_cols[1]:
+            description = st.text_area("Descrição", key="facebook_page_description")
+            niche = st.text_input("Nicho", key="facebook_page_niche")
+            active = st.toggle("Activo", value=True, key="facebook_page_active")
+        submitted = st.form_submit_button("Guardar página Facebook", type="primary", width="stretch")
+    if submitted:
+        normalized_url = url.strip()
+        if not name.strip():
+            st.error("Informe o nome da página.")
+        elif not normalized_url.startswith(("https://www.facebook.com/", "https://facebook.com/", "http://www.facebook.com/", "http://facebook.com/")):
+            st.error("Informe uma URL pública válida de uma página Facebook.")
+        else:
+            existing = [item for item in read_json("channels.json", []) if isinstance(item, dict)]
+            duplicate = next((item for item in existing if classify_channel_platform(item) == "facebook" and str(item.get("url") or "").strip().casefold() == normalized_url.casefold()), None)
+            if duplicate:
+                st.warning("Esta página Facebook já está cadastrada.")
+            else:
+                page = create_channel(name.strip(), normalized_url, {
+                    "platform": "facebook",
+                    "social_network": "Facebook Pages",
+                    "country": country.strip(),
+                    "description": description.strip(),
+                    "niche": niche.strip(),
+                    "active": bool(active),
+                    "metrics_source": "public_url",
+                })
+                update_channel(page["id"], {"platform": "facebook", "social_network": "Facebook Pages"})
+                st.success(f"Página {page['name']} guardada.")
+                st.rerun()
+
+    pages = [item for item in read_json("channels.json", []) if isinstance(item, dict) and classify_channel_platform(item) == "facebook"]
+    st.divider()
+    st.subheader(f"Facebook Pages cadastradas ({len(pages)})")
+    if not pages:
+        st.info("Nenhuma página Facebook cadastrada.")
+        return
+    for page in pages:
+        page_id = str(page.get("id") or "")
+        with st.container(border=True):
+            header_cols = st.columns([0.7, 2.75, 1.15, 1.1, 1.0, 1.35, 1.35])
+            with header_cols[0]:
+                st.markdown("### FB")
+            with header_cols[1]:
+                page_country = str(page.get("country") or "").strip()
+                st.write(f"**{page.get('name', 'Sem nome')}**{f' · {page_country}' if page_country else ''}")
+                st.caption(page.get("niche") or "SEM NICHO CONFIGURADO")
+                st.caption(page.get("url") or "sem URL")
+            with header_cols[2]:
+                if page.get("url"):
+                    st.link_button("Abrir página", str(page["url"]), type="primary", width="content")
+            with header_cols[3]:
+                st.metric("País", page_country or "—")
+            with header_cols[4]:
+                st.metric("Estado", "Activo" if page.get("active", True) else "Inactivo")
+            with header_cols[5]:
+                st.caption("Facebook Page")
+            with header_cols[6]:
+                active_value = st.toggle("Activo", value=bool(page.get("active", True)), key=f"facebook_active_{page_id}")
+                if active_value != bool(page.get("active", True)):
+                    update_channel(page_id, {"active": active_value})
+                    st.rerun()
+            with st.expander("Detalhes e configuração da página", expanded=False):
+                with st.form(f"facebook_page_edit_{page_id}"):
+                    edited_name = st.text_input("Nome da página", value=str(page.get("name") or ""))
+                    edited_url = st.text_input("URL pública", value=str(page.get("url") or ""))
+                    edit_country_options = [""] + list(COUNTRY_OPTIONS)
+                    current_page_country = str(page.get("country") or "")
+                    edited_country = st.selectbox("País", edit_country_options, index=edit_country_options.index(current_page_country) if current_page_country in edit_country_options else 0)
+                    edited_description = st.text_area("Descrição", value=str(page.get("description") or ""))
+                    edited_niche = st.text_input("Nicho", value=str(page.get("niche") or ""))
+                    save_page = st.form_submit_button("Guardar alterações", type="primary")
+                action_cols = st.columns(2)
+                with action_cols[0]:
+                    if save_page:
+                        if not edited_name.strip() or not edited_url.strip().startswith(("https://www.facebook.com/", "https://facebook.com/", "http://www.facebook.com/", "http://facebook.com/")):
+                            st.error("Informe o nome e uma URL pública válida de uma página Facebook.")
+                        else:
+                            update_channel(page_id, {"name": edited_name.strip(), "url": edited_url.strip(), "country": edited_country.strip(), "description": edited_description.strip(), "niche": edited_niche.strip()})
+                            st.success("Página Facebook actualizada.")
+                            st.rerun()
+                with action_cols[1]:
+                    if st.button("Apagar", key=f"facebook_delete_{page_id}"):
+                        delete_channel(page_id)
+                        st.success("Página Facebook apagada.")
+                        st.rerun()
+
+
 def render_channels():
     st.title("Canais Youtube")
     st.caption("Escolha entre importar dados públicos do YouTube ou preencher o canal manualmente.")
@@ -2849,6 +2953,8 @@ def render_channels():
                 url = st.text_input("URL", value=imported.get("url", source if source.startswith("http") else ""), key="yt_import_url")
                 handle = st.text_input("Handle", value=imported.get("handle", ""), key="yt_import_handle")
                 language = st.selectbox("Idioma do roteiro", VIDEO_LANGUAGE_SELECTION_OPTIONS, index=VIDEO_LANGUAGE_SELECTION_OPTIONS.index(normalize_video_language(imported.get("language") or "pt")) if normalize_video_language(imported.get("language") or "pt") in VIDEO_LANGUAGE_SELECTION_OPTIONS else 0, format_func=video_language_label, key="yt_import_language")
+                import_country_options = [""] + list(COUNTRY_OPTIONS)
+                import_country = st.selectbox("País", import_country_options, index=import_country_options.index(str(imported.get("country") or "")) if str(imported.get("country") or "") in import_country_options else 0, key="yt_import_country")
                 style = st.selectbox("Fonte do vídeo", WIDE_STYLE_OPTIONS, index=0, key="yt_import_style")
                 video_aspect_ratio = st.selectbox("Proporção do vídeo", CHANNEL_ASPECT_RATIO_OPTIONS, key="yt_import_aspect_ratio")
                 blueprint = st.selectbox("Blueprint Padrão", blueprint_ids, index=blueprint_ids.index(imported_blueprint) if imported_blueprint in blueprint_ids else 0, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"), key="yt_import_blueprint")
@@ -2879,7 +2985,7 @@ def render_channels():
                             "description": description.strip(),
                             "niche": niche.strip(),
                             "reference_channels": [item.strip() for item in re.split(r"[,|]", niche) if item.strip()],
-                            "language": language,
+                            "language": language, "country": import_country.strip(),
                             "style_wide": channel_video_source_storage(style), "video_aspect_ratio": video_aspect_ratio, "format": "wide",
                             "blueprint_id": blueprint.strip(),
                             "default_blueprint_id": blueprint.strip(),
@@ -3138,6 +3244,8 @@ def render_channels():
             description = st.text_area("Descrição", key="manual_channel_description")
             niche = st.text_input("Nicho", placeholder="Ex.: História militar, mistérios, ciência", key="manual_channel_niche")
             language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=list(LANGUAGE_CODES).index("pt"), format_func=language_label, key="manual_channel_language")
+            manual_country_options = [""] + list(COUNTRY_OPTIONS)
+            manual_country = st.selectbox("País", manual_country_options, key="manual_channel_country")
             style = st.selectbox("Estilo wide", ["Pexels/Pixabay", "full_ia", "Apenas Música"], index=0, key="manual_channel_style")
             manual_blueprint_items = blueprint_catalog()
             manual_blueprint_ids = [item[0] for item in manual_blueprint_items]
@@ -3166,7 +3274,7 @@ def render_channels():
                         "description": description.strip(),
                         "niche": niche.strip(),
                         "reference_channels": [item.strip() for item in re.split(r"[,|]", niche) if item.strip()],
-                        "language": language,
+                        "language": language, "country": manual_country.strip(),
                         "style_wide": {"Pexels/Pixabay": "pexels", "full_ia": "full_ia", "Apenas Música": "music"}.get(style, style),
                         "blueprint_id": blueprint.strip(),
                         "default_blueprint_id": blueprint.strip(),
@@ -3228,7 +3336,8 @@ def render_channels():
                 else:
                     st.markdown("### YT")
             with header_cols[1]:
-                st.write(f"**{channel.get('name', 'Sem nome')}**")
+                country_label = str(channel.get("country") or "").strip()
+                st.write(f"**{channel.get('name', 'Sem nome')}**{f' · {country_label}' if country_label else ''}")
                 st.caption(channel_niche_label(channel))
                 st.caption(f"{channel.get('handle') or channel.get('url') or 'sem URL'} · {channel.get('metrics_source', 'manual')}")
             with header_cols[2]:
@@ -6175,6 +6284,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.")
@@ -9552,12 +9785,13 @@ def main():
     channel_profile_items = [
         ("Canais YouTube", ":material/ondemand_video:", "Canais YouTube"),
         ("Canais Tiktok", ":material/music_video:", "Canais Tiktok"),
+        ("Contas Instagram", ":material/share:", "Contas Instagram"),
+        ("Facebook Pages", ":material/public:", "Facebook Pages"),
         ("Blueprints Youtube", ":material/library_books:", "Blueprints Youtube"),
         ("Thumbnail Blueprints", ":material/image:", "Thumbnail Blueprints"),
         ("Brandings Youtube", ":material/brush:", "Brandings Youtube"),
         ("Contas TikTok", ":material/account_circle:", "Contas TikTok"),
         ("Prompt Masters", ":material/auto_awesome:", "Prompt Masters"),
-        ("Facebook Pages", ":material/public:", "Facebook Pages"),
     ]
     music_items = [
         ("Criação de Músicas", ":material/music_note:", "Criação de Músicas"),
@@ -9570,7 +9804,6 @@ def main():
         ("Geração de Conteúdo IA", ":material/auto_awesome:", "Geração de Conteúdo IA"),
         ("Motion Control", ":material/motion_photos_on:", "Motion Control"),
         ("UGC Products", ":material/shopping_bag:", "UGC Products"),
-        ("Contas Instagram", ":material/share:", "Contas Instagram"),
     ]
     growth_items = [
         ("Analista Growth Youtube", ":material/analytics:", "Analista Growth Youtube"),
@@ -9601,6 +9834,11 @@ def main():
     automation_items = [
         ("Automação Youtube", ":material/schedule:", "Automação Youtube"),
         ("Automação Tiktok", ":material/schedule:", "Automação Tiktok"),
+        ("Automação Facebook", ":material/schedule:", "Automação Facebook"),
+        ("Automação Musicas", ":material/schedule:", "Automação Musicas"),
+        ("Automação UGC", ":material/schedule:", "Automação UGC"),
+        ("Automação Influencer Content", ":material/schedule:", "Automação Influencer Content"),
+        ("Automação Bilibili", ":material/schedule:", "Automação Bilibili"),
     ]
     edition_items = [
         ("Limpador de Metadados", ":material/edit_note:", "Limpador de Metadados"),
@@ -9634,12 +9872,12 @@ def main():
         "Configurações": settings_items,
     }
     nav_paths = {
-        "Início": "/inicio", "Automação": "/automacao", "Automação Youtube": "/automacao/youtube", "Automação Tiktok": "/automacao/tiktok",
+        "Início": "/inicio", "Automação": "/automacao", "Automação Youtube": "/automacao/youtube", "Automação Tiktok": "/automacao/tiktok", "Automação Facebook": "/automacao/facebook", "Automação Musicas": "/automacao/musicas", "Automação UGC": "/automacao/ugc", "Automação Influencer Content": "/automacao/influencer-content", "Automação Bilibili": "/automacao/bilibili",
         "Niche Finder": "/niche-finder", "Niche Finder Kaggle": "/niche-finder/kaggle", "Niche Finder Apify": "/niche-finder/apify",
         "Pipeline Vídeos": "/pipeline-videos", "Criação de Vídeos": "/pipeline-videos/criacao", "Criação de Shorts": "/pipeline-videos/shorts", "Backlog Vídeos": "/pipeline-videos/backlog", "Roteiros": "/pipeline-videos/roteiros", "Thumbnails": "/pipeline-videos/thumbnails", "Upload": "/pipeline-videos/upload", "Update Youtube Vídeos": "/pipeline-videos/update-youtube",
         "Pipeline Música": "/pipeline-musica", "Criação de Músicas": "/pipeline-musica/criacao", "Music Backlog": "/pipeline-musica/backlog", "Vozes Personalizadas": "/pipeline-musica/vozes-personalizadas", "Upload Música": "/pipeline-musica/upload",
-        "Canais/Perfis (Vídeos)": "/canais-perfis-videos", "Canais YouTube": "/canais-perfis-videos/canais-youtube", "Canais Tiktok": "/canais-perfis-videos/canais-tiktok", "Blueprints Youtube": "/canais-perfis-videos/blueprints-youtube", "Thumbnail Blueprints": "/canais-perfis-videos/thumbnail-blueprints", "Brandings Youtube": "/canais-perfis-videos/brandings-youtube", "Contas TikTok": "/canais-perfis-videos/contas-tiktok", "Prompt Masters": "/canais-perfis-videos/prompt-masters", "Facebook Pages": "/canais-perfis-videos/facebook-pages",
-        "AI Influencers": "/ai-influencers", "Personagens": "/ai-influencers/personagens", "Geração de Conteúdo IA": "/ai-influencers/geracao-conteudo", "Motion Control": "/ai-influencers/motion-control", "UGC Products": "/ai-influencers/ugc-products", "Contas Instagram": "/ai-influencers/redes-sociais",
+        "Canais/Perfis (Vídeos)": "/canais-perfis-videos", "Canais YouTube": "/canais-perfis-videos/canais-youtube", "Canais Tiktok": "/canais-perfis-videos/canais-tiktok", "Contas Instagram": "/canais-perfis-videos/contas-instagram", "Facebook Pages": "/canais-perfis-videos/facebook-pages", "Blueprints Youtube": "/canais-perfis-videos/blueprints-youtube", "Thumbnail Blueprints": "/canais-perfis-videos/thumbnail-blueprints", "Brandings Youtube": "/canais-perfis-videos/brandings-youtube", "Contas TikTok": "/canais-perfis-videos/contas-tiktok", "Prompt Masters": "/canais-perfis-videos/prompt-masters",
+        "AI Influencers": "/ai-influencers", "Personagens": "/ai-influencers/personagens", "Geração de Conteúdo IA": "/ai-influencers/geracao-conteudo", "Motion Control": "/ai-influencers/motion-control", "UGC Products": "/ai-influencers/ugc-products",
         "Edição": "/edicao", "Limpador de Metadados": "/edicao/limpador-metadados", "Cortes": "/edicao/cortes", "Editor Python": "/edicao/editor-python", "Download Mídia": "/edicao/download-midia",
         "Growth": "/growth", "Analista Growth Youtube": "/growth/youtube", "Analista Growth Tiktok": "/growth/tiktok", "Analista Growth Instagram": "/growth/instagram", "Analista Facebook Pages": "/growth/facebook-pages", "Analista Bilibili": "/growth/bilibili",
         "Documentação": "/documentacao", "Tutorial Meta": "/documentacao/meta", "Tutorial Supabase": "/documentacao/supabase", "Tutorial Kaggle": "/documentacao/kaggle", "Tutorial Apify": "/documentacao/apify", "Tutorial YouTube Video-Upload Frontend": "/documentacao/youtube-video-upload-frontend", "Tutorial OAuth do Google": "/documentacao/oauth-google", "Tutorial YouTube Data API Key (Public Data)": "/documentacao/youtube-data-api-key",
@@ -9731,9 +9969,14 @@ def main():
         "Canais YouTube": render_channels,
         "Canais Tiktok": render_tiktok_channels,
         "Contas TikTok": render_tiktok_accounts,
-        "Facebook Pages": lambda: render_edit_placeholder("Facebook Pages", ""),
+        "Facebook Pages": render_facebook_pages,
         "Automação Youtube": render_automation,
         "Automação Tiktok": render_tiktok_automation,
+        "Automação Facebook": render_facebook_automation,
+        "Automação Musicas": lambda: None,
+        "Automação UGC": lambda: None,
+        "Automação Influencer Content": lambda: None,
+        "Automação Bilibili": lambda: None,
         "Niche Finder Kaggle": render_niche_finder,
         "Tutorial Kaggle": lambda: render_niche_tutorial("kaggle"),
         "Niche Finder Apify": render_niche_finder_apify,

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/package.json

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