@danhachuel/thunderbolt 0.3.88 → 0.3.90

package/app/main.py

@@ -64,7 +64,7 @@ from hermes_ui.thumbnails import (
     upload_thumbnail_image,
 )
 from hermes_ui.draft_video import DRAFT_SETTING_SECTIONS, missing_content_fields, missing_setting_sections, normalise_saved_script, setting_widget_suffixes
-from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_thumbnail_prompt, generate_title_and_keywords, generate_topic_for_channel, generate_video_keywords
+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
 from hermes_ui.media_generation import MediaGenerationError, generate_image_for_card, generate_video_for_card
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
 from integrations.tiktok_public import fetch_public_tiktok_profile, normalize_tiktok_reference
@@ -4701,8 +4701,39 @@ def render_upload_conventional():
             channel = selected_youtube_channel or channel_map.get(str(task.get("channel_id")), {})
             account = direct_accounts.get(str(channel.get("google_account_id", "")))
             if "YouTube" in destination:
-                title = st.text_input("Título", value=task.get("title") or task.get("topic", "Vídeo Thunderbolt"), key=f"yt_title_{task['id']}")
-                description = st.text_area("Descrição", value=task.get("description", ""), key=f"yt_description_{task['id']}", height=100)
+                detected_language = normalize_video_language(task.get("language") or channel.get("language") or "pt")
+                language_state_key = f"yt_language_{task['id']}"
+                language_source_key = f"yt_language_source_{task['id']}"
+                if st.session_state.get(language_source_key) != detected_language:
+                    st.session_state[language_state_key] = detected_language
+                    st.session_state[language_source_key] = detected_language
+                title_state_key = f"yt_title_{task['id']}"
+                title = st.text_input("Título", value=task.get("title") or task.get("topic", "Vídeo Thunderbolt"), key=title_state_key)
+                description_state_key = f"yt_description_{task['id']}"
+                description_error_key = f"yt_description_ai_error_{task['id']}"
+
+                def generate_upload_description_callback() -> None:
+                    current_title = str(st.session_state.get(title_state_key) or title).strip()
+                    raw_tags = st.session_state.get(f"yt_tags_{task['id']}", task.get("tags", ""))
+                    current_tags = raw_tags if isinstance(raw_tags, list) else [item.strip() for item in str(raw_tags or "").split(",") if item.strip()]
+                    try:
+                        st.session_state[description_state_key] = generate_video_description(
+                            settings,
+                            channel,
+                            str(task.get("topic") or current_title),
+                            title=current_title,
+                            tags=current_tags,
+                            language=detected_language,
+                        )
+                    except CreativeGenerationError as exc:
+                        st.session_state[description_error_key] = str(exc)
+                    else:
+                        st.session_state.pop(description_error_key, None)
+
+                description = st.text_area("Descrição", value=task.get("description", ""), key=description_state_key, height=100)
+                st.button("Gerar descrição com IA", key=f"yt_description_ai_{task['id']}", use_container_width=False, on_click=generate_upload_description_callback)
+                if description_error := str(st.session_state.get(description_error_key) or "").strip():
+                    st.error(f"Não foi possível gerar a descrição: {description_error}")
                 tags_raw = st.text_input("Tags separadas por vírgula", value=task.get("tags", "") if isinstance(task.get("tags", ""), str) else ", ".join(task.get("tags", [])), key=f"yt_tags_{task['id']}")
                 yt_cols = st.columns(3)
                 with yt_cols[0]:
@@ -4711,7 +4742,13 @@ def render_upload_conventional():
                 with yt_cols[1]:
                     category_id = st.text_input("Category ID", value="22", key=f"yt_category_{task['id']}")
                 with yt_cols[2]:
-                    language = st.text_input("Idioma", value="pt-BR", key=f"yt_language_{task['id']}")
+                    language = st.selectbox(
+                        "Idioma",
+                        VIDEO_LANGUAGE_SELECTION_OPTIONS,
+                        index=VIDEO_LANGUAGE_SELECTION_OPTIONS.index(detected_language) if detected_language in VIDEO_LANGUAGE_SELECTION_OPTIONS else 0,
+                        format_func=video_language_label,
+                        key=language_state_key,
+                    )
                 quota_count = official_upload_count(channel, account)
                 st.caption(f"API Oficial hoje: {quota_count}/{OFFICIAL_DAILY_LIMIT} envios nesta conta Gmail.")
                 if not selected_youtube_channel:
@@ -6366,6 +6403,22 @@ def render_supabase_tutorial():
     st.markdown(tutorial_content, unsafe_allow_html=True)
 
 
+def render_youtube_frontend_upload_tutorial():
+    """Render the safe operational guide for the YouTube direct-upload workflow."""
+    tutorial_path = ROOT / "seed" / "references" / "youtube-video-upload-frontend.md"
+    st.title("Tutorial YouTube Video-Upload Frontend")
+    st.caption("Guia prático e seguro para rever metadados, sessão e envio directo de vídeos concluídos.")
+    st.markdown("[Abrir referência técnica no GitHub](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api)")
+    try:
+        tutorial_content = tutorial_path.read_text(encoding="utf-8").strip()
+    except OSError:
+        tutorial_content = ""
+    if not tutorial_content:
+        st.error("O conteúdo local do tutorial não está disponível. Consulte a referência técnica no GitHub.")
+        return
+    st.markdown(tutorial_content, unsafe_allow_html=False)
+
+
 def render_mcp():
     st.title("MCP")
     st.caption("Clientes externos, servidor MCP do Thunderbolt e a skill local ficam separados para evitar confundir funções diferentes.")
@@ -6671,6 +6724,7 @@ def main():
         ("Tutorial Supabase", ":material/storage:", "Tutorial Supabase"),
         ("Tutorial Kaggle", ":material/menu_book:", "Tutorial Kaggle"),
         ("Tutorial Apify", ":material/menu_book:", "Tutorial Apify"),
+        ("Tutorial YouTube Video-Upload Frontend", ":material/video_library:", "Tutorial YouTube Video-Upload Frontend"),
     ]
     settings_items = [
         ("MCP", ":material/hub:", "MCP"),
@@ -6809,6 +6863,7 @@ def main():
         "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,
+        "Tutorial YouTube Video-Upload Frontend": render_youtube_frontend_upload_tutorial,
         "Configurações": lambda: render_edit_placeholder("Configurações", "Seleccione uma opção no menu expansível."),
         "MCP": render_mcp,
         "Contas Google": render_google_accounts,

package/hermes_ui/creative_generation.py

@@ -121,6 +121,46 @@ def channel_context(channel: dict[str, Any], blueprint: dict[str, Any] | None =
     }
 
 
+def generate_video_description(
+    settings: dict[str, Any],
+    channel: dict[str, Any],
+    topic: str,
+    *,
+    title: str = "",
+    tags: list[str] | None = None,
+    language: str = "",
+) -> str:
+    """Generate a concise YouTube description through the configured text LLM pool."""
+    topic = str(topic or "").strip()
+    title = str(title or "").strip()
+    if not topic and not title:
+        raise CreativeGenerationError("É necessário um tópico ou título antes de gerar a descrição do vídeo.")
+    context = channel_context(channel)
+    normalized_tags = [str(item).strip() for item in (tags or []) if str(item).strip()][:15]
+    system = (
+        "És um editor de metadados de YouTube. Cria uma descrição útil, clara e envolvente para o vídeo, "
+        "sem alegações não verificadas, sem clickbait falso e sem mencionar que foi gerada por IA. "
+        "Usa dois parágrafos curtos, inclui um convite natural para subscrever quando apropriado e devolve "
+        "apenas JSON válido com a chave description."
+    )
+    user = json.dumps(
+        {
+            "channel": context,
+            "language": language or context["language"],
+            "topic": topic,
+            "title": title or topic,
+            "tags": normalized_tags,
+            "requirements": {"paragraphs": 2, "max_characters": 1800, "no_unverified_claims": True},
+        },
+        ensure_ascii=False,
+    )
+    result = _chat_json(settings, system, user)
+    description = str(result.get("description") or "").strip()
+    if not description:
+        raise CreativeGenerationError("O provider LLM não devolveu uma descrição válida para o vídeo.")
+    return description[:1800]
+
+
 def generate_topic_for_channel(
     settings: dict[str, Any],
     channel: dict[str, Any],

package/package.json

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

package/seed/references/youtube-video-upload-frontend.md

@@ -0,0 +1,48 @@
+# Tutorial YouTube Video-Upload Frontend
+
+Este tutorial explica como utilizar, de forma responsável, o fluxo **Direct upload** do Thunderbolt para vídeos já concluídos. A rota é uma integração técnica baseada em comportamentos do frontend do YouTube e pode mudar sem aviso. Use-a somente em contas e canais que controla e respeite as políticas aplicáveis do YouTube.
+
+> **Segurança primeiro:** dados de sessão, cookies de autenticação, identificadores de canal e material de credencial são confidenciais. Nunca os copie para conversas, capturas de ecrã, issues, ficheiros versionados ou campos de texto comuns. Configure-os exclusivamente nos campos protegidos da aplicação local.
+
+## 1. Antes de começar
+
+Confirme que o vídeo foi concluído no **Video Backlog** e que o respectivo canal YouTube está seleccionado no Thunderbolt. No formulário de Upload, confirme título, descrição, tags, privacidade, categoria e idioma antes de autorizar qualquer envio.
+
+O Thunderbolt oferece dois percursos distintos: o fluxo oficial, que utiliza a integração de API autorizada, e o fluxo directo, destinado a uma sessão válida e a uma conta controlada pelo utilizador. Estes percursos não devem ser usados para contornar políticas, limites da plataforma ou permissões de canal.
+
+| Elemento | Finalidade | Boa prática |
+| --- | --- | --- |
+| Vídeo | Ficheiro final da tarefa concluída | Verifique duração, áudio, miniatura e legendas antes do envio. |
+| Metadados | Título, descrição, tags, idioma e privacidade | Reveja manualmente antes de publicar. A descrição por IA pode ser editada. |
+| Canal | Destino associado à conta autorizada | Confirme que é o canal correcto, sobretudo em contas com vários canais. |
+| Sessão | Autorização temporária de upload directo | Mantenha-a apenas em armazenamento local protegido e actualize-a quando expirar. |
+
+## 2. Preparar a autenticação de forma segura
+
+No Thunderbolt, abra **Upload > Direct upload** e utilize os controlos de autorização fornecidos pela interface. Complete o procedimento somente no seu navegador e conta YouTube. Não partilhe dados de sessão, cookies, tokens temporários, IDs de canal ou chaves de integração com terceiros.
+
+Se a verificação de saúde indicar sessão expirada, interrompa o envio e renove a autorização pela interface. O sistema deve apresentar o diagnóstico sem mostrar os valores protegidos. Nunca use valores de exemplo ou chaves encontradas em documentos públicos.
+
+## 3. Envio em partes e memória
+
+O envio directo pode transferir o ficheiro em partes, em vez de carregar todo o vídeo para a memória de uma só vez. Esta estratégia é adequada para ficheiros grandes e reduz a pressão de memória no computador. O Thunderbolt mantém o vídeo no armazenamento local e regista apenas o estado e o resultado do processo.
+
+## 4. Executar o envio
+
+Abra **Upload > Conventional upload** para rever os metadados. Utilize **Gerar descrição com IA** apenas quando quiser uma sugestão editorial; o resultado permanece editável. O campo **Idioma** é detectado da tarefa ou canal e é mostrado numa lista suspensa para evitar códigos escritos incorrectamente.
+
+Depois de confirmar o canal, a privacidade e os metadados, seleccione o fluxo de envio apropriado. Um envio publica ou cria conteúdo numa plataforma externa; por isso, o Thunderbolt deve exigir a confirmação explícita do utilizador antes da acção.
+
+## 5. Diagnóstico e manutenção
+
+| Situação | Acção recomendada |
+| --- | --- |
+| Sessão expirada ou não autorizada | Renove a autorização na interface e volte a executar a verificação de saúde. |
+| Canal incorrecto | Cancele antes do envio e seleccione o canal certo. |
+| Falha de rede | Não repita automaticamente sem confirmar se o vídeo foi criado no YouTube Studio. |
+| Metadados incompletos | Corrija título, descrição, tags, idioma ou privacidade no formulário antes de enviar. |
+| Limite ou política da plataforma | Pare o processo e siga as políticas e limites actualmente aplicáveis do YouTube. |
+
+## Referência técnica
+
+O material fornecido pelo utilizador cita o repositório [Nojus10/YouTube-Video-Upload-Frontend-Api](https://github.com/Nojus10/YouTube-Video-Upload-Frontend-Api). O Thunderbolt apresenta este tutorial como orientação de integração segura; não replica segredos, valores de autenticação nem instruções de extracção de credenciais.