@danhachuel/thunderbolt 0.2.59 → 0.2.61

package/app/main.py

@@ -42,7 +42,7 @@ from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdap
 from integrations.postiz import PostizAdapter
 from integrations.upload_routing import OFFICIAL_DAILY_LIMIT, official_upload_count, upload_with_default_route
 from integrations.youtube_direct_upload import YouTubeDirectUploader
-from integrations.youtube_direct_credentials import delete_credentials_document, direct_account_status, document_status, ensure_credentials_document, merge_credentials_document, parse_credentials_document, save_credentials_document, update_credentials_document_session_info
+from integrations.youtube_direct_credentials import delete_credentials_document, direct_account_status, document_status, ensure_credentials_document, load_credentials_document, merge_credentials_document, parse_credentials_document, save_credentials_document, update_credentials_document_session_info
 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.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
@@ -120,6 +120,21 @@ VIDEO_LANGUAGE_OPTIONS = [
     "50 – Hausa",
 ]
 
+# Mantemos estes valores separados para que Criação de Vídeos e Roteiros partilhem
+# exactamente os mesmos selectores sem alterar a lista histórica de idiomas.
+VIDEO_FORMAT_OPTIONS = ["wide", "shorts", "music"]
+VIDEO_CONCATENATION_OPTIONS = ["Random Concatenation (Recommended)", "Sequential Concatenation"]
+VIDEO_TRANSITION_OPTIONS = ["None", "Fade", "Dissolve"]
+VIDEO_ENCODER_OPTIONS = ["Default (Recommended)", "H.264", "H.265"]
+VOICEOVER_MODE_OPTIONS = ["Auto", "Upload", "None"]
+VOICEOVER_SERVICE_OPTIONS = ["Azure TTS V1"]
+VOICEOVER_VOLUME_OPTIONS = ["20%", "40%", "60%", "80%", "100%"]
+VOICEOVER_SPEED_OPTIONS = ["0.5x", "0.75x", "1.0x", "1.25x", "1.5x", "2.0x"]
+BACKGROUND_MUSIC_SOURCE_OPTIONS = ["Ficheiro existente", "Carregar ficheiro", "Criar via Suno API", "Random Background Music", "Sem música"]
+BACKGROUND_MUSIC_VOLUME_OPTIONS = ["0%", "10%", "20%", "30%", "50%", "75%", "100%"]
+SUBTITLE_FONT_OPTIONS = ["MicrosoftYaHeiBold.ttc", "Arial.ttf", "DejaVuSans.ttf"]
+SUBTITLE_POSITION_OPTIONS = ["Bottom (Recommended)", "Top", "Center"]
+
 ensure_storage()
 st.set_page_config(page_title="Thunderbolt", page_icon="T", layout="wide", initial_sidebar_state="expanded")
 
@@ -300,6 +315,101 @@ def voice_catalog(current: str = "") -> list[str]:
     return voices
 
 
+def render_video_generation_settings(prefix: str, *, current_language: str = "") -> dict[str, Any]:
+    """Render the shared MoneyPrinter-style settings and return a serializable payload."""
+    settings: dict[str, Any] = {}
+    st.markdown("### Video Subject Settings")
+    subject_cols = st.columns(2)
+    with subject_cols[0]:
+        settings["video_subject"] = st.text_input(
+            "Video Subject",
+            value=str(st.session_state.get(f"{prefix}_video_subject", "")),
+            key=f"{prefix}_video_subject",
+            placeholder="Ex.: How AI is changing everyday life",
+        )
+        settings["script_language"] = st.selectbox(
+            "Script Language",
+            VIDEO_LANGUAGE_OPTIONS,
+            index=VIDEO_LANGUAGE_OPTIONS.index(current_language) if current_language in VIDEO_LANGUAGE_OPTIONS else 0,
+            key=f"{prefix}_script_language",
+        )
+    with subject_cols[1]:
+        with st.expander("Advanced Script Settings", expanded=False):
+            settings["script_structure_notes"] = st.text_area(
+                "Estrutura e notas opcionais",
+                value=str(st.session_state.get(f"{prefix}_script_structure_notes", "")),
+                key=f"{prefix}_script_structure_notes",
+                height=100,
+                placeholder="Ex.: gancho forte, 6 cenas, narração documental…",
+            )
+        settings["generate_script_with_ai"] = st.checkbox("Generate Script & Keywords with AI", value=True, key=f"{prefix}_generate_script_with_ai")
+    settings["video_script"] = st.text_area(
+        "Video Script (Optional)",
+        value=str(st.session_state.get(f"{prefix}_video_script", "")),
+        key=f"{prefix}_video_script",
+        height=130,
+    )
+    settings["video_keywords"] = st.text_area(
+        "Video Keywords (English, Optional)",
+        value=str(st.session_state.get(f"{prefix}_video_keywords", "")),
+        key=f"{prefix}_video_keywords",
+        height=90,
+    )
+
+    st.markdown("### Video Settings")
+    video_cols = st.columns(2)
+    with video_cols[0]:
+        settings["video_source"] = st.selectbox("Video Source", WIDE_STYLE_OPTIONS, key=f"{prefix}_video_source")
+        if settings["video_source"] == "full_ia":
+            settings["style_ia"] = st.selectbox("Estilo IA", AI_STYLE_OPTIONS, key=f"{prefix}_style_ia")
+        else:
+            settings["style_ia"] = ""
+        settings["video_format"] = st.selectbox("Formato", VIDEO_FORMAT_OPTIONS, key=f"{prefix}_video_format")
+        settings["video_concatenation_mode"] = st.selectbox("Video Concatenation Mode", VIDEO_CONCATENATION_OPTIONS, key=f"{prefix}_video_concatenation")
+        settings["match_visuals_to_script_order"] = st.checkbox("Match Visuals to Script Order", value=False, key=f"{prefix}_match_visuals")
+        settings["video_transition_mode"] = st.selectbox("Video Transition Mode", VIDEO_TRANSITION_OPTIONS, key=f"{prefix}_video_transition")
+    with video_cols[1]:
+        settings["video_aspect_ratio"] = st.selectbox("Video Aspect Ratio", ["Portrait 9:16", "Landscape 16:9", "Square 1:1"], key=f"{prefix}_video_aspect_ratio")
+        settings["maximum_clip_duration"] = st.selectbox("Maximum Clip Duration (seconds)", [3, 5, 8, 10, 15], key=f"{prefix}_maximum_clip_duration")
+        settings["videos_per_run"] = st.selectbox("Videos per Run", list(range(1, 11)), key=f"{prefix}_videos_per_run")
+        settings["video_encoder"] = st.selectbox("Video Encoder", VIDEO_ENCODER_OPTIONS, key=f"{prefix}_video_encoder")
+
+    st.markdown("### Audio Settings")
+    audio_cols = st.columns(2)
+    with audio_cols[0]:
+        settings["voiceover_mode"] = st.radio("Voiceover Mode", VOICEOVER_MODE_OPTIONS, horizontal=True, key=f"{prefix}_voiceover_mode")
+        settings["voiceover_service"] = st.selectbox("Voiceover Service", VOICEOVER_SERVICE_OPTIONS, key=f"{prefix}_voiceover_service")
+        current_voice = str(st.session_state.get(f"{prefix}_voice", ""))
+        voice_options = voice_catalog(current_voice)
+        settings["voice"] = st.selectbox("Voice (match script language)", voice_options, format_func=lambda value: value or "Sem voz seleccionada", key=f"{prefix}_voice")
+        volume_speed_cols = st.columns(2)
+        with volume_speed_cols[0]:
+            settings["voiceover_volume"] = st.selectbox("Voiceover Volume", VOICEOVER_VOLUME_OPTIONS, index=VOICEOVER_VOLUME_OPTIONS.index("100%"), key=f"{prefix}_voiceover_volume")
+        with volume_speed_cols[1]:
+            settings["voiceover_speed"] = st.selectbox("Voiceover Speed", VOICEOVER_SPEED_OPTIONS, index=VOICEOVER_SPEED_OPTIONS.index("1.0x"), key=f"{prefix}_voiceover_speed")
+        st.button("Preview Voice", key=f"{prefix}_preview_voice", disabled=True, help="A pré-visualização de voz será ligada ao provider configurado.")
+    with audio_cols[1]:
+        settings["background_music_source"] = st.selectbox("Background Music Source", BACKGROUND_MUSIC_SOURCE_OPTIONS, index=3, key=f"{prefix}_background_music_source")
+        settings["background_music_volume"] = st.selectbox("Background Music Volume", BACKGROUND_MUSIC_VOLUME_OPTIONS, index=2, key=f"{prefix}_background_music_volume")
+
+    st.markdown("### Subtitle Settings")
+    subtitle_cols = st.columns(2)
+    with subtitle_cols[0]:
+        settings["enable_subtitles"] = st.checkbox("Enable Subtitles", value=True, key=f"{prefix}_enable_subtitles")
+        settings["subtitle_font"] = st.selectbox("Font", SUBTITLE_FONT_OPTIONS, key=f"{prefix}_subtitle_font")
+        settings["subtitle_position"] = st.selectbox("Position", SUBTITLE_POSITION_OPTIONS, key=f"{prefix}_subtitle_position")
+        settings["subtitle_color"] = st.color_picker("Color", "#FFFFFF", key=f"{prefix}_subtitle_color")
+        settings["subtitle_background"] = st.checkbox("Background", value=True, key=f"{prefix}_subtitle_background")
+        settings["subtitle_background_color"] = st.color_picker("Background Color", "#000000", key=f"{prefix}_subtitle_background_color")
+        settings["subtitle_rounded_background"] = st.checkbox("Rounded Background", value=False, key=f"{prefix}_subtitle_rounded_background")
+    with subtitle_cols[1]:
+        settings["subtitle_font_size"] = st.slider("Font Size", min_value=12, max_value=96, value=60, key=f"{prefix}_subtitle_font_size")
+        settings["subtitle_outline"] = st.color_picker("Outline", "#000000", key=f"{prefix}_subtitle_outline")
+        settings["subtitle_outline_width"] = st.slider("Outline Width", min_value=0.0, max_value=5.0, value=1.5, step=0.25, key=f"{prefix}_subtitle_outline_width")
+        st.button("Restore Subtitle Defaults", key=f"{prefix}_restore_subtitle_defaults", disabled=True, help="Os valores predefinidos já estão activos nesta configuração.")
+    return settings
+
+
 def channel_default_options(channel: dict) -> tuple[list[str], dict[str, str], str, list[str], str]:
     """Return synchronised Blueprint and voice options for a channel editor."""
     blueprint_items = blueprint_catalog()
@@ -959,6 +1069,11 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
             )
             mode = {"Canal específico": "single", "Lote no mesmo canal": "same_channel", "Lote geral": "general"}[mode_label]
             selected_one: dict[str, Any] | None = None
+            legacy_language = st.session_state.get("video_language")
+            legacy_language_map = {"Português": "36 – Português (Brasil)", "English": "01 – Inglês", "Español": "41 – Espanhol (LatAm)"}
+            if legacy_language not in VIDEO_LANGUAGE_OPTIONS:
+                st.session_state["video_language"] = legacy_language_map.get(legacy_language, VIDEO_LANGUAGE_OPTIONS[0])
+            generation_settings: dict[str, Any] = {}
             if mode == "general":
                 selected = [str(channel["id"]) for channel in all_channels if channel.get("id")]
                 st.info(f"**Lote geral:** será criada exactamente uma tarefa para cada um dos {len(selected)} canais cadastrados. Cada canal receberá um tema, título e thumbnail próprios; não existe selecção parcial.")
@@ -999,6 +1114,10 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                             st.write(f"**{channel.get('name', 'Canal')}**")
                             st.caption(f"{result.get('niche', '')} · {result.get('angle', '')}")
                             st.text_area("Briefing gerado", value=result.get("topic", ""), key=f"new_video_general_topic_{channel['id']}", height=80)
+                generation_settings = render_video_generation_settings(
+                    "new_video",
+                    current_language=str(st.session_state.get("video_language") or ""),
+                )
             else:
                 if not active_channels:
                     st.warning("Não existem canais activos disponíveis para os modos de canal específico.")
@@ -1006,8 +1125,12 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                 else:
                     selected_one = st.selectbox("Canal", active_channels, format_func=lambda c: c["name"], key="new_video_channel")
                     selected = [selected_one["id"]]
-                    # Intentionally sits between Canal and Estilo wide, as requested.
+                    # Intentionally sits between Canal and the generation settings, as requested.
                     render_channel_blueprint_panel(selected_one)
+                    generation_settings = render_video_generation_settings(
+                        "new_video",
+                        current_language=str(st.session_state.get("video_language") or ""),
+                    )
                 topic = st.text_area(
                     "Tópico ou briefing",
                     value=st.session_state.get("new_video_topic", ""),
@@ -1034,8 +1157,13 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                         meta = st.session_state["new_video_topic_meta"]
                         st.caption(f"Origem: IA · Nicho: {meta.get('niche', '—')} · Ângulo: {meta.get('angle', '—')}")
 
-            wide_style_label = st.selectbox("Estilo wide", WIDE_STYLE_OPTIONS, key="new_video_style_wide")
-            style_ia = st.selectbox("Estilo IA", AI_STYLE_OPTIONS, key="new_video_style_ia") if wide_style_label == "full_ia" else ""
+            if not generation_settings:
+                generation_settings = render_video_generation_settings(
+                    "new_video",
+                    current_language=str(st.session_state.get("video_language") or ""),
+                )
+            wide_style_label = generation_settings["video_source"]
+            style_ia = generation_settings.get("style_ia", "")
             music_path = ""
             music_source = ""
             if wide_style_label == "Apenas Música":
@@ -1162,12 +1290,8 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
 
             with st.form("new_video_form"):
                 quantity = st.number_input("Quantidade", min_value=1, max_value=100, value=1, disabled=mode != "same_channel")
-                legacy_language = st.session_state.get("video_language")
-                legacy_language_map = {"Português": "36 – Português (Brasil)", "English": "01 – Inglês", "Español": "41 – Espanhol (LatAm)"}
-                if legacy_language not in VIDEO_LANGUAGE_OPTIONS:
-                    st.session_state["video_language"] = legacy_language_map.get(legacy_language, VIDEO_LANGUAGE_OPTIONS[0])
-                language = st.selectbox("Idioma", VIDEO_LANGUAGE_OPTIONS, key="video_language")
-                fmt = st.selectbox("Formato", ["wide", "shorts", "music"], key="new_video_format")
+                language = generation_settings["script_language"]
+                fmt = generation_settings["video_format"]
                 submitted = st.form_submit_button("Criar tarefas", type="primary")
             if submitted:
                 style = {"Pexels/Pixabay": "pexels", "full_ia": "full_ia", "Apenas Música": "music"}[wide_style_label]
@@ -1213,8 +1337,8 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                             st.session_state["new_video_general_topics"] = {cid: {"topic": payload["topic"], "topic_source": payload.get("topic_source", "llm")} for cid, payload in payloads.items()}
                     if len(payloads) == len(selected):
                         batch_topic = "Lote geral — um vídeo independente por canal"
-                        channel_payloads = {cid: {**payload, "language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source} for cid, payload in payloads.items()}
-                        batch = create_batch("general", selected, batch_topic, 1, {"language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source, "topic_source": "llm", "channel_payloads": channel_payloads})
+                        channel_payloads = {cid: {**payload, "language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source, "generation_settings": generation_settings} for cid, payload in payloads.items()}
+                        batch = create_batch("general", selected, batch_topic, 1, {"language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source, "generation_settings": generation_settings, "topic_source": "llm", "channel_payloads": channel_payloads})
                         tasks = create_tasks_for_batch(batch)
                         st.success(f"Lote geral {batch['id']} criado com {len(tasks)} tarefas independentes, uma por canal.")
                 else:
@@ -1230,8 +1354,8 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                             except CreativeGenerationError as exc:
                                 st.warning(f"Título/thumbnail automáticos pendentes: {exc} A tarefa será criada com o tópico como título e sem ficheiro de thumbnail.")
                                 payload = {"topic": topic_value, "title": topic_value, "topic_source": "manual", "thumbnail_status": "pending_provider", "thumbnail_variants": [], "thumbnail_variant": {}, "thumbnail_prompt": "", "thumbnail_text": ""}
-                        payload.update({"topic": topic_value, "topic_source": payload.get("topic_source") or ("llm" if st.session_state.get("new_video_topic_meta") else "manual"), "language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source})
-                        batch = create_batch(mode, selected, topic_value, quantity_value, {"language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source, "topic_source": payload.get("topic_source", "manual"), "channel_payloads": {selected[0]: payload}})
+                        payload.update({"topic": topic_value, "topic_source": payload.get("topic_source") or ("llm" if st.session_state.get("new_video_topic_meta") else "manual"), "language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source, "generation_settings": generation_settings})
+                        batch = create_batch(mode, selected, topic_value, quantity_value, {"language": language, "format": fmt, "style_wide": style, "style_ia": style_ia, "music_mode": style == "music", "background_mode": "none" if style == "music" else ("ai" if style == "full_ia" else "stock"), "music_path": music_path, "music_source": music_source, "generation_settings": generation_settings, "topic_source": payload.get("topic_source", "manual"), "channel_payloads": {selected[0]: payload}})
                         tasks = create_tasks_for_batch(batch)
                         st.success(f"Lote {batch['id']} criado com {len(tasks)} tarefa(s). Abra a subaba Vídeos para acompanhar.")
     with videos_tab:
@@ -1295,14 +1419,13 @@ def render_scripts():
             height=120,
             placeholder="Descreva o tema, a mensagem, o conflito ou a ideia musical que o Blueprint deve orientar.",
         )
-        language_options = VIDEO_LANGUAGE_OPTIONS
-        language = st.selectbox("Idioma", language_options, key="script_language")
-        structure_notes = st.text_area(
-            "Estrutura e notas opcionais",
-            key="script_structure_notes",
-            height=90,
-            placeholder="Ex.: 6 cenas, narração documental, refrão repetível, atmosfera sombria…",
+        legacy_script_language = str(st.session_state.get("script_language") or "")
+        script_settings = render_video_generation_settings(
+            "pipeline_scripts",
+            current_language=legacy_script_language if legacy_script_language in VIDEO_LANGUAGE_OPTIONS else "",
         )
+        language = script_settings["script_language"]
+        structure_notes = script_settings["script_structure_notes"]
         generate_col, clear_col = st.columns([1.4, 1])
         with generate_col:
             generate_clicked = st.button("Gerar com IA a partir do Blueprint", type="primary", use_container_width=True, key="generate_script_document")
@@ -1324,6 +1447,7 @@ def render_scripts():
                         channel=selected_channel or {},
                         blueprint=selected_blueprint,
                         structure_notes=structure_notes,
+                        generation_settings=script_settings,
                     )
                 st.session_state["script_draft"] = generated
                 st.session_state["script_draft_title"] = generated["title"]
@@ -1356,6 +1480,7 @@ def render_scripts():
                             "content": draft_content,
                             "document_type": "video_script" if document_type == "Roteiro de vídeo" else "music_lyrics",
                             "language": language,
+                            "generation_settings": script_settings,
                             "channel_id": str((selected_channel or {}).get("id") or ""),
                             "channel_name": str((selected_channel or {}).get("name") or "Documento independente"),
                             "blueprint_id": str(selected_blueprint.get("id") or selected_blueprint_id or ""),
@@ -2446,7 +2571,7 @@ def render_settings():
             account_email_snapshot = str(batch_account.get("email") or "sem e-mail")
             account_label_snapshot = str(batch_account.get("label") or "Canais YouTube")
             ensure_credentials_document(STORAGE, batch_account, settings, channel_state)
-            direct_status = direct_account_status(STORAGE, batch_account)
+            direct_status = direct_account_status(STORAGE, batch_account, settings)
             missing_document_parts = list(direct_status.get("missing_cookies", []))
             if not direct_status.get("has_session_info"):
                 missing_document_parts.append("sessionInfo")
@@ -2553,6 +2678,31 @@ def render_settings():
         if youtube_accounts_missing_document:
             st.info("Contas que ainda precisam de dados no documento: " + ", ".join(youtube_accounts_missing_document))
 
+        st.divider()
+        st.markdown("### INNERTUBE_API_KEY")
+        st.caption("Esta chave pertence à conta Google/YouTube seleccionada e fica guardada na configuração da conta. Não faz parte do documento de cookies/credenciais e não é editada no separador API Keys.")
+        account_key_options = [str(account.get("id")) for account in batch_accounts if account.get("id")]
+        account_key_labels = {str(account.get("id")): f"{account.get('label', 'Canais YouTube')} — {account.get('email', 'sem e-mail')}" for account in batch_accounts if account.get("id")}
+        if account_key_options:
+            with st.form("innertube_api_key_form"):
+                selected_key_account_id = st.selectbox("Conta Google/YouTube", account_key_options, format_func=lambda value: account_key_labels.get(value, value), key="innertube_key_account")
+                selected_key_account = next(account for account in batch_accounts if str(account.get("id")) == selected_key_account_id)
+                current_innertube_api_key = direct_account_status(STORAGE, selected_key_account, settings).get("innertube_api_key", "")
+                innertube_api_key_value = st.text_input("INNERTUBE_API_KEY", value=current_innertube_api_key, type="password", key=f"innertube_api_key_{selected_key_account_id}", help="Chave usada pelo Upload directo desta conta. Guarde-a aqui, separada do documento de cookies.")
+                save_innertube_api_key = st.form_submit_button("Guardar INNERTUBE_API_KEY", type="primary", use_container_width=True)
+            if save_innertube_api_key:
+                selected_key_account["innertube_api_key"] = innertube_api_key_value.strip()
+                selected_key_account.pop("INNERTUBE_API_KEY", None)
+                settings.pop("direct_innertube_api_key", None)
+                settings["youtube_batch_accounts"] = batch_accounts
+                write_json("settings.json", settings)
+                document = load_credentials_document(STORAGE, selected_key_account, settings, channel_state, create=True)
+                save_credentials_document(STORAGE, selected_key_account, document)
+                st.success("INNERTUBE_API_KEY guardada na configuração da conta Google/YouTube, fora do documento de cookies.")
+                st.rerun()
+        else:
+            st.info("Adicione primeiro uma conta Google/YouTube para configurar a INNERTUBE_API_KEY.")
+
         st.divider()
         st.markdown("### Adicionar outra conta Gmail")
         st.caption("Este formulário fica fora dos cartões das contas existentes. A associação de canais não depende da completude deste documento; ela apenas ficará pendente para Upload directo até os campos serem preenchidos.")
@@ -2564,7 +2714,7 @@ def render_settings():
                 new_account_client_id = st.text_input("OAuth Client ID", key="new_batch_account_client_id")
             with add_cols[1]:
                 new_account_client_secret = st.text_input("OAuth Client Secret", type="password", key="new_batch_account_client_secret")
-                new_account_session_info = st.text_input("sessionInfo token desta conta Google", type="password", key="new_batch_account_session_info", help="Token sessionInfo desta conta. Os cookies, INNERTUBE_API_KEY, chunk_size e delegated_session_ids continuam apenas no documento.")
+                new_account_session_info = st.text_input("sessionInfo token desta conta Google", type="password", key="new_batch_account_session_info", help="Token sessionInfo desta conta. Os cookies e delegated_session_ids ficam no documento; a INNERTUBE_API_KEY é configurada no bloco próprio acima.")
                 new_account_document = st.file_uploader("Documento de cookies/credenciais opcional", type=["json"], key="new_batch_account_credentials_document", help="Pode subir agora um JSON completo ou apenas o documento de cookies. Se não subir, será criado um credentials.json padrão vazio.")
             add_account = st.form_submit_button("Adicionar conta Google/YouTube", type="primary", use_container_width=True)
         if add_account:
@@ -2638,10 +2788,6 @@ def render_settings():
                 st.caption("A YouTube Data API Key é uma credencial Google Cloud separada do OAuth. Só é necessária se escolher o método YouTube Data API para consultar métricas oficiais. Não é necessária para Página pública — sem API Key, para autorizar OAuth ou para fazer upload.")
                 youtube_api_key = text_setting("YouTube Data API Key (opcional)", "youtube_api_key", secret=True, help_text="Credencial separada, criada em Google Cloud > APIs e serviços > Credenciais > Chave de API. Não cole aqui o Client ID nem o Client Secret.")
 
-            st.caption("As credenciais e parâmetros do Upload directo — cookies, sessionInfo, INNERTUBE_API_KEY, chunk_size e DELEGATED_SESSION_ID — são lidos exclusivamente do documento JSON por conta Google. Não são editados nesta UI.")
-            direct_innertube_api_key = str(settings.get("direct_innertube_api_key", "") or "")
-            direct_chunk_size = int(settings.get("direct_chunk_size", 262144) or 262144)
-
             with st.expander("Serviço, materiais e rede"):
                 cols = st.columns(2)
                 with cols[0]:
@@ -2792,7 +2938,6 @@ def render_settings():
                     "youtube_client_id": youtube_client_id, "youtube_client_secret": youtube_client_secret,
                     "kaggle_username": kaggle_username.strip(), "kaggle_api_key": kaggle_api_key.strip(), "kaggle_kernel_slug": kaggle_kernel_slug.strip() or "thunderbolt-niche-finder",
                     "apify_api_token": apify_api_token.strip(), "apify_actor_id": apify_actor_id.strip() or DEFAULT_ACTOR_ID, "apify_poll_interval_seconds": int(apify_poll_interval), "apify_run_timeout_seconds": int(apify_run_timeout),
-                    "direct_innertube_api_key": direct_innertube_api_key, "direct_chunk_size": direct_chunk_size,
                     "log_level": log_level, "listen_host": listen_host, "listen_port": listen_port, "video_source": video_source,
                     "endpoint": endpoint, "proxy_http": proxy_http, "proxy_https": proxy_https, "match_materials_to_script": match_materials_to_script,
                     "llm_provider": llm_provider, "openai_api_key": openai_api_key, "openai_base_url": openai_base_url, "openai_model_name": openai_model_name,

package/hermes_ui/domain.py

@@ -154,6 +154,7 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
                 "music_path": payload.get("music_path", options.get("music_path", "")),
                 "music_source": payload.get("music_source", options.get("music_source", "")),
                 "background_mode": payload.get("background_mode", options.get("background_mode", "stock")),
+                "generation_settings": payload.get("generation_settings", options.get("generation_settings", {})),
                 "blueprint_id": payload.get("blueprint_id") or channel.get("default_blueprint_id") or channel.get("blueprint_id", ""),
                 "blueprint_name": payload.get("blueprint_name", ""),
                 "voice": payload.get("voice") or channel.get("default_voice") or channel.get("voice", ""),

package/hermes_ui/script_generation.py

@@ -24,6 +24,7 @@ def generate_script_document(
     channel: dict[str, Any] | None = None,
     blueprint: dict[str, Any] | None = None,
     structure_notes: str = "",
+    generation_settings: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Generate an editable Markdown document from the configured LLM.
 
@@ -38,6 +39,7 @@ def generate_script_document(
 
     channel_context_value = channel_context(channel or {}, blueprint or {})
     blueprint_payload = blueprint or {}
+    generation_settings_payload = generation_settings or {}
     if normalized_type == "video_script":
         output_requirements = {
             "content": "roteiro completo em Markdown, com título, gancho, cenas, narração e indicações visuais/sonoras",
@@ -69,6 +71,7 @@ def generate_script_document(
             "channel": channel_context_value,
             "blueprint": blueprint_payload,
             "structure_notes": structure_notes.strip(),
+            "generation_settings": generation_settings_payload,
             "output_requirements": output_requirements,
         },
         ensure_ascii=False,
@@ -87,5 +90,6 @@ def generate_script_document(
         "blueprint_name": str(blueprint_payload.get("name") or "SEM BLUEPRINT CONFIGURADO"),
         "channel_id": str((channel or {}).get("id") or ""),
         "channel_name": str((channel or {}).get("name") or "Documento independente"),
+        "generation_settings": generation_settings_payload,
         "generated_by": "configured_llm",
     }

package/integrations/youtube_direct_credentials.py

@@ -101,8 +101,7 @@ def parse_credentials_document(content: bytes, filename: str = DIRECT_DOCUMENT_N
         raise ValueError(f"Faltam cookies obrigatórios no documento {filename}: {', '.join(missing)}.")
     if not document["sessionInfo"]:
         raise ValueError(f"Falta sessionInfo no documento {filename}.")
-    if not document["INNERTUBE_API_KEY"]:
-        raise ValueError(f"Falta INNERTUBE_API_KEY no documento {filename}.")
+    # INNERTUBE_API_KEY é configurada separadamente na UI de Contas Google/YouTube.
     return document
 
 
@@ -128,6 +127,20 @@ def _account_session_info(account: dict[str, Any]) -> str:
     return str(account.get("sessionInfo") or account.get("session_info") or account.get("direct_session_info") or "").strip()
 
 
+def account_innertube_api_key(account: dict[str, Any] | None, document: dict[str, Any] | None = None, settings: dict[str, Any] | None = None) -> str:
+    """Return the account-level key; document value is only a legacy migration fallback."""
+    account = account or {}
+    document = document or {}
+    settings = settings or {}
+    return str(
+        account.get("innertube_api_key")
+        or account.get("INNERTUBE_API_KEY")
+        or settings.get("direct_innertube_api_key")
+        or document.get("INNERTUBE_API_KEY")
+        or ""
+    ).strip()
+
+
 def _normalise_document(raw: Any, account: dict[str, Any]) -> dict[str, Any]:
     raw = raw if isinstance(raw, dict) else {}
     cookies = _normalise_pairs(raw.get("cookies", raw))
@@ -187,7 +200,7 @@ def save_credentials_document(storage_root: Path, account: dict[str, Any], docum
         "email": normalised["email"],
         "sessionInfo": normalised["sessionInfo"],
         "cookies": normalised["cookies"],
-        "INNERTUBE_API_KEY": normalised["INNERTUBE_API_KEY"],
+        # INNERTUBE_API_KEY não pertence ao documento de cookies/credenciais.
         "chunk_size": normalised["chunk_size"],
         "delegated_session_ids": normalised["delegated_session_ids"],
     }
@@ -277,7 +290,7 @@ def merge_credentials_document(
 
     The upload may contain only cookies or the full Frontend API document. Existing
     non-empty values are preserved, so uploading cookies never discards sessionInfo,
-    INNERTUBE_API_KEY, chunk_size or delegated channel IDs.
+    chunk_size or delegated channel IDs. INNERTUBE_API_KEY is configured separately.
     """
     try:
         raw = json.loads(content.decode("utf-8-sig", errors="replace"))
@@ -295,8 +308,8 @@ def merge_credentials_document(
     incoming_session = _placeholder_to_empty(session_info_override) or incoming.get("sessionInfo", "")
     if incoming_session:
         merged["sessionInfo"] = incoming_session
-    if incoming.get("INNERTUBE_API_KEY"):
-        merged["INNERTUBE_API_KEY"] = incoming["INNERTUBE_API_KEY"]
+    # INNERTUBE_API_KEY recebida num JSON é deliberadamente ignorada: a fonte oficial
+    # é a configuração separada da secção Contas Google/YouTube.
     if "chunk_size" in raw:
         merged["chunk_size"] = incoming["chunk_size"]
     for key, value in incoming.get("delegated_session_ids", {}).items():
@@ -325,14 +338,16 @@ def document_status(storage_root: Path, account: dict[str, Any], channel: dict[s
     document = load_credentials_document(storage_root, account, settings, channels, create=True)
     missing_cookies = [key for key in COOKIE_KEYS if not document["cookies"].get(key)]
     delegated = delegated_session_id(document, channel or {}) if channel else ""
+    innertube_api_key = account_innertube_api_key(account, document, settings)
     return {
         "document_file": str(path),
         "document_exists": path.exists(),
         "missing_cookies": missing_cookies,
         "has_session_info": bool(document.get("sessionInfo")),
-        "has_innertube_api_key": bool(document.get("INNERTUBE_API_KEY")),
+        "has_innertube_api_key": bool(innertube_api_key),
+        "innertube_api_key": innertube_api_key,
         "has_delegated_session_id": bool(delegated) if channel is not None else None,
-        "ready": not missing_cookies and bool(document.get("sessionInfo")) and bool(document.get("INNERTUBE_API_KEY")) and (channel is None or bool(delegated)),
+        "ready": not missing_cookies and bool(document.get("sessionInfo")) and bool(innertube_api_key) and (channel is None or bool(delegated)),
     }
 
 
@@ -364,9 +379,9 @@ def save_cookie_file(storage_root: Path, account: dict[str, Any], content: bytes
     return destination
 
 
-def direct_account_status(storage_root: Path, account: dict[str, Any]) -> dict[str, Any]:
-    """Backward-compatible account status; the source of truth is credentials.json."""
-    status = document_status(storage_root, account)
+def direct_account_status(storage_root: Path, account: dict[str, Any], settings: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Return account status; cookies stay in credentials.json and the API key is separate."""
+    status = document_status(storage_root, account, settings=settings)
     return {
         "cookie_file": status["document_file"],
         "document_exists": status["document_exists"],
@@ -374,6 +389,7 @@ def direct_account_status(storage_root: Path, account: dict[str, Any]) -> dict[s
         "missing_cookies": status["missing_cookies"],
         "has_session_info": status["has_session_info"],
         "has_innertube_api_key": status["has_innertube_api_key"],
+        "innertube_api_key": status.get("innertube_api_key", ""),
         "ready": status["ready"],
         "document_file": status["document_file"],
     }

package/integrations/youtube_direct_upload.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from integrations.youtube_direct_credentials import COOKIE_KEYS, delegated_session_id, load_credentials_document
+from integrations.youtube_direct_credentials import COOKIE_KEYS, account_innertube_api_key, delegated_session_id, load_credentials_document
 from urllib.parse import quote
 
 import requests
@@ -49,7 +49,8 @@ def _session_info(settings: dict[str, Any], channel: dict[str, Any], account: di
 
 
 def _innertube_api_key(settings: dict[str, Any], channel: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> str:
-    return str(_direct_document(settings, channel, account, storage_root).get("INNERTUBE_API_KEY", "") or "").strip()
+    document = _direct_document(settings, channel, account, storage_root)
+    return account_innertube_api_key(account, document, settings)
 
 
 def _delegated_session(settings: dict[str, Any], channel: dict[str, Any], account: dict[str, Any] | None = None, storage_root: Path | None = None) -> str:
@@ -96,7 +97,7 @@ def validate_direct_upload(video_path: str | Path, channel: dict[str, Any], sett
     if not _session_info(settings, channel, account, storage_root):
         return "Falta sessionInfo no documento de credenciais da conta."
     if not _innertube_api_key(settings, channel, account, storage_root):
-        return "Falta INNERTUBE_API_KEY no documento de credenciais da conta."
+        return "Falta INNERTUBE_API_KEY no cartão da conta Google/YouTube."
     if not _delegated_session(settings, channel, account, storage_root):
         return "Falta DELEGATED_SESSION_ID deste canal no documento de credenciais da conta."
     return None

package/package.json

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