@danhachuel/thunderbolt 0.3.92 → 0.3.94

package/app/main.py

@@ -1969,10 +1969,17 @@ def render_channels():
                 channel_account_ids.append(current_channel_account_id)
                 youtube_account_labels[current_channel_account_id] = "Conta Google não configurada"
             with st.expander("Upload directo — documento da conta deste canal", expanded=False):
-                st.caption("O DELEGATED_SESSION_ID deste canal é individual, mas fica apenas no documento JSON da conta Google. A UI não mostra nem edita esse valor; associe apenas o canal à conta que contém o documento.")
+                st.caption("O DELEGATED_SESSION_ID é individual deste canal. Guarde-o aqui; o valor fica no registo local do canal e não é copiado para o documento JSON partilhado da conta Google.")
                 with st.form(f"channel_direct_credentials_{channel_id}"):
                     channel_account_id = st.selectbox("Conta Google do documento deste canal", channel_account_ids, index=channel_account_ids.index(current_channel_account_id) if current_channel_account_id in channel_account_ids else 0, format_func=lambda item: youtube_account_labels.get(item, item or "Sem conta Google associada"), key=f"channel_account_{channel_id}")
-                    save_channel_direct_credentials = st.form_submit_button("Associar conta Google ao canal", type="primary", use_container_width=True)
+                    channel_delegated_session_id = st.text_input(
+                        "DELEGATED_SESSION_ID deste canal",
+                        value=str(channel.get("delegated_session_id") or ""),
+                        type="password",
+                        key=f"channel_delegated_session_id_{channel_id}",
+                        help="Identificador individual usado pelo Upload directo deste canal. Não é partilhado com outros canais nem mostrado nos diagnósticos.",
+                    )
+                    save_channel_direct_credentials = st.form_submit_button("Guardar conta Google e DELEGATED_SESSION_ID", type="primary", use_container_width=True)
                 selected_channel_account = youtube_accounts_by_id.get(channel_account_id)
                 if selected_channel_account:
                     selected_account_status = document_status(STORAGE, selected_channel_account, channel, settings, channels)
@@ -1992,8 +1999,15 @@ def render_channels():
                 else:
                     st.info("Associe este canal a uma conta Google para validar o documento de credenciais.")
                 if save_channel_direct_credentials:
-                    update_channel(channel_id, {"google_account_id": channel_account_id.strip(), "google_account_email": str(youtube_accounts_by_id.get(channel_account_id, {}).get("email", ""))})
-                    st.success("Conta Google associada ao canal. O DELEGATED_SESSION_ID continua exclusivamente no documento da conta.")
+                    update_channel(
+                        channel_id,
+                        {
+                            "google_account_id": channel_account_id.strip(),
+                            "google_account_email": str(youtube_accounts_by_id.get(channel_account_id, {}).get("email", "")),
+                            "delegated_session_id": channel_delegated_session_id.strip(),
+                        },
+                    )
+                    st.success("Conta Google e DELEGATED_SESSION_ID individual do canal guardados.")
                     st.rerun()
 
             render_channel_videos(channel)
@@ -3562,6 +3576,21 @@ def load_video_tasks_for_catalog() -> list[dict[str, Any]]:
     return [task for task in saved if isinstance(task, dict) and str(task.get("id") or "").strip()]
 
 
+def _is_music_task(task: dict[str, Any]) -> bool:
+    """Identify music pipeline tasks without conflating them with ordinary video tasks."""
+    return bool(task.get("music_mode")) or str(task.get("style_wide") or task.get("style") or "").strip().casefold() in {"music", "música"}
+
+
+def load_music_tasks_for_catalog() -> list[dict[str, Any]]:
+    """Return persisted tasks that were explicitly created through a music route."""
+    return [task for task in load_video_tasks_for_catalog() if _is_music_task(task)]
+
+
+def load_standard_video_tasks_for_catalog() -> list[dict[str, Any]]:
+    """Keep video backlog free of tasks that belong to the dedicated music queue."""
+    return [task for task in load_video_tasks_for_catalog() if not _is_music_task(task)]
+
+
 def _video_task_format(task: dict[str, Any]) -> str:
     value = task.get("format") or task.get("style_wide") or task.get("style") or "wide"
     return str(value).strip() or "wide"
@@ -3608,7 +3637,7 @@ def render_videos():
     st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
     st.caption(f"Os vídeos são guardados em `{STORAGE / 'videos'}`.")
     _render_pipeline_progress_panel()
-    tasks = load_video_tasks_for_catalog()
+    tasks = load_standard_video_tasks_for_catalog()
     if not tasks:
         st.info("Nenhum vídeo criado.")
         return
@@ -3667,6 +3696,64 @@ def render_videos():
                         st.rerun()
 
 
+def render_music_backlog() -> None:
+    """Render the music-only counterpart of Backlog Videos with the same controls."""
+    st.subheader("Music Backlog")
+    st.caption("Acompanhamento das músicas criadas, estados da pipeline e controlos de execução.")
+    st.caption(f"As músicas são guardadas em `{STORAGE / 'music'}`.")
+    _render_pipeline_progress_panel()
+    tasks = load_music_tasks_for_catalog()
+    if not tasks:
+        st.info("Nenhuma música criada.")
+        return
+    known_states = ["to_do", "doing", "blocked", "done", "failed", "cancelled"]
+    extra_states = sorted({str(task.get("state") or "unknown") for task in tasks if str(task.get("state") or "unknown") not in known_states})
+    state_filter = st.selectbox("Filtrar por estado", ["Todos", *known_states, *extra_states], key="music_backlog_state_filter")
+    for task in tasks:
+        if state_filter != "Todos" and task.get("state") != state_filter:
+            continue
+        with st.container(border=True):
+            cols = st.columns([2.2, 1, 1, 1.2, 1.8])
+            with cols[0]:
+                st.write(f"**{task.get('title') or task.get('topic', 'Sem título')}**")
+                st.caption(f"Música: {task.get('music_source') or 'rota musical'}")
+                st.caption(f"{task.get('channel_name')} · {task.get('id')}")
+                music_path = str(task.get("music_path") or (task.get("artifacts") or {}).get("music") or "").strip()
+                if music_path and Path(music_path).is_file():
+                    music_file = Path(music_path)
+                    st.success("Música pronta; pode continuar para o destino configurado.")
+                    st.download_button(
+                        "Descarregar música pronta",
+                        data=music_file.read_bytes(),
+                        file_name=music_file.name,
+                        mime="audio/mpeg",
+                        key=f"music_backlog_download_{task['id']}",
+                        use_container_width=True,
+                    )
+                elif music_path:
+                    st.caption(f"Música registada: {music_path}")
+                else:
+                    st.caption("A música será disponibilizada quando a etapa de geração terminar.")
+            with cols[1]:
+                st.caption("Formato")
+                st.write(_video_task_format(task))
+            with cols[2]:
+                st.write(_pipeline_stage_label(task))
+            with cols[3]:
+                _render_video_task_state(task)
+            with cols[4]:
+                state = str(task.get("state") or "")
+                start_col, stop_col = st.columns(2)
+                with start_col:
+                    if st.button("Start", key=f"music_backlog_start_{task['id']}", use_container_width=True, disabled=state not in {"to_do", "blocked", "failed"}):
+                        transition_task(task["id"], "doing")
+                        st.rerun()
+                with stop_col:
+                    if st.button("Stop", key=f"music_backlog_stop_{task['id']}", use_container_width=True, disabled=state != "doing"):
+                        transition_task(task["id"], "blocked")
+                        st.rerun()
+
+
 def _thumbnail_editor_context(record: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
     """Resolve the persisted task channel/Blueprint without requiring either one to remain registered."""
     channel_id = str(record.get("channel_id") or "").strip()
@@ -6731,6 +6818,7 @@ def main():
     ]
     music_items = [
         ("Criação de Músicas", ":material/music_note:", "Criação de Músicas"),
+        ("Music Backlog", ":material/queue_music:", "Music Backlog"),
         ("Upload Música", ":material/library_music:", "Upload Música"),
     ]
     models_ai_items = [
@@ -6853,6 +6941,7 @@ def main():
         "Criação de Vídeos": render_new_video,
         "Backlog Vídeos": render_videos,
         "Criação de Músicas": render_music_creation,
+        "Music Backlog": render_music_backlog,
         "Upload Música": render_music_upload,
         "Roteiros": render_scripts,
         "Thumbnails": render_thumbnails,

package/integrations/youtube_direct_credentials.py

@@ -363,6 +363,9 @@ def merge_credentials_document(
 
 
 def delegated_session_id(document: dict[str, Any], channel: dict[str, Any]) -> str:
+    channel_value = str(channel.get("delegated_session_id") or "").strip() if isinstance(channel, dict) else ""
+    if channel_value:
+        return channel_value
     mapping = document.get("delegated_session_ids", {}) if isinstance(document, dict) else {}
     if not isinstance(mapping, dict):
         return ""

package/package.json

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