@danhachuel/thunderbolt 0.6.9 → 0.6.11

package/app/main.py

@@ -109,6 +109,7 @@ from hermes_ui.draft_video import DRAFT_SETTING_SECTIONS, missing_content_fields
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_thumbnail_prompt, generate_title_and_keywords, generate_topic_for_channel, generate_video_description, generate_video_keywords, generate_video_update_metadata
 from hermes_ui.media_generation import MediaGenerationError, format_media_generation_error, generate_image_for_card, generate_video_for_card
 from hermes_ui.growth_youtube import list_analyses, run_audit
+from hermes_ui.growth_tiktok import render_growth_tiktok
 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
@@ -124,6 +125,7 @@ from integrations.youtube_direct_credentials import delete_credentials_document,
 from integrations.session_info_health import check_account_session_info_health
 from integrations.youtube_session_manager import renew_account_session
 from integrations.youtube_batch import account_key as youtube_batch_account_key, account_status as youtube_batch_account_status, authorize_account as authorize_youtube_batch_account, delete_account_token as delete_youtube_batch_token, list_my_channels as list_youtube_batch_channels, loopback_redirect_uri
+from integrations.youtube_upload import authorize_youtube_agent
 from integrations.youtube_growth_api import find_account_for_channel as find_youtube_growth_account
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
@@ -6767,7 +6769,7 @@ def render_google_accounts(*, include_innertube: bool = True):
                 document_save = st.button("Guardar documento nesta conta", key=f"save_direct_account_{account_id}", use_container_width=True)
 
                 account_status = youtube_batch_account_status(batch_account, STORAGE)
-                status_cols = st.columns(3)
+                status_cols = st.columns(4)
                 with status_cols[0]:
                     (st.success if account_status.ok else st.warning)(account_status.message)
                 with status_cols[1]:
@@ -6777,6 +6779,12 @@ def render_google_accounts(*, include_innertube: bool = True):
                         if result.ok:
                             st.rerun()
                 with status_cols[2]:
+                    if st.button("Autorizar upload YouTube", key=f"batch_authorize_upload_{account_id}", use_container_width=True, help="Autoriza esta conta com o escopo de publicação YouTube; é separado da autorização de leitura/listagem dos canais." ):
+                        result = authorize_youtube_agent(settings, STORAGE, account=batch_account)
+                        (st.success if result.ok else st.error)(result.message)
+                        if result.ok:
+                            st.rerun()
+                with status_cols[3]:
                     if st.button("Apagar conta", icon=":material/delete:", key=f"batch_remove_settings_{account_id}", use_container_width=True):
                         delete_youtube_batch_token(batch_account, STORAGE)
                         delete_credentials_document(STORAGE, batch_account)
@@ -8034,7 +8042,8 @@ def render_settings():
             composio_enabled = st.checkbox("Activar Composio", value=bool(settings.get("composio_enabled", False)), key="upload_composio_enabled")
             composio_auto_upload = st.checkbox("Usar Composio por defeito na Automação Youtube", value=bool(settings.get("composio_auto_upload", True)), key="upload_composio_auto_upload", help="Quando estiver configurado, Composio é tentado antes da API Oficial, Upload directo e Postiz.")
             composio_api_key = st.text_input("Composio API key", value=str(settings.get("composio_api_key") or ""), type="password", key="upload_composio_api_key", help="Use a API key de projecto do Composio Platform. Nunca coloque esta chave no GitHub, em URLs ou em mensagens.")
-            composio_user_id = st.text_input("Composio user ID", value=str(settings.get("composio_user_id") or "thunderbolt-local"), key="upload_composio_user_id", help="Identidade estável usada para associar as contas conectadas no Composio.")
+            composio_user_id = st.text_input("Composio user ID", value=str(settings.get("composio_user_id") or "thunderbolt-local"), key="upload_composio_user_id", help="Tem de ser o mesmo user ID usado quando as contas YouTube foram ligadas no Composio.")
+            composio_connected_account_id = st.text_input("Connected account YouTube (ID ou alias)", value=str(settings.get("composio_connected_account_id") or ""), key="upload_composio_connected_account_id", help="Opcional. Selecciona uma conta activa do Composio. Use o ID exacto ou alias configurado.")
             current_tool_slug = str(settings.get("composio_tool_slug") or "upload_video")
             if current_tool_slug not in composio_operation_slugs:
                 current_tool_slug = "upload_video"
@@ -8068,7 +8077,7 @@ def render_settings():
             with composio_action_cols[1]:
                 test_composio = st.button("Testar configuração", use_container_width=True, key="upload_composio_test")
             if save_composio:
-                settings.update({"composio_enabled": bool(composio_enabled), "composio_auto_upload": bool(composio_auto_upload), "composio_api_key": composio_api_key.strip(), "composio_user_id": composio_user_id.strip() or "thunderbolt-local", "composio_toolkit": composio_toolkit, "composio_tool_slug": composio_tool_slug, "composio_file_field": "videoFilePath", "composio_channel_field": composio_channel_field, "composio_privacy_status": composio_privacy_status, "composio_category_id": composio_category_id, "composio_language": composio_language, "composio_privacy_field": "privacyStatus", "composio_category_field": "categoryId", "composio_language_field": "defaultLanguage", "composio_arguments_json": composio_arguments_json or "{}"})
+                settings.update({"composio_enabled": bool(composio_enabled), "composio_auto_upload": bool(composio_auto_upload), "composio_api_key": composio_api_key.strip(), "composio_user_id": composio_user_id.strip() or "thunderbolt-local", "composio_connected_account_id": composio_connected_account_id.strip(), "composio_toolkit": composio_toolkit, "composio_tool_slug": composio_tool_slug, "composio_file_field": "videoFilePath", "composio_channel_field": composio_channel_field, "composio_privacy_status": composio_privacy_status, "composio_category_id": composio_category_id, "composio_language": composio_language, "composio_privacy_field": "privacyStatus", "composio_category_field": "categoryId", "composio_language_field": "defaultLanguage", "composio_arguments_json": composio_arguments_json or "{}"})
                 write_json("settings.json", settings)
                 st.success("Configuração Composio guardada.")
                 st.rerun()
@@ -9060,7 +9069,7 @@ def main():
         "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."),
         "Analista Growth Youtube": render_growth_youtube,
-        "Analista Growth Tiktok": lambda: render_edit_placeholder("Analista Growth Tiktok", ""),
+        "Analista Growth Tiktok": render_growth_tiktok,
         "Analista Growth Instagram": lambda: render_edit_placeholder("Analista Growth Instagram", ""),
         "Analista Facebook Pages": lambda: render_edit_placeholder("Analista Facebook Pages", ""),
         "Analista Bilibili": lambda: render_edit_placeholder("Analista Bilibili", ""),

package/hermes_ui/growth_tiktok.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+import json
+import re
+import uuid
+from datetime import datetime, timezone
+from html import escape
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+import streamlit as st
+
+from integrations.tiktok_public import fetch_public_tiktok_profile
+from .storage import STORAGE, read_json, write_json
+
+ANALYSES_FILENAME = "tiktok_growth_analyses.json"
+ANALYSES_DIR = STORAGE / "growth" / "tiktok"
+AGENT_METRICS = (
+    "Demanda e viabilidade do nicho", "Hook — primeiros 3 segundos", "Watch time e retenção",
+    "CTR e embalagem", "Ritmo e edição", "Tráfego FYP", "Engajamento", "Conversão em seguidores", "Cadência",
+)
+
+
+def analysis_code(now: datetime | None = None) -> str:
+    moment = now or datetime.now(timezone.utc)
+    return f"GTA-{moment.strftime('%Y%m%d-%H%M%S')}-{uuid.uuid4().hex[:6].upper()}"
+
+
+def _score_color(score: int | float) -> str:
+    return "red" if score <= 30 else "yellow" if score < 70 else "green"
+
+
+def _safe_int(value: Any, default: int = 0) -> int:
+    try:
+        return int(value or default)
+    except (TypeError, ValueError):
+        return default
+
+
+def _number(value: Any) -> float | None:
+    try:
+        return float(value) if value not in (None, "", "—") else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _public_videos(source: str, limit: int = 5) -> list[dict[str, Any]]:
+    try:
+        import yt_dlp
+    except ImportError as exc:
+        raise RuntimeError("yt-dlp não está instalado. Instale as dependências do Thunderbolt.") from exc
+    options = {"quiet": True, "skip_download": True, "extract_flat": True, "playlistend": limit, "noplaylist": False}
+    with yt_dlp.YoutubeDL(options) as downloader:
+        info = downloader.extract_info(source, download=False)
+    entries = info.get("entries") if isinstance(info, Mapping) else []
+    videos: list[dict[str, Any]] = []
+    for item in entries or []:
+        if not isinstance(item, Mapping):
+            continue
+        video_id = str(item.get("id") or item.get("webpage_url") or "").strip()
+        if not video_id:
+            continue
+        videos.append({
+            "id": video_id,
+            "title": str(item.get("title") or "Sem título").strip(),
+            "url": str(item.get("webpage_url") or f"https://www.tiktok.com/@{source.lstrip('@').split('/')[-1]}/video/{video_id}"),
+            "view_count": _safe_int(item.get("view_count")),
+            "like_count": _safe_int(item.get("like_count")),
+            "comment_count": _safe_int(item.get("comment_count")),
+            "repost_count": _safe_int(item.get("repost_count")),
+            "duration": _safe_int(item.get("duration")),
+            "upload_date": str(item.get("upload_date") or ""),
+        })
+    return videos[:limit]
+
+
+def _score_from_rate(rate: float | None, thresholds: tuple[float, float]) -> int:
+    if rate is None:
+        return 50
+    low, high = thresholds
+    if rate < low:
+        return 30
+    if rate < high:
+        return 60
+    return 85
+
+
+def _report_markdown(record: Mapping[str, Any]) -> str:
+    profile = record.get("profile") or {}
+    lines = [
+        f"# TIKTOK CHANNEL AUDIT REPORT: {record.get('channel_name', 'Canal')}", "",
+        f"- Código: `{record.get('code')}`", "- Plataforma: TikTok",
+        f"- Data: {record.get('created_at')}", f"- Nota geral: **{record.get('overall_score', 0)}/100**", "",
+        "## Resumo executivo", "",
+        f"- Elegível para Creator Rewards: **{record.get('monetization_status', 'A verificar')}**",
+        f"- Seguidores públicos: **{profile.get('subscriber_count', '—')}**",
+        f"- Visualizações públicas na amostra: **{record.get('sample_views', '—')}**", "",
+        "## Diagnóstico", "", "| Pilar | Nota | Métrica observada | Origem | Diagnóstico |", "|---|---:|---|---|---|",
+    ]
+    for metric in record.get("metrics", []):
+        lines.append(f"| **{metric['label']}** | {metric['score']}/100 | {metric['value']} | {metric.get('source', 'unknown')} | {metric['diagnosis']} |")
+    lines += ["", "## Últimos vídeos públicos", "", "| Título | Visualizações | Gostos | Comentários | Duração |", "|---|---:|---:|---:|---:|"]
+    for video in record.get("videos", []):
+        lines.append(f"| {str(video.get('title', '')).replace('|', '/')} | {video.get('view_count', 0):,} | {video.get('like_count', 0):,} | {video.get('comment_count', 0):,} | {video.get('duration', 0)}s |")
+    lines += ["", "## Roadmap accionável", "", "1. **REBUILD THE HOOK**: nos primeiros 3 segundos, começar com resultado, estatística, pergunta directa ou pattern interrupt; sem logo ou introdução lenta.", "2. **OPTIMIZE RETENTION**: renovar visual/texto a cada 3–5 segundos, inserir micro-hook a cada 5–8 segundos e cliffhanger a cada 15–20 segundos.", "3. **PUBLISH CONSISTENTLY**: manter pelo menos 3 vídeos por semana, priorizando originalidade, vídeos com 60+ segundos e qualidade sobre volume.", "", "## Limitações", "", "CTR, retenção de 3 segundos, curva de retenção, origem FYP, RPM, seguidores ganhos e elegibilidade completa exigem dados autorizados do TikTok Studio. Estes valores não são inventados a partir de uma página pública."]
+    return "\n".join(lines) + "\n"
+
+
+def run_audit(channel: Mapping[str, Any], settings: Mapping[str, Any] | None = None, *, progress: Callable[[str], None] | None = None) -> dict[str, Any]:
+    del settings
+    code = analysis_code()
+    root = ANALYSES_DIR / code
+    root.mkdir(parents=True, exist_ok=True)
+    notify = progress or (lambda _message: None)
+    source = str(channel.get("url") or channel.get("handle") or "").strip()
+    if not source:
+        raise RuntimeError("A conta seleccionada não tem URL pública ou handle TikTok.")
+    notify("A consultar o perfil público TikTok…")
+    profile_result = fetch_public_tiktok_profile(source)
+    profile = dict(profile_result.data or {})
+    if not profile_result.ok and not profile:
+        raise RuntimeError(profile_result.message)
+    notify("A recolher os últimos 5 vídeos públicos…")
+    try:
+        videos = _public_videos(source, 5)
+    except Exception as exc:
+        videos = []
+        profile["video_lookup_error"] = str(exc)[:240]
+    views = sum(_safe_int(item.get("view_count")) for item in videos)
+    likes = sum(_safe_int(item.get("like_count")) for item in videos)
+    comments = sum(_safe_int(item.get("comment_count")) for item in videos)
+    shares = sum(_safe_int(item.get("repost_count")) for item in videos)
+    engagement = ((likes + comments + shares) / views * 100) if views else None
+    avg_views = views / len(videos) if videos else None
+    durations = [_safe_int(item.get("duration")) for item in videos if _safe_int(item.get("duration")) > 0]
+    avg_duration = sum(durations) / len(durations) if durations else None
+    followers = _number(profile.get("subscriber_count"))
+    conversion = (followers / views * 100) if followers is not None and views else None
+    cadence_score = 70 if len(videos) >= 3 else 40 if videos else 0
+    niche = str(channel.get("niche") or channel.get("description") or "—")
+    metrics = [
+        {"label": "Demanda e viabilidade do nicho", "score": 50 if videos else 0, "value": f"{len(videos)} vídeos públicos", "source": "public", "diagnosis": "Amostra pública recolhida; concorrência e Creative Center requerem dados externos autorizados."},
+        {"label": "Hook — primeiros 3 segundos", "score": 50, "value": "Retenção de 3s indisponível", "source": "unavailable", "diagnosis": "TikTok Studio é necessário para a retenção inicial."},
+        {"label": "Watch time e retenção", "score": 50, "value": f"Duração média {avg_duration:.0f}s" if avg_duration else "Curva de retenção indisponível", "source": "public" if avg_duration else "unavailable", "diagnosis": "A duração pública não substitui watch time ou curva de retenção."},
+        {"label": "CTR e embalagem", "score": 50, "value": "CTR não exposto publicamente", "source": "unavailable", "diagnosis": "CTR e impressões exigem TikTok Studio."},
+        {"label": "Ritmo e edição", "score": 50, "value": "Quedas de retenção indisponíveis", "source": "unavailable", "diagnosis": "A análise de pacing depende da curva de retenção."},
+        {"label": "Tráfego FYP", "score": 50, "value": "Origem FYP indisponível", "source": "unavailable", "diagnosis": "FYP, Search, Followers e External exigem TikTok Studio."},
+        {"label": "Engajamento", "score": _score_from_rate(engagement, (3, 6)), "value": f"{engagement:.2f}% na amostra" if engagement is not None else "Sem interacções públicas", "source": "public", "diagnosis": "Likes, comentários e reposts agregados nos vídeos públicos recolhidos."},
+        {"label": "Conversão em seguidores", "score": _score_from_rate(conversion, (0.5, 1.0)), "value": f"{conversion:.2f}% proxy" if conversion is not None else "Seguidores ganhos por vídeo indisponíveis", "source": "estimated" if conversion is not None else "unavailable", "diagnosis": "Proxy não equivale a seguidores ganhos por vídeo."},
+        {"label": "Cadência", "score": cadence_score, "value": f"{len(videos)} vídeos na amostra", "source": "public", "diagnosis": "A frequência semanal precisa de datas públicas válidas ou TikTok Studio."},
+    ]
+    overall = round(sum(item["score"] for item in metrics) / len(metrics)) if metrics else 0
+    monetization = "A verificar — faltam dados privados" if followers is None or followers < 10000 else "Possível — confirmar 100.000 views/30 dias e conta elegível"
+    record = {"code": code, "channel_id": str(channel.get("id") or ""), "channel_name": str(channel.get("name") or profile.get("name") or "Conta TikTok"), "platform": "TikTok", "created_at": datetime.now(timezone.utc).isoformat(), "overall_score": overall, "score_color": _score_color(overall), "metrics": metrics, "videos": videos, "profile": profile, "sample_views": views, "engagement_rate": engagement, "monetization_status": monetization, "status": "completed"}
+    report_path = root / f"{code}.md"
+    report_path.write_text(_report_markdown(record), encoding="utf-8")
+    record["report_path"] = str(report_path)
+    analyses = read_json(ANALYSES_FILENAME, [])
+    if not isinstance(analyses, list): analyses = []
+    analyses.append(record)
+    write_json(ANALYSES_FILENAME, analyses[-100:])
+    return record
+
+
+def list_analyses() -> list[dict[str, Any]]:
+    value = read_json(ANALYSES_FILENAME, [])
+    return [dict(item) for item in value if isinstance(item, Mapping)] if isinstance(value, list) else []
+
+
+def _card(title: str, score: Any, featured: bool, rows: list[tuple[str, str, str, str]]) -> str:
+    score_int = _safe_int(score)
+    row_html = "".join(f'<tr><td>{escape(label)}</td><td><b>{escape(value)}</b></td><td>{escape(target)}</td><td style="color:{colour};font-weight:700;">● {escape(status)}</td></tr>' for label, value, target, status, colour in rows)
+    return f'<div style="min-height:{"350px" if featured else "280px"};border:1px solid #2b3b52;border-radius:14px;padding:16px;background:linear-gradient(145deg,#111c2b,#0b121c);box-shadow:0 8px 22px rgba(0,0,0,.16);"><div style="font-size:{"19px" if featured else "16px"};font-weight:750;color:#f8fafc;margin-top:8px;">{escape(title)}</div><div style="display:flex;align-items:baseline;gap:5px;margin:8px 0 10px;"><span style="font-size:{"38px" if featured else "30px"};font-weight:850;color:{"#ef4444" if score_int <= 30 else "#f59e0b" if score_int < 70 else "#22c55e"};">{score_int}</span><span style="font-size:13px;color:#94a3b8;">/100</span></div><div style="overflow-x:auto;"><table style="width:100%;border-collapse:collapse;font-size:11px;color:#cbd5e1;"><thead><tr><th style="text-align:left;padding:5px 3px;border-bottom:1px solid #334155;">KPI</th><th style="text-align:left;padding:5px 3px;border-bottom:1px solid #334155;">Valor</th><th style="text-align:left;padding:5px 3px;border-bottom:1px solid #334155;">Meta</th><th style="text-align:left;padding:5px 3px;border-bottom:1px solid #334155;">Status</th></tr></thead><tbody>{row_html}</tbody></table></div></div>'
+
+
+def render_growth_tiktok() -> None:
+    st.title("Analista Growth Tiktok")
+    st.caption("Auditoria pública baseada nos 3 pilares críticos e nas métricas secundárias do agente Growth TikTok.")
+    channels = [item for item in read_json("channels.json", []) if isinstance(item, dict) and item.get("active", True) and str(item.get("platform") or "").casefold() == "tiktok"]
+    if not channels:
+        st.info("Cadastre pelo menos uma conta TikTok em Canais Tiktok para iniciar a análise.")
+        return
+    selector_col, action_col = st.columns([1.05, 1.15], gap="small")
+    with selector_col:
+        selected = st.selectbox("Conta a analisar", channels, format_func=lambda item: str(item.get("name") or item.get("handle") or "Conta sem nome"), key="growth_tiktok_channel")
+    with action_col:
+        st.write("")
+        analyse_clicked = st.button("ANALISAR CONTA", type="primary", use_container_width=True, key="growth_tiktok_analyse")
+    st.markdown("**Estado das APIs de Growth**")
+    api_cols = st.columns(2, gap="small")
+    with api_cols[0]:
+        st.caption("TikTok página pública: perfil e amostra de vídeos")
+        st.markdown('<span style="color:#22c55e;font-weight:700;">● Disponível quando a página pública responder</span>', unsafe_allow_html=True)
+    with api_cols[1]:
+        st.caption("TikTok Studio: retenção, FYP, CTR e conversão")
+        st.markdown('<span style="color:#94a3b8;font-weight:700;">● Requer dados privados autorizados</span>', unsafe_allow_html=True)
+    if analyse_clicked:
+        with st.status("A preparar a análise pública…", expanded=True) as status:
+            try:
+                record = run_audit(selected, read_json("settings.json", {}), progress=st.write)
+                st.session_state["growth_tiktok_last_code"] = record["code"]
+                status.update(label="Análise concluída", state="complete")
+            except Exception as exc:
+                status.update(label="Análise falhou", state="error")
+                st.error(str(exc)[:500])
+    records = list_analyses()
+    selected_record = next((item for item in reversed(records) if str(item.get("channel_id")) == str(selected.get("id"))), None)
+    metric_by_label = {str(item.get("label")): item for item in (selected_record.get("metrics", []) if selected_record else [])}
+    metrics = selected_record.get("metrics", []) if selected_record else [{"label": label, "score": 0, "value": "Aguardando análise", "source": "unknown"} for label in AGENT_METRICS]
+    score = selected_record.get("overall_score") if selected_record else None
+    score_color = "#64748b" if score is None else ("#ef4444" if score <= 30 else "#f59e0b" if score < 70 else "#22c55e")
+    summary_col, download_col = st.columns([3.25, 1], gap="large")
+    with summary_col:
+        st.markdown(f'<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;">Nota geral da conta</div><div style="font-size:18px;font-weight:700;margin-top:5px;">{escape(str(selected.get("name") or selected.get("handle") or "Conta TikTok"))}</div></div><div style="font-size:42px;font-weight:800;color:{score_color};line-height:1;">{score if score is not None else "—"}<span style="font-size:16px;color:#94a3b8;">{("/100" if score is not None else "")}</span></div></div>', unsafe_allow_html=True)
+    with download_col:
+        st.write("")
+        report_path = Path(str(selected_record.get("report_path") or "")) if selected_record else Path()
+        if report_path.is_file():
+            st.download_button("BAIXAR ANALISE COMPLETA", report_path.read_bytes(), file_name=report_path.name, mime="text/markdown", use_container_width=True, key=f"tiktok_download_{selected_record['code']}")
+        else:
+            st.button("BAIXAR ANALISE COMPLETA", disabled=True, use_container_width=True, key="tiktok_download_disabled")
+    st.subheader("Dashboard de Growth")
+    st.caption("3 pilares críticos em destaque e camadas operacionais abaixo. Vermelho: 0–30 · Amarelo: 31–69 · Verde: 70–100.")
+    def item(label: str, target: str, available: bool = False) -> tuple[str, str, str, str, str]:
+        metric = metric_by_label.get(label, {})
+        value = str(metric.get("value", "Aguardando análise"))
+        return (label, value, target, "A verificar" if not available else "Meta atingida", "#94a3b8" if not available else "#22c55e")
+    cards = [
+        ("Demanda e viabilidade do nicho", True, [item("Demanda e viabilidade do nicho", "> 500k concorrência", True), ("Nicho Detectado", str(selected.get("niche") or "—"), "Viável", "A verificar", "#94a3b8")]),
+        ("Hook — primeiros 3 segundos", True, [item("Hook — primeiros 3 segundos", "> 70% retenção 3s"), ("Primeiro frame", "Dados privados", "Hook visível", "A verificar", "#94a3b8")]),
+        ("Watch time e retenção", True, [item("Watch time e retenção", "> 60% aos 60s"), ("Micro-hook", "Dados privados", "a cada 5–8s", "A verificar", "#94a3b8")]),
+        ("CTR e embalagem", False, [item("CTR e embalagem", "> 8% CTR")]),
+        ("Ritmo e edição", False, [item("Ritmo e edição", "Refresh 5–8s")]),
+        ("Tráfego FYP", False, [item("Tráfego FYP", "> 70% FYP")]),
+        ("Engajamento", False, [item("Engajamento", "> 6%")]),
+        ("Conversão em seguidores", False, [item("Conversão em seguidores", "> 1%")]),
+        ("Cadência", False, [item("Cadência", "3–5 vídeos/semana")]),
+    ]
+    st.markdown('<div style="display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:14px;margin:14px 0 18px;">' + "".join(_card(title, metric_by_label.get(title, {}).get("score", 0), featured, rows) for title, featured, rows in 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(title, metric_by_label.get(title, {}).get("score", 0), featured, rows) for title, featured, rows in cards[3:]) + '</div>', unsafe_allow_html=True)
+    st.caption("Legenda: ● Verde = meta atingida · ● Amarelo = atenção · ● Vermelho = crítico · Cinzento = dado não disponível na fonte autorizada.")
+    st.divider()
+    history_tab, dashboard_tab = st.tabs(["Últimas análises", "Leitura estratégica"])
+    with dashboard_tab:
+        st.write("Priorize Hook, retenção e cadência. CTR, FYP, retenção real e seguidores ganhos ficam pendentes de dados autorizados do TikTok Studio.")
+    with history_tab:
+        if not records:
+            st.info("Ainda não existem análises guardadas.")
+        for record in reversed(records[-20:]):
+            row = st.columns([2, 1, 2.2, 1.2, 1, 1.4])
+            row[0].write(f"**{record.get('channel_name', 'Conta TikTok')}**")
+            row[1].write("TikTok")
+            row[2].caption(str(record.get("code", "")))
+            row[3].caption(str(record.get("created_at", "")).replace("T", " ")[:19])
+            row[4].write(f"{record.get('overall_score', '—')}/100")
+            path = Path(str(record.get("report_path") or ""))
+            if path.is_file():
+                row[5].download_button("Análise", path.read_bytes(), file_name=path.name, mime="text/markdown", key=f"tiktok_history_{record.get('code')}")
+
+
+__all__ = ["AGENT_METRICS", "ANALYSES_DIR", "analysis_code", "list_analyses", "run_audit", "render_growth_tiktok"]

package/hermes_ui/storage.py

@@ -291,6 +291,7 @@ DEFAULTS: dict[str, Any] = {
         "composio_auto_upload": True,
         "composio_api_key": "",
         "composio_user_id": "thunderbolt-local",
+        "composio_connected_account_id": "",
         "composio_toolkit": "upload_video",
         "composio_tool_slug": "upload_video",
         "composio_file_field": "videoFilePath",

package/integrations/composio_upload.py

@@ -111,6 +111,35 @@ def _client(api_key: str, *, upload_dir: Path | None = None):
     return Composio(**kwargs)
 
 
+def _connected_account_id(client: Any, user_id: str, toolkit: str, selector: str) -> str:
+    """Resolve a connected-account ID from an ID or UI alias."""
+    value = str(selector or "").strip()
+    if not value:
+        return ""
+    try:
+        response = client.connected_accounts.list(user_ids=[_require_user_id(user_id)], statuses=["ACTIVE"])
+        raw = _safe_value(response)
+        items = raw.get("items", []) if isinstance(raw, dict) else raw
+        if not isinstance(items, list):
+            items = []
+        wanted = value.casefold()
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            toolkit_value = item.get("toolkit")
+            if isinstance(toolkit_value, dict):
+                toolkit_value = toolkit_value.get("slug") or toolkit_value.get("name")
+            candidates = [item.get("id"), item.get("nanoid"), item.get("alias"), item.get("name")]
+            if str(toolkit or "").strip() and toolkit.casefold() not in str(toolkit_value or "").casefold():
+                continue
+            if any(str(candidate or "").strip().casefold() == wanted for candidate in candidates):
+                return str(item.get("id") or item.get("nanoid") or value).strip()
+    except Exception:
+        # Preserve the original selector so Composio returns its actionable error.
+        return value
+    return value
+
+
 def discover_tools(api_key: str, user_id: str, query: str, toolkit: str = "") -> list[dict[str, Any]]:
     client = _client(api_key)
     try:
@@ -183,7 +212,7 @@ def parse_arguments(arguments_json: str) -> dict[str, Any]:
     return parsed
 
 
-def execute_upload(api_key: str, user_id: str, slug: str, video_path: str, file_field: str, arguments_json: str = "") -> dict[str, Any]:
+def execute_upload(api_key: str, user_id: str, slug: str, video_path: str, file_field: str, arguments_json: str = "", connected_account_id: str = "") -> dict[str, Any]:
     path = Path(str(video_path or "").strip()).expanduser()
     slug = str(slug or "").strip()
     file_field = str(file_field or "").strip()
@@ -201,13 +230,16 @@ def execute_upload(api_key: str, user_id: str, slug: str, video_path: str, file_
     arguments[file_field] = str(path.resolve())
     client = _client(api_key, upload_dir=path.parent)
     try:
-        result = client.tools.execute(
-            slug,
-            arguments=arguments,
-            user_id=_require_user_id(user_id),
-            version="latest",
-            dangerously_skip_version_check=True,
-        )
+        execute_kwargs: dict[str, Any] = {
+            "arguments": arguments,
+            "user_id": _require_user_id(user_id),
+            "version": "latest",
+            "dangerously_skip_version_check": True,
+        }
+        selected_account = _connected_account_id(client, user_id, "youtube", connected_account_id)
+        if selected_account:
+            execute_kwargs["connected_account_id"] = selected_account
+        result = client.tools.execute(slug, **execute_kwargs)
         response = _response(result)
         if not response["successful"] and not response["error"]:
             response["error"] = f"A ferramenta `{slug}` devolveu uma resposta sem sucesso."

package/integrations/upload_routing.py

@@ -338,6 +338,7 @@ def _composio_upload(settings: dict[str, Any], *, channel: dict[str, Any], **kwa
             str(kwargs.get("video_path") or ""),
             file_field,
             json.dumps(parsed_arguments, ensure_ascii=False),
+            str(settings.get("composio_connected_account_id") or channel.get("composio_connected_account_id") or "").strip(),
         )
     except ComposioUploadError as exc:
         return IntegrationResult(False, str(exc), {})

package/integrations/youtube_upload.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from typing import Any, Callable
 
 from integrations.platforms import IntegrationResult
-from integrations.youtube_batch import loopback_host, loopback_port, loopback_redirect_uri, token_path as batch_token_path
+from integrations.youtube_batch import account_key, loopback_host, loopback_port, loopback_redirect_uri, token_path as batch_token_path
 
 
 # O fluxo de upload precisa apenas do scope de publicação; Analytics e leitura
@@ -27,6 +27,13 @@ def _safe_text(value: Any, default: str = "") -> str:
     return str(value if value is not None else default).strip()
 
 
+def _upload_account_token_path(storage_root: Path, account: dict[str, Any] | None, purpose: str) -> Path | None:
+    if not isinstance(account, dict) or not (account.get("id") or account.get("email")):
+        return None
+    safe_purpose = str(purpose or "upload").strip().lower() or "upload"
+    return Path(storage_root) / "state" / "youtube_upload_tokens" / f"{account_key(account)}-{safe_purpose}.json"
+
+
 def _path_value(value: Any) -> Path | None:
     if isinstance(value, dict):
         value = value.get("path") or value.get("file") or value.get("filepath")
@@ -103,8 +110,16 @@ class _GoogleYouTubeBase:
         return any(path.exists() and path.stat().st_size > 0 for path in self._token_candidates())
 
     def _token_candidates(self) -> list[Path]:
-        paths = [self.token_path]
+        paths: list[Path] = []
+        account_token = _upload_account_token_path(self.token_path.parents[1], self.account, self.__class__.__name__)
+        if account_token is not None:
+            paths.append(account_token)
+        if not self.account:
+            paths.append(self.token_path)
         if self.account:
+            # Compatibilidade com autorizações de publicação antigas guardadas
+            # no caminho global; o token de leitura/listagem continua separado.
+            paths.append(self.token_path)
             paths.append(batch_token_path(self.token_path.parents[1], self.account))
         if self.alternate_token_path and self.alternate_token_path not in paths:
             paths.append(self.alternate_token_path)
@@ -146,19 +161,20 @@ class _GoogleYouTubeBase:
         return credentials
 
     def _save_credentials(self, credentials: Any, *, nested: bool = False) -> None:
-        self.token_path.parent.mkdir(parents=True, exist_ok=True)
+        destination = _upload_account_token_path(self.token_path.parents[1], self.account, self.__class__.__name__) or self.token_path
+        destination.parent.mkdir(parents=True, exist_ok=True)
         payload = json.loads(credentials.to_json())
         if nested:
             payload = {"youtube": payload}
-        temporary = self.token_path.with_name(f".{self.token_path.name}.{secrets.token_hex(6)}.tmp")
+        temporary = destination.with_name(f".{destination.name}.{secrets.token_hex(6)}.tmp")
         temporary.write_text(json.dumps(payload, indent=2), encoding="utf-8")
         try:
             os.chmod(temporary, 0o600)
         except OSError:
             pass
-        temporary.replace(self.token_path)
+        temporary.replace(destination)
         try:
-            os.chmod(self.token_path, 0o600)
+            os.chmod(destination, 0o600)
         except OSError:
             pass
 
@@ -382,12 +398,12 @@ def upload_youtube_with_fallback(
     return IntegrationResult(False, f"O agente de upload falhou e o fallback OAuth também falhou. Agente: {primary_result.message} Fallback: {fallback_result.message}", {"status": "all_upload_mechanisms_failed", "attempts": attempts})
 
 
-def authorize_youtube_agent(settings: dict[str, Any], storage_root: Path, *, open_browser: bool = True) -> IntegrationResult:
-    return YouTubeAutomationAgentUploader(settings, storage_root).authorize(open_browser=open_browser)
+def authorize_youtube_agent(settings: dict[str, Any], storage_root: Path, *, account: dict[str, Any] | None = None, open_browser: bool = True) -> IntegrationResult:
+    return YouTubeAutomationAgentUploader(settings, storage_root, account=account).authorize(open_browser=open_browser)
 
 
-def authorize_youtube_fallback(settings: dict[str, Any], storage_root: Path, *, open_browser: bool = True) -> IntegrationResult:
-    return DirectYouTubeOAuthUploader(settings, storage_root).authorize(open_browser=open_browser)
+def authorize_youtube_fallback(settings: dict[str, Any], storage_root: Path, *, account: dict[str, Any] | None = None, open_browser: bool = True) -> IntegrationResult:
+    return DirectYouTubeOAuthUploader(settings, storage_root, account=account).authorize(open_browser=open_browser)
 
 
 def youtube_upload_status(settings: dict[str, Any], storage_root: Path) -> dict[str, IntegrationResult]:

package/package.json

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