@danhachuel/thunderbolt 0.4.44 → 0.4.46

package/app/main.py

@@ -80,10 +80,11 @@ 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_description, 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, generate_video_update_metadata
 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
+from integrations.youtube_update import YOUTUBE_UPDATE_VIDEO, YouTubeVideoUpdater
 from integrations.postiz import PostizAdapter
 from integrations.upload_post import UploadPostAdapter, UPLOAD_POST_PLATFORM_OPTIONS, normalize_upload_post_platforms
 from integrations.bilibili_upload import BilibiliApiAdapter, BILIBILI_DEFAULT_TID, BILIBILI_VIDEO_EXTENSIONS, normalise_bilibili_api_cards
@@ -1931,7 +1932,7 @@ def render_tiktok_channels():
                 description = st.text_area("Descrição", value=str(imported.get("bio") or ""), key="tiktok_import_description")
                 if st.form_submit_button("Cadastrar canal TikTok", type="primary"):
                     channel = create_channel(name.strip(), url.strip(), {"platform": "tiktok", "handle": handle.strip(), "language": language, "niche": niche.strip(), "description": description.strip(), "default_prompt_master": prompt, "prompt_master": prompt, "style_wide": "portrait", "video_aspect_ratio": "Portrait 9:16", "metrics_source": "tiktok_public_page", "subscriber_count": imported.get("subscriber_count"), "video_count": imported.get("video_count")})
-                    update_channel(channel["id"], {"platform": "tiktok", "default_prompt_master": prompt, "prompt_master": prompt})
+                    update_channel(channel["id"], {"platform": "tiktok", "default_prompt_master": prompt, "prompt_master": prompt, "avatar_url": imported.get("avatar_url") or imported.get("avatar") or "", "thumbnail_url": imported.get("avatar_url") or imported.get("avatar") or ""})
                     st.session_state.pop("tiktok_channel_import", None)
                     st.success(f"Canal {channel['name']} cadastrado.")
                     st.rerun()
@@ -4589,7 +4590,13 @@ def render_thumbnails():
 
 def render_tiktok_automation():
     st.title("Automação Tiktok")
-    st.caption("Fila exclusiva de Shorts TikTok em Portrait 9:16, usando Prompt Master em vez de Blueprint.")
+    st.caption("Agendamento diário da geração por canal. A fila TikTok usa Prompt Master e mantém exclusivamente o formato Portrait 9:16.")
+    worker_status = load_worker_status()
+    local_now = datetime.now().astimezone()
+    if worker_status.get("alive"):
+        st.success(f"Worker activo · relógio local: {local_now.strftime('%d/%m/%Y %H:%M:%S %Z')}")
+    else:
+        st.warning("Worker de automação não está activo. Inicie o Thunderbolt pelo launcher (`npx.cmd --yes @danhachuel/thunderbolt`) para activar as verificações horárias.")
     channels = _tiktok_channel_records()
     prompt_ids, prompt_labels = _tiktok_prompt_options()
     if not channels:
@@ -4598,18 +4605,43 @@ def render_tiktok_automation():
     for channel in channels:
         channel_id = str(channel["id"])
         with st.container(border=True):
-            st.write(f"**{channel.get('name', 'Sem nome')}** · {channel.get('handle', '')}")
-            enabled = st.toggle("Automação ligada", value=bool(channel.get("automation_on", False)), key=f"tiktok_automation_on_{channel_id}")
-            schedule_time = st.text_input("Horário diário (HH:MM)", value=channel.get("automation_time", "00:00"), key=f"tiktok_automation_time_{channel_id}")
-            prompt = st.selectbox("Prompt Master padrão", prompt_ids, index=prompt_ids.index(channel.get("default_prompt_master", "")) if channel.get("default_prompt_master", "") in prompt_ids else 0, format_func=lambda item: prompt_labels.get(item, item), key=f"tiktok_automation_prompt_{channel_id}")
-            st.caption("Formato da fila: Portrait 9:16 · Pool de vídeo: TikTok")
-            if st.button("Guardar automação TikTok", key=f"tiktok_automation_save_{channel_id}", type="primary"):
-                if not valid_hhmm(schedule_time):
-                    st.error("Use o formato HH:MM, por exemplo 08:30.")
+            header_cols = st.columns([0.55, 2.35, 1.35, 1.5, 1.35])
+            with header_cols[0]:
+                profile_image = channel.get("avatar_url") or channel.get("thumbnail_url")
+                if profile_image:
+                    st.image(profile_image, width=48)
                 else:
-                    update_channel(channel_id, {"automation_on": bool(enabled), "automation_time": schedule_time.strip(), "default_prompt_master": prompt, "prompt_master": prompt, "platform": "tiktok", "video_aspect_ratio": "Portrait 9:16"})
-                    st.success("Automação TikTok guardada.")
-                    st.rerun()
+                    st.markdown("### TT")
+            with header_cols[1]:
+                st.write(f"**{channel.get('name', 'Sem nome')}**")
+                st.caption(channel.get("handle") or channel.get("url") or "sem URL")
+            with header_cols[2]:
+                enabled = st.toggle("Automação ligada", value=bool(channel.get("automation_on", False)), key=f"tiktok_automation_on_{channel_id}")
+            with header_cols[3]:
+                schedule_time = st.text_input("Horário (HH:MM)", value=channel.get("automation_time", "00:00"), key=f"tiktok_automation_time_{channel_id}")
+            default_cols = st.columns([1.0, 1.0, 1.35, 1.45, 1.55, 1.0], gap="small")
+            with default_cols[0]:
+                st.markdown("**Idioma Padrão**")
+                st.caption(language_label(channel.get("language") or "pt"))
+            with default_cols[1]:
+                st.markdown("**Nicho Padrão**")
+                st.caption(channel_niche_label(channel))
+            with default_cols[2]:
+                st.markdown("**Formato da fila**")
+                st.caption("Portrait 9:16")
+            with default_cols[3]:
+                prompt = st.selectbox("Prompt Master Padrão", prompt_ids, index=prompt_ids.index(channel.get("default_prompt_master", "")) if channel.get("default_prompt_master", "") in prompt_ids else 0, format_func=lambda item: prompt_labels.get(item, item), key=f"tiktok_automation_prompt_{channel_id}")
+            with default_cols[4]:
+                st.markdown("**Pool de vídeos**")
+                st.caption("TikTok / Shorts")
+            with default_cols[5]:
+                if st.button("Guardar", key=f"tiktok_automation_save_{channel_id}", use_container_width=True, type="primary"):
+                    if not valid_hhmm(schedule_time):
+                        st.error("Use o formato HH:MM, por exemplo 08:30.")
+                    else:
+                        update_channel(channel_id, {"automation_on": bool(enabled), "automation_time": schedule_time.strip(), "default_prompt_master": prompt, "prompt_master": prompt, "platform": "tiktok", "video_aspect_ratio": "Portrait 9:16"})
+                        st.success("Automação TikTok guardada.")
+                        st.rerun()
 
 
 def render_automation():
@@ -7559,6 +7591,94 @@ def render_metadata_cleaner():
                 st.download_button("Descarregar", data=output.read_bytes(), file_name=output.name, mime="video/*", key=f"metadata_history_{record.get('id')}")
 
 
+def render_update_youtube_videos():
+    st.title("Update Youtube Vídeos")
+    st.caption("Actualize título, descrição e thumbnail de vídeos publicados sem alterar o ficheiro de vídeo.")
+    settings = read_json("settings.json", {})
+    channels = [channel for channel in read_json("channels.json", []) if isinstance(channel, dict) and channel.get("platform", "youtube") != "tiktok" and channel.get("active", True)]
+    if not channels:
+        st.info("Cadastre pelo menos um canal YouTube activo antes de actualizar vídeos.")
+        return
+    channel = st.selectbox("Canal YouTube", channels, format_func=lambda item: item.get("name") or item.get("url") or "Canal sem nome", key="update_youtube_channel")
+    updater = YouTubeVideoUpdater(settings, STORAGE)
+    refresh_key = f"update_youtube_loaded_{channel.get('id', '')}"
+    if st.button("Carregar vídeos do canal", type="primary", use_container_width=True, key="update_youtube_load") or refresh_key not in st.session_state:
+        with st.spinner("A carregar vídeos publicados…"):
+            result = updater.list_videos(channel, max_results=50)
+        st.session_state[refresh_key] = result.data if result.ok else {"error": result.message, "videos": []}
+    loaded = st.session_state.get(refresh_key, {})
+    if loaded.get("error"):
+        st.error(loaded["error"])
+        return
+    videos = loaded.get("videos", [])
+    st.caption(f"{len(videos)} vídeo(s) carregado(s). Operação: `{YOUTUBE_UPDATE_VIDEO}`")
+    if not videos:
+        st.info("Não foram encontrados vídeos publicados para este canal.")
+        return
+    tasks = load_video_tasks_for_catalog()
+    blueprint = blueprint_for_channel(channel)
+    for video in videos:
+        video_id = str(video.get("id") or "")
+        card_key = f"update_youtube_{video_id}"
+        with st.container(border=True):
+            top = st.columns([1.2, 3.8, 1.2])
+            with top[0]:
+                if video.get("thumbnail_url"):
+                    st.image(video["thumbnail_url"], use_container_width=True)
+            with top[1]:
+                st.markdown(f"**{video.get('title') or 'Sem título'}**")
+                st.caption(f"{video.get('published_at') or 'Data indisponível'} · {video.get('privacy_status') or 'estado desconhecido'} · `{video_id}`")
+                st.markdown(f"[Abrir no YouTube]({video.get('url')})")
+            with top[2]:
+                st.caption("Alteração")
+                st.write("Metadados")
+                st.write("Sem alteração do vídeo")
+            title_key, desc_key = f"{card_key}_title", f"{card_key}_description"
+            title = st.text_input("Título", value=st.session_state.get(title_key, video.get("title", "")), key=title_key, max_chars=100)
+            description = st.text_area("Descrição", value=st.session_state.get(desc_key, video.get("description", "")), key=desc_key, height=150)
+            ai_cols = st.columns(3)
+            script = next((str(task.get("script") or task.get("video_script") or "") for task in tasks if str(task.get("youtube_video_id") or task.get("video_id") or "") == video_id), "")
+            with ai_cols[0]:
+                if st.button("Gerar título", key=f"{card_key}_ai_title", use_container_width=True):
+                    try:
+                        generated = generate_video_update_metadata(settings, channel, video, script=script, blueprint=blueprint, mode="title")
+                        st.session_state[title_key] = generated["title"]
+                        st.rerun()
+                    except CreativeGenerationError as exc:
+                        st.error(str(exc))
+            with ai_cols[1]:
+                if st.button("Gerar descrição", key=f"{card_key}_ai_description", use_container_width=True):
+                    try:
+                        generated = generate_video_update_metadata(settings, channel, video, script=script, blueprint=blueprint, mode="description")
+                        st.session_state[desc_key] = generated["description"]
+                        st.rerun()
+                    except CreativeGenerationError as exc:
+                        st.error(str(exc))
+            with ai_cols[2]:
+                if st.button("Gerar título e descrição", key=f"{card_key}_ai_both", use_container_width=True):
+                    try:
+                        generated = generate_video_update_metadata(settings, channel, video, script=script, blueprint=blueprint, mode="both")
+                        st.session_state[title_key] = generated.get("title", title)
+                        st.session_state[desc_key] = generated.get("description", description)
+                        st.rerun()
+                    except CreativeGenerationError as exc:
+                        st.error(str(exc))
+            thumbnail = st.file_uploader("Trocar thumbnail (opcional)", type=["jpg", "jpeg", "png"], key=f"{card_key}_thumbnail")
+            if st.button("Actualizar no YouTube", type="primary", key=f"{card_key}_save", use_container_width=True):
+                thumbnail_path = None
+                if thumbnail is not None:
+                    thumbnail_path = STORAGE / "youtube_update" / f"{video_id}_{thumbnail.name}"
+                    thumbnail_path.parent.mkdir(parents=True, exist_ok=True)
+                    thumbnail_path.write_bytes(thumbnail.getvalue())
+                result = updater.update_video(video, title=title, description=description, thumbnail_path=thumbnail_path)
+                if result.ok:
+                    st.success(f"{result.message} Campos: {', '.join(result.data.get('changed') or []) or 'nenhum'}.")
+                    st.session_state.pop(refresh_key, None)
+                    st.rerun()
+                else:
+                    st.error(result.message)
+
+
 def render_pipeline():
     st.title("Pipeline Vídeos")
     st.caption("Estado das filas locais e dependências da cascata")
@@ -7581,6 +7701,7 @@ def main():
         ("Roteiros", ":material/article:", "Roteiros"),
         ("Thumbnails", ":material/image:", "Thumbnails"),
         ("Upload", ":material/cloud_upload:", "Upload"),
+        ("Update Youtube Vídeos", ":material/edit_note:", "Update Youtube Vídeos"),
     ]
     channel_profile_items = [
         ("Canais YouTube", ":material/ondemand_video:", "Canais YouTube"),
@@ -7668,7 +7789,7 @@ def main():
     nav_paths = {
         "Início": "/inicio", "Automação": "/automacao", "Automação Youtube": "/automacao/youtube", "Automação Tiktok": "/automacao/tiktok",
         "Niche Finder": "/niche-finder", "Niche Finder Kaggle": "/niche-finder/kaggle", "Niche Finder Apify": "/niche-finder/apify",
-        "Pipeline Vídeos": "/pipeline-videos", "Criação de Vídeos": "/pipeline-videos/criacao", "Criação de Shorts": "/pipeline-videos/shorts", "Backlog Vídeos": "/pipeline-videos/backlog", "Roteiros": "/pipeline-videos/roteiros", "Thumbnails": "/pipeline-videos/thumbnails", "Upload": "/pipeline-videos/upload",
+        "Pipeline Vídeos": "/pipeline-videos", "Criação de Vídeos": "/pipeline-videos/criacao", "Criação de Shorts": "/pipeline-videos/shorts", "Backlog Vídeos": "/pipeline-videos/backlog", "Roteiros": "/pipeline-videos/roteiros", "Thumbnails": "/pipeline-videos/thumbnails", "Upload": "/pipeline-videos/upload", "Update Youtube Vídeos": "/pipeline-videos/update-youtube",
         "Pipeline Música": "/pipeline-musica", "Criação de Músicas": "/pipeline-musica/criacao", "Music Backlog": "/pipeline-musica/backlog", "Vozes Personalizadas": "/pipeline-musica/vozes-personalizadas", "Upload Música": "/pipeline-musica/upload",
         "Canais/Perfis (Vídeos)": "/canais-perfis-videos", "Canais YouTube": "/canais-perfis-videos/canais-youtube", "Canais Tiktok": "/canais-perfis-videos/canais-tiktok", "Blueprints Youtube": "/canais-perfis-videos/blueprints-youtube", "Thumbnail Blueprints": "/canais-perfis-videos/thumbnail-blueprints", "Brandings Youtube": "/canais-perfis-videos/brandings-youtube", "Contas TikTok": "/canais-perfis-videos/contas-tiktok", "Prompt Masters": "/canais-perfis-videos/prompt-masters", "Facebook Pages": "/canais-perfis-videos/facebook-pages",
         "AI Influencers": "/ai-influencers", "Personagens": "/ai-influencers/personagens", "Geração de Conteúdo IA": "/ai-influencers/geracao-conteudo", "Motion Control": "/ai-influencers/motion-control", "UGC Products": "/ai-influencers/ugc-products", "Redes Sociais": "/ai-influencers/redes-sociais",
@@ -7755,6 +7876,7 @@ def main():
         "Roteiros": render_scripts,
         "Thumbnails": render_thumbnails,
         "Upload": render_upload,
+        "Update Youtube Vídeos": render_update_youtube_videos,
         "Blueprints Youtube": render_blueprints,
         "Thumbnail Blueprints": render_thumbnail_blueprints,
         "Brandings Youtube": render_youtube_brandings,

package/hermes_ui/creative_generation.py

@@ -599,3 +599,44 @@ def generate_ugc_segment_prompts(settings: dict[str, Any], instructions: str) ->
     except CreativeGenerationError:
         pass
     return _ugc_fallback_prompts(clean)
+
+
+def generate_video_update_metadata(
+    settings: dict[str, Any],
+    channel: dict[str, Any],
+    video: dict[str, Any],
+    *,
+    script: str = "",
+    blueprint: dict[str, Any] | None = None,
+    mode: str = "both",
+) -> dict[str, str]:
+    """Generate reviewed metadata for an already-published YouTube video."""
+    context = channel_context(channel, blueprint)
+    language_instruction = _language_instruction(video.get("default_language") or channel.get("language") or context["language"])
+    fields = {"title": "title", "description": "description"} if mode == "both" else {mode: mode}
+    system = (
+        "És um editor de metadados de YouTube. Gera apenas os campos solicitados em JSON válido. "
+        f"Escreve todos os campos em {language_instruction}. Mantém o tema, o roteiro e o nicho do canal, "
+        "evita clickbait falso, alegações não verificadas e menções a IA. O título deve ser claro e ter no máximo 100 caracteres; "
+        "a descrição deve ser natural, informativa e preservar factos fornecidos no roteiro."
+    )
+    user = json.dumps({
+        "requested_fields": list(fields.values()),
+        "channel": context,
+        "video": {"id": video.get("id"), "title": video.get("title", ""), "description": video.get("description", ""), "language": video.get("default_language", "")},
+        "script": str(script or "")[:12000],
+        "requirements": {"title_max_characters": 100, "description_max_characters": 1800},
+    }, ensure_ascii=False)
+    result = _chat_json(settings, system, user)
+    output: dict[str, str] = {}
+    if "title" in fields:
+        title = str(result.get("title") or "").strip()[:100]
+        if not title:
+            raise CreativeGenerationError("O provider não devolveu um título válido.")
+        output["title"] = title
+    if "description" in fields:
+        description = str(result.get("description") or "").strip()[:1800]
+        if not description:
+            raise CreativeGenerationError("O provider não devolveu uma descrição válida.")
+        output["description"] = description
+    return output

package/hermes_ui/domain.py

@@ -39,6 +39,7 @@ def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = N
         "niche": "",
         "reference_channels": [],
         "thumbnail_url": "",
+        "avatar_url": "",
         "subscriber_count": None,
         "video_count": None,
         "view_count": None,

package/integrations/youtube_update.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from integrations.platforms import IntegrationResult
+from integrations.youtube_upload import AGENT_SCOPES, YouTubeAutomationAgentUploader, _path_value
+
+YOUTUBE_UPDATE_VIDEO = "YOUTUBE_UPDATE_VIDEO"
+
+
+def _channel_id(channel: dict[str, Any]) -> str:
+    value = str(channel.get("youtube_channel_id") or channel.get("youtube_id") or "").strip()
+    if value.startswith("UC"):
+        return value
+    match = re.search(r"(?:/channel/)(UC[A-Za-z0-9_-]+)", str(channel.get("url") or ""))
+    return match.group(1) if match else ""
+
+
+class YouTubeVideoUpdater(YouTubeAutomationAgentUploader):
+    """Official OAuth adapter for metadata-only YouTube updates."""
+
+    def list_videos(self, channel: dict[str, Any], *, page_token: str = "", max_results: int = 25) -> IntegrationResult:
+        channel_id = _channel_id(channel)
+        if not channel_id:
+            return IntegrationResult(False, "Este canal não tem um YouTube channel ID. Actualize o cadastro do canal antes de listar vídeos.", {"operation": YOUTUBE_UPDATE_VIDEO, "videos": []})
+        try:
+            credentials = self._load_credentials()
+            if credentials is None:
+                return IntegrationResult(False, "Autorize primeiro a conta YouTube para listar vídeos.", {"operation": YOUTUBE_UPDATE_VIDEO, "videos": []})
+            youtube = self._build_client(credentials)
+            channel_response = youtube.channels().list(part="contentDetails", id=channel_id).execute()
+            items = channel_response.get("items") or []
+            if not items:
+                return IntegrationResult(False, "O canal YouTube não foi encontrado para esta conta autorizada.", {"operation": YOUTUBE_UPDATE_VIDEO, "videos": []})
+            uploads_id = ((items[0].get("contentDetails") or {}).get("relatedPlaylists") or {}).get("uploads")
+            if not uploads_id:
+                return IntegrationResult(False, "Não foi possível localizar a playlist de uploads do canal.", {"operation": YOUTUBE_UPDATE_VIDEO, "videos": []})
+            ids: list[str] = []
+            next_token = page_token or ""
+            while True:
+                playlist = youtube.playlistItems().list(part="snippet,contentDetails", playlistId=uploads_id, maxResults=max(1, min(50, int(max_results))), pageToken=next_token).execute()
+                ids.extend(str((item.get("contentDetails") or {}).get("videoId") or "") for item in playlist.get("items", []))
+                next_token = str(playlist.get("nextPageToken") or "")
+                if not next_token:
+                    break
+            ids = [item for item in ids if item]
+            if not ids:
+                return IntegrationResult(True, "Nenhum vídeo encontrado neste canal.", {"operation": YOUTUBE_UPDATE_VIDEO, "videos": [], "next_page_token": ""})
+            details = youtube.videos().list(part="snippet,status,contentDetails", id=",".join(ids)).execute()
+            videos = []
+            for item in details.get("items", []):
+                snippet = item.get("snippet") or {}
+                videos.append({
+                    "id": item.get("id", ""),
+                    "title": snippet.get("title", ""),
+                    "description": snippet.get("description", ""),
+                    "category_id": snippet.get("categoryId", "22"),
+                    "default_language": snippet.get("defaultLanguage") or snippet.get("defaultAudioLanguage") or channel.get("language") or "pt",
+                    "published_at": snippet.get("publishedAt", ""),
+                    "channel_id": snippet.get("channelId", channel_id),
+                    "thumbnail_url": ((snippet.get("thumbnails") or {}).get("high") or (snippet.get("thumbnails") or {}).get("default") or {}).get("url", ""),
+                    "privacy_status": (item.get("status") or {}).get("privacyStatus", ""),
+                    "url": f"https://www.youtube.com/watch?v={item.get('id', '')}",
+                })
+            return IntegrationResult(True, f"{len(videos)} vídeo(s) carregado(s).", {"operation": YOUTUBE_UPDATE_VIDEO, "videos": videos, "next_page_token": ""})
+        except Exception as exc:
+            return IntegrationResult(False, f"Falha ao listar vídeos YouTube: {exc}", {"operation": YOUTUBE_UPDATE_VIDEO, "videos": []})
+
+    def update_video(self, video: dict[str, Any], *, title: str, description: str, thumbnail_path: str | Path | None = None) -> IntegrationResult:
+        video_id = str(video.get("id") or "").strip()
+        if not video_id:
+            return IntegrationResult(False, "Vídeo sem videoId; a actualização foi recusada.", {"operation": YOUTUBE_UPDATE_VIDEO})
+        title = str(title or "").strip()
+        description = str(description or "")
+        if not title:
+            return IntegrationResult(False, "O título não pode ficar vazio.", {"operation": YOUTUBE_UPDATE_VIDEO, "video_id": video_id})
+        changed: list[str] = []
+        try:
+            credentials = self._load_credentials()
+            if credentials is None:
+                return IntegrationResult(False, "Autorize primeiro a conta YouTube.", {"operation": YOUTUBE_UPDATE_VIDEO, "video_id": video_id})
+            youtube = self._build_client(credentials)
+            current_category = str(video.get("category_id") or "22")
+            body = {"id": video_id, "snippet": {"title": title[:100], "description": description, "categoryId": current_category}}
+            if title != str(video.get("title") or "") or description != str(video.get("description") or ""):
+                youtube.videos().update(part="snippet", body=body).execute()
+                if title != str(video.get("title") or ""):
+                    changed.append("title")
+                if description != str(video.get("description") or ""):
+                    changed.append("description")
+            thumbnail = _path_value(thumbnail_path)
+            if thumbnail:
+                if not thumbnail.exists() or not thumbnail.is_file():
+                    return IntegrationResult(False, "A thumbnail seleccionada não existe.", {"operation": YOUTUBE_UPDATE_VIDEO, "video_id": video_id, "changed": changed})
+                with thumbnail.open("rb") as handle:
+                    youtube.thumbnails().set(videoId=video_id, media_body=handle).execute()
+                changed.append("thumbnail")
+            return IntegrationResult(True, "Vídeo actualizado sem alterar o ficheiro de vídeo.", {"operation": YOUTUBE_UPDATE_VIDEO, "video_id": video_id, "changed": changed, "url": f"https://www.youtube.com/watch?v={video_id}"})
+        except Exception as exc:
+            return IntegrationResult(False, f"Falha ao actualizar o vídeo YouTube: {exc}", {"operation": YOUTUBE_UPDATE_VIDEO, "video_id": video_id, "changed": changed})
+
+
+def update_youtube_video(settings: dict[str, Any], channel: dict[str, Any], video: dict[str, Any], *, title: str, description: str, thumbnail_path: str | Path | None = None) -> IntegrationResult:
+    updater = YouTubeVideoUpdater(settings, Path(__file__).resolve().parents[1] / "storage")
+    return updater.update_video(video, title=title, description=description, thumbnail_path=thumbnail_path)

package/package.json

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