@danhachuel/thunderbolt 0.6.13 → 0.6.15

package/app/main.py

@@ -70,6 +70,7 @@ from app.modules.token_optimizer.compressor import check_installation
 from app.modules.token_optimizer.config import DEFAULTS as TOKEN_OPTIMIZER_DEFAULTS
 from app.modules.token_optimizer.metrics import get_stats as get_token_optimizer_stats
 from app.influencers_ui import render_ai_influencer_characters, render_ai_influencer_content, render_ai_influencers_api_status, render_motion_control, render_ugc_products
+from app.social_networks_ui import render_meta_api_cards, render_social_networks
 from hermes_ui.blueprints import create_blueprint_from_link, list_branding_files, save_generated_blueprint
 from hermes_ui.thumbnail_blueprints import generate_thumbnail_blueprint, list_thumbnail_blueprint_documents, resolve_thumbnail_blueprint, save_thumbnail_blueprint, save_thumbnail_blueprint_pair, thumbnail_blueprint_catalog, thumbnail_blueprint_for_blueprint, thumbnail_blueprint_for_channel
 from hermes_ui.metadata_cleaner import build_description, clean_video_metadata, list_edit_records, metadata_manifest, normalize_tags, save_edit_record, store_external_video
@@ -112,6 +113,7 @@ from hermes_ui.growth_youtube import list_analyses, run_audit
 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.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
@@ -8034,6 +8036,10 @@ def render_settings():
                 st.rerun()
         with st.expander("API Tiktok", expanded=False):
             render_tiktok_api_cards(settings)
+        with st.expander("API Instagram", expanded=False):
+            render_meta_api_cards(settings, "instagram")
+        with st.expander("API Facebook Pages", expanded=False):
+            render_meta_api_cards(settings, "facebook_pages")
         with st.expander("API Bilibili", expanded=False):
             bilibili_cards = settings.get("bilibili_api_cards") if isinstance(settings.get("bilibili_api_cards"), list) else []
             bilibili_ready = any(bool(card.get("active", True) and card.get("sessdata") and card.get("bili_jct") and card.get("buvid3")) for card in bilibili_cards if isinstance(card, dict))
@@ -9071,12 +9077,12 @@ def main():
         "Geração de Conteúdo IA": lambda: render_ai_influencer_content(read_json("settings.json", {})),
         "Motion Control": lambda: render_motion_control(read_json("settings.json", {})),
         "UGC Products": lambda: render_ugc_products(read_json("settings.json", {})),
-        "Redes Sociais": lambda: render_edit_placeholder("Redes Sociais", "Área reservada para a futura funcionalidade de redes sociais."),
+        "Redes Sociais": lambda: render_social_networks(read_json("settings.json", {})),
         "Analista Growth Youtube": render_growth_youtube,
         "Analista Growth Tiktok": render_growth_tiktok,
         "Analista Growth Instagram": render_growth_instagram,
         "Analista Facebook Pages": render_growth_facebook_pages,
-        "Analista Bilibili": lambda: render_edit_placeholder("Analista Bilibili", ""),
+        "Analista Bilibili": render_growth_bilibili,
         "Documentação": lambda: render_edit_placeholder("Documentação", "Seleccione um tutorial no menu expansível."),
         "Tutorial Meta": render_models_ai_tutorial,
         "Tutorial Supabase": render_supabase_tutorial,

package/app/social_networks_ui.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import uuid
+from typing import Any, Callable, Mapping
+
+import streamlit as st
+
+from hermes_ui.domain import create_channel, update_channel
+from hermes_ui.influencers import InfluencerBackendError, STANDALONE_CONTENT_INFLUENCER_ID, get_repository
+from hermes_ui.storage import read_json, write_json
+from integrations.instagram_public import fetch_public_instagram_profile
+from integrations.meta_social import test_facebook_pages_api_card, test_instagram_api_card
+
+
+def _clean(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _metric(value: Any) -> str:
+    if value in (None, ""):
+        return "—"
+    try:
+        return f"{int(value):,}".replace(",", ".")
+    except (TypeError, ValueError):
+        return _clean(value) or "—"
+
+
+def _api_card_defaults(kind: str) -> tuple[str, list[str], Callable[[Mapping[str, Any]], dict[str, Any]]]:
+    if kind == "instagram":
+        return "instagram_api_cards", ["id", "label", "account_id", "access_token"], test_instagram_api_card
+    return "facebook_pages_api_cards", ["id", "label", "page_id", "access_token"], test_facebook_pages_api_card
+
+
+def _normalise_api_cards(settings: dict[str, Any], kind: str) -> list[dict[str, str]]:
+    key, fields, _ = _api_card_defaults(kind)
+    raw = settings.get(key)
+    cards: list[dict[str, str]] = []
+    if isinstance(raw, list):
+        for index, item in enumerate(raw):
+            if not isinstance(item, dict):
+                continue
+            card = {field: _clean(item.get(field)) for field in fields}
+            card["id"] = card["id"] or f"{kind}-api-{index + 1}"
+            cards.append(card)
+    if not cards:
+        legacy_key = "instagram_api_key" if kind == "instagram" else "facebook_pages_api_key"
+        legacy_id = "instagram_account_id" if kind == "instagram" else "facebook_page_id"
+        token = _clean(settings.get(legacy_key))
+        identifier = _clean(settings.get(legacy_id))
+        if token or identifier:
+            cards = [{"id": f"{kind}-api-1", "label": "Conta 1", "account_id" if kind == "instagram" else "page_id": identifier, "access_token": token}]
+    if cards and not isinstance(raw, list):
+        settings[key] = cards
+        write_json("settings.json", settings)
+    return cards
+
+
+def _persist_api_cards(settings: dict[str, Any], kind: str, cards: list[dict[str, Any]]) -> None:
+    key, fields, _ = _api_card_defaults(kind)
+    clean_cards: list[dict[str, str]] = []
+    for index, item in enumerate(cards):
+        card = {field: _clean(item.get(field)) for field in fields}
+        card["id"] = card["id"] or f"{kind}-api-{index + 1}"
+        clean_cards.append(card)
+    settings[key] = clean_cards
+    if kind == "instagram":
+        first = next((item for item in clean_cards if item.get("account_id") and item.get("access_token")), clean_cards[0] if clean_cards else {})
+        settings["instagram_account_id"] = first.get("account_id", "")
+        settings["instagram_api_key"] = first.get("access_token", "")
+    else:
+        first = next((item for item in clean_cards if item.get("page_id") and item.get("access_token")), clean_cards[0] if clean_cards else {})
+        settings["facebook_page_id"] = first.get("page_id", "")
+        settings["facebook_pages_api_key"] = first.get("access_token", "")
+    write_json("settings.json", settings)
+
+
+def _api_card_status(card: Mapping[str, Any], kind: str) -> tuple[str, str]:
+    identifier = _clean(card.get("account_id" if kind == "instagram" else "page_id"))
+    token = _clean(card.get("access_token"))
+    if not token:
+        return "missing", "Missing key"
+    if not identifier:
+        return "missing", "Missing configuration"
+    return "ready", "Configured"
+
+
+def render_meta_api_cards(settings: dict[str, Any], kind: str) -> None:
+    is_instagram = kind == "instagram"
+    title = "API Instagram" if is_instagram else "API Facebook Pages"
+    entity_label = "Instagram Account ID" if is_instagram else "Facebook Page ID"
+    key, _, tester = _api_card_defaults(kind)
+    cards = _normalise_api_cards(settings, kind)
+    if not cards:
+        st.info(f"Ainda não existe nenhuma conta {title.replace('API ', '')} configurada. Use o botão abaixo para criar o primeiro card.")
+    for index, card in enumerate(cards):
+        card_id = _clean(card.get("id"))
+        status_kind, status_label = _api_card_status(card, kind)
+        with st.container(border=True):
+            header_cols = st.columns([3.2, 1.2])
+            with header_cols[0]:
+                st.subheader(f"{title} {index + 1}")
+                st.caption("Cada card representa uma conta independente; o token é guardado apenas no storage local.")
+            with header_cols[1]:
+                st.markdown(
+                    f'<span class="tb-api-status tb-api-status--{status_kind}">{"✓" if status_kind == "ready" else "!"} {status_label}</span>',
+                    unsafe_allow_html=True,
+                )
+            with st.form(f"{kind}_api_card_form_{card_id}"):
+                label = st.text_input("Nome da conta", value=_clean(card.get("label")) or f"Conta {index + 1}", key=f"{kind}_api_{card_id}_label")
+                identifier = st.text_input(entity_label, value=_clean(card.get("account_id" if is_instagram else "page_id")), key=f"{kind}_api_{card_id}_identifier")
+                token = st.text_input("Access Token", value=_clean(card.get("access_token")), type="password", key=f"{kind}_api_{card_id}_token")
+                action_cols = st.columns(3)
+                with action_cols[0]:
+                    test_clicked = st.form_submit_button("Teste chamada API", use_container_width=True)
+                with action_cols[1]:
+                    save_clicked = st.form_submit_button("Guardar Card", type="primary", use_container_width=True)
+                with action_cols[2]:
+                    delete_clicked = st.form_submit_button("Apagar Card", use_container_width=True)
+            edited = {
+                "id": card_id,
+                "label": label.strip(),
+                "access_token": token.strip(),
+                ("account_id" if is_instagram else "page_id"): identifier.strip(),
+            }
+            if test_clicked:
+                cards[index] = edited
+                _persist_api_cards(settings, kind, cards)
+                result = tester(edited)
+                if result.get("status") == "success":
+                    st.success(result.get("message") or "Chamada API concluída.")
+                elif result.get("status") == "missing":
+                    st.warning(result.get("message") or "Missing configuration")
+                else:
+                    st.error(result.get("message") or "A chamada API falhou.")
+            elif save_clicked:
+                cards[index] = edited
+                _persist_api_cards(settings, kind, cards)
+                st.success(f"{title} guardada.")
+                st.rerun()
+            elif delete_clicked:
+                cards = [item for item in cards if _clean(item.get("id")) != card_id]
+                _persist_api_cards(settings, kind, cards)
+                st.success(f"{title} apagada.")
+                st.rerun()
+    if st.button("Adicionar nova API", type="primary", use_container_width=True, key=f"add_{kind}_api_card"):
+        identifier_key = "account_id" if is_instagram else "page_id"
+        cards.append({"id": f"{kind}-api-{uuid.uuid4().hex[:10]}", "label": f"Conta {len(cards) + 1}", identifier_key: "", "access_token": ""})
+        _persist_api_cards(settings, kind, cards)
+        st.success(f"Novo card {title} criado.")
+        st.rerun()
+
+
+def _instagram_profiles() -> list[dict[str, Any]]:
+    records = read_json("channels.json", [])
+    return [item for item in records if isinstance(item, dict) and _clean(item.get("platform")).lower() == "instagram"]
+
+
+def _characters(settings: Mapping[str, Any]) -> tuple[list[dict[str, Any]], Any | None]:
+    try:
+        repository = get_repository(settings)
+        items = [item for item in repository.list_influencers() if _clean(item.get("id")) != STANDALONE_CONTENT_INFLUENCER_ID]
+        return items, repository
+    except (InfluencerBackendError, Exception):
+        return [], None
+
+
+def _save_public_profile(data: Mapping[str, Any], *, country: str, language: str, character_id: str = "") -> dict[str, Any]:
+    name = _clean(data.get("name")) or _clean(data.get("username")) or "Conta Instagram"
+    url = _clean(data.get("url"))
+    metadata = {
+        **dict(data),
+        "platform": "instagram",
+        "social_network": "Instagram",
+        "name": name,
+        "url": url,
+        "handle": _clean(data.get("handle")),
+        "country": country.strip(),
+        "language": language.strip(),
+        "post_count": data.get("post_count"),
+        "subscriber_count": data.get("subscriber_count"),
+        "following_count": data.get("following_count"),
+        "character_id": character_id.strip(),
+        "active": True,
+        "metrics_source": "instagram_public_page",
+    }
+    return create_channel(name, url, metadata)
+
+
+def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, Any]], settings: Mapping[str, Any]) -> None:
+    profile_id = _clean(profile.get("id"))
+    edit_key = f"edit_instagram_profile_{profile_id}"
+    with st.container(border=True):
+        header_cols = st.columns([0.7, 3.1, 1.25, 1.25, 1.25, 1.65])
+        with header_cols[0]:
+            if _clean(profile.get("avatar_url")):
+                st.image(profile["avatar_url"], width=64)
+            else:
+                st.markdown("### IG")
+        with header_cols[1]:
+            st.write(f"**{_clean(profile.get('name')) or 'Sem nome'}**")
+            st.caption(f"{_clean(profile.get('handle')) or _clean(profile.get('url')) or 'sem handler'}")
+            st.caption(f"{_clean(profile.get('country')) or 'País não definido'} · {_clean(profile.get('language')) or 'Idioma não definido'}")
+        with header_cols[2]:
+            st.metric("posts", _metric(profile.get("post_count")))
+        with header_cols[3]:
+            st.metric("Seguidores", _metric(profile.get("subscriber_count")))
+        with header_cols[4]:
+            st.metric("seguindo", _metric(profile.get("following_count")))
+        with header_cols[5]:
+            refresh_col, edit_col = st.columns(2)
+            with refresh_col:
+                if st.button("↻", help="Actualizar posts, seguidores e seguindo", key=f"refresh_instagram_{profile_id}"):
+                    result = fetch_public_instagram_profile(_clean(profile.get("url")) or _clean(profile.get("handle")))
+                    if result.ok:
+                        update_channel(profile_id, {**result.data, "platform": "instagram", "country": profile.get("country", ""), "language": profile.get("language", ""), "character_id": profile.get("character_id", "")})
+                        st.success("Métricas Instagram actualizadas.")
+                        st.rerun()
+                    st.warning(result.message)
+            with edit_col:
+                if st.button("Editar", key=f"edit_instagram_button_{profile_id}", use_container_width=True):
+                    st.session_state[edit_key] = True
+                    st.rerun()
+            url = _clean(profile.get("url"))
+            if url:
+                st.link_button("Abrir Instagram", url, use_container_width=True)
+
+        if st.session_state.get(edit_key):
+            with st.form(f"edit_instagram_profile_form_{profile_id}"):
+                edit_cols = st.columns(2)
+                with edit_cols[0]:
+                    name = st.text_input("Nome", value=_clean(profile.get("name")), key=f"instagram_edit_name_{profile_id}")
+                    handle = st.text_input("handler", value=_clean(profile.get("handle")), key=f"instagram_edit_handle_{profile_id}")
+                    country = st.text_input("País", value=_clean(profile.get("country")), key=f"instagram_edit_country_{profile_id}")
+                    language = st.text_input("Idioma", value=_clean(profile.get("language")), key=f"instagram_edit_language_{profile_id}")
+                with edit_cols[1]:
+                    posts = st.number_input("posts", min_value=0, value=int(profile.get("post_count") or 0), key=f"instagram_edit_posts_{profile_id}")
+                    followers = st.number_input("Seguidores", min_value=0, value=int(profile.get("subscriber_count") or 0), key=f"instagram_edit_followers_{profile_id}")
+                    following = st.number_input("seguindo", min_value=0, value=int(profile.get("following_count") or 0), key=f"instagram_edit_following_{profile_id}")
+                save_edit = st.form_submit_button("Guardar alterações", type="primary", use_container_width=True)
+            if save_edit:
+                update_channel(profile_id, {"name": name.strip(), "handle": handle.strip(), "country": country.strip(), "language": language.strip(), "post_count": int(posts), "subscriber_count": int(followers), "following_count": int(following)})
+                st.session_state.pop(edit_key, None)
+                st.success("Conta Instagram actualizada.")
+                st.rerun()
+        else:
+            block_cols = st.columns(4, gap="small")
+            with block_cols[0]:
+                st.markdown(f"**Nome**\n\n{_clean(profile.get('name')) or '—'}")
+            with block_cols[1]:
+                st.markdown(f"**handler**\n\n{_clean(profile.get('handle')) or '—'}")
+            with block_cols[2]:
+                st.markdown(f"**País**\n\n{_clean(profile.get('country')) or '—'}")
+            with block_cols[3]:
+                st.markdown(f"**Idioma**\n\n{_clean(profile.get('language')) or '—'}")
+
+        character_options = [""] + [_clean(item.get("id")) for item in characters if _clean(item.get("id"))]
+        character_labels = {"": "Sem personagem associado"} | {_clean(item.get("id")): _clean(item.get("name")) or _clean(item.get("id")) for item in characters}
+        current_character = _clean(profile.get("character_id"))
+        selected_character = st.selectbox("Personagem", character_options, index=character_options.index(current_character) if current_character in character_options else 0, format_func=lambda value: character_labels.get(value, value), key=f"instagram_character_{profile_id}")
+        if st.button("Atrelar Personagem", key=f"attach_instagram_character_{profile_id}", use_container_width=True):
+            update_channel(profile_id, {"character_id": selected_character})
+            st.success("Personagem associado à conta Instagram.")
+            st.rerun()
+
+
+def render_social_networks(settings: dict[str, Any]) -> None:
+    st.title("Redes Sociais")
+    st.caption("Cadastre contas Instagram através de pesquisa pública e associe cada conta a um Personagem de AI Influencers.")
+    search_tab, accounts_tab = st.tabs(["Pesquisa pública Instagram", "Contas Instagram"])
+    with search_tab:
+        st.caption("A pesquisa consulta apenas a página pública do Instagram. API Key não é necessária para cadastrar o perfil.")
+        source = st.text_input("URL pública ou @handler Instagram", placeholder="https://www.instagram.com/conta/ ou @conta", key="social_instagram_source")
+        search_cols = st.columns(2)
+        with search_cols[0]:
+            search_clicked = st.button("Pesquisar conta pública", type="primary", use_container_width=True, key="social_instagram_search")
+        with search_cols[1]:
+            if st.button("Limpar pesquisa", use_container_width=True, key="social_instagram_clear"):
+                for key in ("social_instagram_result", "social_instagram_ok", "social_instagram_message"):
+                    st.session_state.pop(key, None)
+                st.rerun()
+        if search_clicked:
+            result = fetch_public_instagram_profile(source)
+            st.session_state["social_instagram_result"] = result.data if isinstance(result.data, dict) else {}
+            st.session_state["social_instagram_ok"] = result.ok
+            st.session_state["social_instagram_message"] = result.message
+        if st.session_state.get("social_instagram_message"):
+            (st.success if st.session_state.get("social_instagram_ok") else st.warning)(st.session_state["social_instagram_message"])
+        data = st.session_state.get("social_instagram_result", {}) if st.session_state.get("social_instagram_ok") else {}
+        if data:
+            characters, _ = _characters(settings)
+            with st.container(border=True):
+                st.subheader("Conta Instagram encontrada")
+                preview_cols = st.columns([0.8, 2.2, 1.2, 1.2, 1.2])
+                with preview_cols[0]:
+                    if _clean(data.get("avatar_url")):
+                        st.image(data["avatar_url"], width=72)
+                with preview_cols[1]:
+                    st.write(f"**{_clean(data.get('name')) or _clean(data.get('username'))}**")
+                    st.caption(_clean(data.get("handle")))
+                with preview_cols[2]:
+                    st.metric("posts", _metric(data.get("post_count")))
+                with preview_cols[3]:
+                    st.metric("Seguidores", _metric(data.get("subscriber_count")))
+                with preview_cols[4]:
+                    st.metric("seguindo", _metric(data.get("following_count")))
+                with st.form("social_instagram_save_public_profile"):
+                    form_cols = st.columns(2)
+                    with form_cols[0]:
+                        name = st.text_input("Nome", value=_clean(data.get("name")), key="social_instagram_result_name")
+                        country = st.text_input("País", value=_clean(data.get("country")), key="social_instagram_result_country")
+                        language = st.text_input("Idioma", value=_clean(data.get("language")), key="social_instagram_result_language")
+                    with form_cols[1]:
+                        posts = st.number_input("posts", min_value=0, value=int(data.get("post_count") or 0), key="social_instagram_result_posts")
+                        followers = st.number_input("Seguidores", min_value=0, value=int(data.get("subscriber_count") or 0), key="social_instagram_result_followers")
+                        following = st.number_input("seguindo", min_value=0, value=int(data.get("following_count") or 0), key="social_instagram_result_following")
+                    character_options = [""] + [_clean(item.get("id")) for item in characters if _clean(item.get("id"))]
+                    character_labels = {"": "Sem personagem associado"} | {_clean(item.get("id")): _clean(item.get("name")) or _clean(item.get("id")) for item in characters}
+                    selected_character = st.selectbox("Personagem", character_options, format_func=lambda value: character_labels.get(value, value), key="social_instagram_result_character")
+                    save_profile = st.form_submit_button("Cadastrar conta Instagram", type="primary", use_container_width=True)
+                if save_profile:
+                    profile_data = dict(data)
+                    profile_data.update({"name": name, "post_count": int(posts), "subscriber_count": int(followers), "following_count": int(following)})
+                    _save_public_profile(profile_data, country=country, language=language, character_id=selected_character)
+                    st.success("Conta Instagram cadastrada em Redes Sociais.")
+                    for key in ("social_instagram_result", "social_instagram_ok", "social_instagram_message"):
+                        st.session_state.pop(key, None)
+                    st.rerun()
+    with accounts_tab:
+        profiles = _instagram_profiles()
+        if not profiles:
+            st.info("Ainda não existem contas Instagram cadastradas. Use a pesquisa pública para adicionar a primeira conta.")
+        characters, _ = _characters(settings)
+        for profile in profiles:
+            _render_instagram_card(profile, characters, settings)

package/hermes_ui/growth_bilibili.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from html import escape
+from typing import Any
+
+import streamlit as st
+
+
+BILIBILI_CARDS: tuple[tuple[str, int, bool, tuple[tuple[str, str, str, str], ...]], ...] = (
+    (
+        "Validação de Procura",
+        70,
+        True,
+        (
+            ("Tecto dos concorrentes", "A medir", "> 500k views", "A verificar"),
+            ("Volume de pesquisa", "A medir", "Procura crescente", "A verificar"),
+            ("Tráfego de pesquisa", "A medir", "15–30%", "A verificar"),
+            ("Diagnóstico", "Validar antes de produzir", "Nicho validado", "A verificar"),
+        ),
+    ),
+    (
+        "Thumbnail",
+        70,
+        True,
+        (
+            ("CTR", "A medir", "> 6%", "A verificar"),
+            ("Contraste", "Alto contraste", "Fundo escuro + cor viva", "Meta"),
+            ("Texto", "3–5 palavras", "Legível no telemóvel", "Meta"),
+            ("Elementos Bilibili", "ACG quando adequado", "Visual expressivo", "Meta"),
+        ),
+    ),
+    (
+        "Título e Intenção",
+        70,
+        True,
+        (
+            ("Estrutura", "Curiosity · Clarity · Context", "Promessa clara", "Meta"),
+            ("Keyword principal", "No início", "Pesquisa Bilibili", "Meta"),
+            ("CTR + retenção", "A medir", "CTR alto sem queda brusca", "A verificar"),
+            ("Formato", "Why / How to / VS", "Intenção explícita", "Meta"),
+        ),
+    ),
+    (
+        "Hook e Retenção",
+        70,
+        False,
+        (
+            ("Retenção aos 15s", "A medir", "> 50%", "A verificar"),
+            ("Retenção aos 30s", "A medir", "> 70%", "A verificar"),
+            ("Método", "Clímax primeiro", "Resultado antes da introdução", "Meta"),
+            ("Abertura", "Sem introdução longa", "Primeiro frame forte", "Meta"),
+        ),
+    ),
+    (
+        "Ritmo e Edição",
+        70,
+        False,
+        (
+            ("Pattern interrupt", "A cada 5–8s", "Sem imagens estáticas > 4s", "Meta"),
+            ("Quedas intermédias", "A medir", "Quedas pequenas", "A verificar"),
+            ("Texto danmaku", "Usar com intenção", "Comentários sobrepostos", "Meta"),
+            ("Cadência visual", "A medir", "Plateau de retenção", "A verificar"),
+        ),
+    ),
+    (
+        "Engagement 三连",
+        70,
+        False,
+        (
+            ("三连率", "A medir", "> 4%", "A verificar"),
+            ("Likes + Coins + Favorites", "Três cliques", "Sinal de qualidade", "Meta"),
+            ("Danmaku", "A medir", "> 5/min", "A verificar"),
+            ("Comentários", "A medir", "> 1/100 views", "A verificar"),
+        ),
+    ),
+    (
+        "Tráfego e Algoritmo",
+        70,
+        False,
+        (
+            ("Recommendation 推荐", "A medir", "40–60%", "A verificar"),
+            ("Search 搜索", "A medir", "15–30%", "A verificar"),
+            ("Followers 粉丝", "A medir", "10–30%", "A verificar"),
+            ("External 外部", "A medir", "< 10%", "A verificar"),
+        ),
+    ),
+    (
+        "Conversão e Saúde",
+        70,
+        False,
+        (
+            ("Conversão em followers", "A medir", "> 1%", "A verificar"),
+            ("Fan Playback", "A medir", "40–60%", "A verificar"),
+            ("Novos viewers", "A medir", "> 20%", "A verificar"),
+            ("Abandono mensal", "A medir", "< 5%", "A verificar"),
+        ),
+    ),
+)
+
+
+def _card_html(card: tuple[str, int, bool, tuple[tuple[str, str, str, str], ...]]) -> str:
+    title, score, featured, rows = card
+    row_html = "".join(
+        f'<tr><td>{escape(label)}</td><td><b>{escape(value)}</b></td><td>{escape(target)}</td>'
+        f'<td><span style="color:#94a3b8;font-weight:700;">● {escape(status)}</span></td></tr>'
+        for label, value, target, status in rows
+    )
+    height = "350px" if featured else "280px"
+    title_size = "19px" if featured else "16px"
+    score_size = "38px" if featured else "30px"
+    return (
+        f'<div style="min-height:{height};border:1px solid #2b3b52;border-radius:14px;padding:16px;'
+        f'background:linear-gradient(145deg,#111c2b,#0b121c);box-shadow:0 8px 22px rgba(0,0,0,.16);">'
+        f'<div style="font-size:11px;font-weight:800;letter-spacing:.08em;color:#7dd3fc;text-transform:uppercase;">BILIBILI GROWTH</div>'
+        f'<div style="font-size:{title_size};font-weight:750;color:#f8fafc;margin-top:8px;">{escape(title)}</div>'
+        f'<div style="display:flex;align-items:baseline;gap:5px;margin:8px 0 10px;">'
+        f'<span style="font-size:{score_size};font-weight:850;color:#22c55e;">{score}</span>'
+        f'<span style="font-size:13px;color:#94a3b8;">/100 · meta do agente</span></div>'
+        f'<div style="overflow-x:auto;"><table style="width:100%;border-collapse:collapse;font-size:11px;color:#cbd5e1;">'
+        f'<thead><tr><th style="text-align:left;padding:5px 3px;border-bottom:1px solid #334155;">KPI</th>'
+        f'<th style="text-align:left;padding:5px 3px;border-bottom:1px solid #334155;">Valor</th>'
+        f'<th style="text-align:left;padding:5px 3px;border-bottom:1px solid #334155;">Meta</th>'
+        f'<th style="text-align:left;padding:5px 3px;border-bottom:1px solid #334155;">Estado</th></tr></thead>'
+        f'<tbody>{row_html}</tbody></table></div></div>'
+    )
+
+
+def render_growth_bilibili() -> None:
+    st.title("Analista Bilibili")
+    st.caption("Como o agente opera e reporta: procura, click funnel, retenção, engagement 三连 e saúde da audiência Bilibili.")
+    st.info("Esta aba define o protocolo e o dashboard de reporte do agente. Os valores privados são preenchidos quando os dados autorizados do Bilibili Studio estiverem disponíveis; não são inventados a partir de páginas públicas.")
+
+    summary_col, status_col = st.columns([3.25, 1], gap="large")
+    with summary_col:
+        st.markdown(
+            '<div style="border:1px solid #263447;border-radius:12px;padding:18px;margin:12px 0 20px;'
+            'background:#101722;display:flex;align-items:center;justify-content:space-between;min-height:76px;">'
+            '<div><div style="font-size:13px;color:#94a3b8;text-transform:uppercase;letter-spacing:.08em;">Estado do agente</div>'
+            '<div style="font-size:18px;font-weight:700;margin-top:5px;">Pronto para auditoria Bilibili</div></div>'
+            '<div style="font-size:18px;font-weight:800;color:#22c55e;">PROTOCOLO ACTIVO</div></div>',
+            unsafe_allow_html=True,
+        )
+    with status_col:
+        st.write("")
+        st.button("ANALISAR CANAL", disabled=True, use_container_width=True, key="growth_bilibili_analyse_disabled")
+        st.caption("A ligação ao Studio será usada quando autorizada.")
+
+    st.subheader("Dashboard de Growth")
+    st.caption("Os três pilares críticos aparecem primeiro; os cinco blocos operacionais completam o diagnóstico. Verde: referência de execução · Cinzento: dado a verificar no Studio.")
+    st.markdown('<div style="display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:14px;margin:14px 0 18px;">' + "".join(_card_html(card) for card in BILIBILI_CARDS[:3]) + '</div>', unsafe_allow_html=True)
+    st.markdown('<div style="display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:12px;margin:0 0 18px;">' + "".join(_card_html(card) for card in BILIBILI_CARDS[3:]) + '</div>', unsafe_allow_html=True)
+    st.caption("Legenda: o agente compara os dados autorizados com as metas Bilibili; quando um dado não existe, apresenta “A verificar” em vez de estimar.")
+
+    st.divider()
+    operation_tab, report_tab, monetization_tab = st.tabs(["Como o agente vai operar", "Como vai reportar", "Contexto de monetização"])
+    with operation_tab:
+        st.subheader("Protocolo de auditoria em 10 passos")
+        st.markdown("""
+1. **Validar procura:** compara o tecto de concorrentes, pesquisa e origem do tráfego.
+2. **Avaliar thumbnail:** verifica CTR, contraste, legibilidade móvel, emoção e elementos ACG quando adequados.
+3. **Avaliar título:** cruza CTR com retenção inicial e aplica Curiosity, Clarity e Context.
+4. **Verificar engagement:** mede a taxa 三连 (Like + Coin + Favorite), danmaku e qualidade dos comentários.
+5. **Diagnosticar hook:** localiza a queda dos primeiros 15–30 segundos e aplica “clímax primeiro”.
+6. **Diagnosticar ritmo:** identifica quedas recorrentes e recomenda pattern interrupts a cada 5–8 segundos.
+7. **Ler o algoritmo:** compara Recommendation, Search, Followers e External com as metas da plataforma.
+8. **Medir conversão:** calcula novos followers por visualização e posiciona a CTA aos 40% do vídeo.
+9. **Verificar cadência:** acompanha 1–2 vídeos por semana, consistência e uso de posts/live para comunidade.
+10. **Avaliar saúde:** cruza Fan Playback, New Viewer, abandono mensal e sinais moonshot.
+""")
+    with report_tab:
+        st.subheader("Formato do reporte entregue pelo agente")
+        st.markdown("""
+O agente reporta sempre em cinco blocos: **projecção financeira e contexto**, **resumo dos dez pilares**, **Top 3 prioridades accionáveis**, **estratégia de longo prazo** e **checklist dos próximos passos**. Cada KPI recebe valor observado, meta, estado e origem do dado.
+
+As três prioridades são escolhidas por impacto: primeiro **Thumbnail + Título**, depois **retenção e engagement**, e só depois produção ou expansão. O relatório distingue claramente `DADO OBSERVADO`, `A VERIFICAR` e `RECOMENDAÇÃO`, sem transformar uma meta em resultado real.
+
+> Regra de reporte: um vídeo com conteúdo forte, mas sem click funnel, não é considerado optimizado. O agente corrige primeiro a combinação thumbnail + título e acompanha a evolução no ciclo seguinte.
+""")
+        st.markdown("**Checklist padrão:** validar nicho · corrigir as últimas 5 thumbnails · reescrever títulos · cortar a introdução · inserir prompt danmaku · publicar em dia fixo · rever analytics em 30 dias.")
+    with monetization_tab:
+        st.subheader("Referências internas usadas pelo agente")
+        st.markdown("""
+A projecção considera Video Incentive Program, Charging, Paid Subscriptions e Huahuo. O cálculo interno é: `Playbacks × Base Rate × Zone Multiplier × Quality Multiplier + Ad Revenue + Tips + Subscriptions`.
+
+Para o diagnóstico inicial, o agente acompanha originalidade do conteúdo, verificação de identidade, estado da conta, direitos ≥ 3, score de crédito ≥ 80 e os limiares de audiência definidos no material Bilibili. Estes itens são **contexto de elegibilidade**, não promessa de rendimento.
+
+Os sinais moonshot acompanhados são densidade de danmaku (> 5 por minuto), crescimento do Search Index (+20% mensal), Long-tail Traffic (> 30%), Shares (> 1%) e Collect Rate (> 5%).
+""")

package/integrations/instagram_public.py

@@ -62,14 +62,21 @@ def fetch_public_instagram_profile(source: str) -> IntegrationResult:
     title = _meta(response.text, 'og:title') or reference['username']
     description = _meta(response.text, 'og:description')
     avatar_url = _meta(response.text, 'og:image')
-    followers = None
-    match = re.search(r'([\d,.]+)\s*(?:followers|seguidores)', description, flags=re.IGNORECASE)
-    if match:
-        try:
-            followers = int(re.sub(r'[^0-9]', '', match.group(1)))
-        except ValueError:
-            followers = None
-    data = {'id': f"instagram_{reference['username']}", **reference, 'name': title.split('(')[0].strip() or reference['username'], 'bio': description, 'avatar_url': avatar_url, 'subscriber_count': followers, 'public_lookup': True, 'metrics_source': 'instagram_public_page', 'last_public_lookup_at': datetime.now(timezone.utc).isoformat()}
+    def metric(patterns: tuple[str, ...]) -> int | None:
+        for pattern in patterns:
+            found = re.search(pattern, description, flags=re.IGNORECASE)
+            if not found:
+                continue
+            try:
+                return int(re.sub(r'[^0-9]', '', found.group(1)))
+            except ValueError:
+                continue
+        return None
+
+    followers = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:followers|seguidores)',))
+    following = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:following|seguindo)',))
+    posts = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:posts|publicações|publications)',))
+    data = {'id': f"instagram_{reference['username']}", **reference, 'name': title.split('(')[0].strip() or reference['username'], 'bio': description, 'avatar_url': avatar_url, 'subscriber_count': followers, 'following_count': following, 'post_count': posts, 'public_lookup': True, 'metrics_source': 'instagram_public_page', 'last_public_lookup_at': datetime.now(timezone.utc).isoformat()}
     return IntegrationResult(True, 'Perfil Instagram encontrado publicamente.', data)
 
 

package/integrations/meta_social.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Mapping
+
+import requests
+
+
+META_GRAPH_BASE_URL = "https://graph.facebook.com/v20.0"
+
+
+def _result(status: str, message: str, *, status_code: int | None = None, data: Mapping[str, Any] | None = None) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "status": status,
+        "message": message[:240],
+        "checked_at": datetime.now(timezone.utc).isoformat(),
+    }
+    if status_code is not None:
+        payload["status_code"] = int(status_code)
+    if data:
+        payload["data"] = dict(data)
+    return payload
+
+
+def _get_graph(identifier: str, access_token: str, fields: str) -> dict[str, Any]:
+    identifier = str(identifier or "").strip()
+    access_token = str(access_token or "").strip()
+    if not access_token:
+        return _result("missing", "Informe a API key/token antes do teste.")
+    if not identifier:
+        return _result("missing", "Informe o identificador da conta antes do teste.")
+    try:
+        response = requests.get(
+            f"{META_GRAPH_BASE_URL}/{identifier}",
+            params={"fields": fields, "access_token": access_token},
+            timeout=15,
+        )
+    except requests.RequestException:
+        return _result("error", "Não foi possível contactar a Meta Graph API.")
+    try:
+        payload = response.json()
+    except ValueError:
+        payload = {}
+    if response.status_code >= 400 or payload.get("error"):
+        error = payload.get("error") if isinstance(payload, dict) else {}
+        message = str(error.get("message") or f"A Meta Graph API devolveu HTTP {response.status_code}.")
+        return _result("error", message, status_code=response.status_code)
+    return _result("success", "Chamada Meta Graph API concluída.", status_code=response.status_code, data={
+        "id": payload.get("id"),
+        "name": payload.get("name"),
+        "username": payload.get("username"),
+    })
+
+
+def test_instagram_api_card(card: Mapping[str, Any]) -> dict[str, Any]:
+    """Validate an Instagram Graph API card without persisting its token."""
+    return _get_graph(
+        str(card.get("account_id") or ""),
+        str(card.get("access_token") or ""),
+        "id,username,name,profile_picture_url,followers_count,media_count",
+    )
+
+
+def test_facebook_pages_api_card(card: Mapping[str, Any]) -> dict[str, Any]:
+    """Validate a Facebook Pages Graph API card without persisting its token."""
+    return _get_graph(
+        str(card.get("page_id") or ""),
+        str(card.get("access_token") or ""),
+        "id,name,fan_count,followers_count,link",
+    )
+
+
+__all__ = ["META_GRAPH_BASE_URL", "test_instagram_api_card", "test_facebook_pages_api_card"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",
@@ -11,6 +11,7 @@
   "files": [
     "app/main.py",
     "app/influencers_ui.py",
+    "app/social_networks_ui.py",
     "app/modules/**/*.py",
     "hermes_ui/*.py",
     "integrations/*.py",