@danhachuel/thunderbolt 0.2.90 → 0.2.92

package/app/main.py

@@ -216,9 +216,20 @@ st.markdown("""
 
 
 def current_ui_language() -> str:
-    settings = read_json("settings.json", {})
-    stored = st.session_state.get("ui_language") or settings.get("ui_language") or "pt"
-    normalized = language_code(stored)
+    """Return the session language without hitting disk on every widget render."""
+    cached = st.session_state.get("ui_language")
+    if cached:
+        return language_code(cached)
+    requested = ""
+    try:
+        requested = str(st.query_params.get("lang") or "").strip()
+    except Exception:
+        requested = ""
+    if requested:
+        normalized = language_code(requested)
+    else:
+        settings = read_json("settings.json", {})
+        normalized = language_code(settings.get("ui_language") or "pt")
     st.session_state["ui_language"] = normalized
     return normalized
 
@@ -235,7 +246,7 @@ _STREAMLIT_I18N_INSTALLED = False
 def _translate_streamlit_arguments(method_name: str, args: tuple[Any, ...], kwargs: dict[str, Any]) -> tuple[tuple[Any, ...], dict[str, Any]]:
     if not args and "label" not in kwargs:
         return args, kwargs
-    selected_language = current_ui_language()
+    selected_language = str(st.session_state.get("ui_language") or current_ui_language())
     translated_args = list(args)
     if translated_args and isinstance(translated_args[0], str):
         translated_args[0] = ui_text(translated_args[0], selected_language)
@@ -339,6 +350,10 @@ def render_ui_language_picker(language: str) -> None:
         )
     if selected != current:
         save_ui_language(selected)
+        try:
+            st.query_params["lang"] = selected
+        except Exception:
+            pass
         st.rerun()
 
 
@@ -1718,13 +1733,16 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                 if st.button("Gerar títulos e thumbnails com IA", key="new_video_generate_creative", use_container_width=True):
                     if selected_one is None:
                         st.error("Seleccione primeiro um canal.")
-                    elif not topic_for_creative:
-                        st.error("Escreva ou gere primeiro um tópico/briefing.")
                     else:
                         try:
-                            generated = generate_creative_for_ui(read_json("settings.json", {}), selected_one, topic_for_creative, topic_source="llm" if st.session_state.get("new_video_topic_meta") else "manual")
+                            if not topic_for_creative:
+                                topic_result = generate_topic_for_ui(read_json("settings.json", {}), selected_one)
+                                topic_for_creative = str(topic_result["topic"]).strip()
+                                st.session_state["new_video_topic"] = topic_for_creative
+                                st.session_state["new_video_topic_meta"] = topic_result
+                            generated = generate_creative_for_ui(read_json("settings.json", {}), selected_one, topic_for_creative, topic_source="llm")
                             st.session_state["new_video_creative_payload"] = generated
-                            st.success("Título e thumbnails gerados; escolha a variante antes de criar as tarefas.")
+                            st.success("Tema, título e thumbnails gerados; escolha a variante antes de criar as tarefas.")
                             st.rerun()
                         except CreativeGenerationError as exc:
                             st.error(str(exc))
@@ -1825,9 +1843,18 @@ def render_new_video(page_title: str = "Criação de Vídeos"):
                         st.success(f"Lote geral {batch['id']} criado com {len(tasks)} tarefas independentes, uma por canal.")
                 else:
                     topic_value = str(st.session_state.get("new_video_topic", "") or "").strip()
-                    if not topic_value or not selected:
-                        st.error("Escreva ou gere um tópico e seleccione um canal.")
+                    if not selected:
+                        st.error("Seleccione um canal.")
                     else:
+                        if not topic_value:
+                            try:
+                                topic_result = generate_topic_for_ui(read_json("settings.json", {}), selected_one or {})
+                                topic_value = str(topic_result["topic"]).strip()
+                                st.session_state["new_video_topic"] = topic_value
+                                st.session_state["new_video_topic_meta"] = topic_result
+                            except CreativeGenerationError as exc:
+                                st.error(f"Não foi possível gerar automaticamente o tema: {exc}")
+                                st.stop()
                         quantity_value = int(quantity if mode == "same_channel" else 1)
                         payload = dict(st.session_state.get("new_video_creative_payload") or {})
                         if not payload.get("title") or not payload.get("thumbnail_variants"):
@@ -3169,7 +3196,8 @@ def render_upload_conventional():
                 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]:
-                    privacy_status = st.selectbox("Privacidade", ["private", "unlisted", "public"], key=f"yt_privacy_{task['id']}")
+                    privacy_status = st.selectbox("Privacidade", ["private", "unlisted", "public"], index=1, key=f"yt_privacy_{task['id']}")
+                    st.caption("Fluxo recomendado: não listado · incorporação activa · permitir remix de áudio e vídeo · publicar no feed de subscritos.")
                 with yt_cols[1]:
                     category_id = st.text_input("Category ID", value="22", key=f"yt_category_{task['id']}")
                 with yt_cols[2]:

package/hermes_ui/creative_generation.py

@@ -178,6 +178,17 @@ def _short_overlay(value: Any) -> str:
     return " ".join(words[:4])
 
 
+def _keywords_from_text(*values: str) -> list[str]:
+    """Build a small deterministic keyword fallback when the LLM omits keywords."""
+    blocked = {"para", "como", "sobre", "mais", "esse", "esta", "that", "this", "with", "from", "video"}
+    result: list[str] = []
+    for value in values:
+        for word in re.findall(r"[\wÀ-ÿ]{4,}", str(value or "").casefold(), flags=re.UNICODE):
+            if word not in blocked and word not in result:
+                result.append(word)
+    return result[:15]
+
+
 def generate_creative_package(
     settings: dict[str, Any],
     channel: dict[str, Any],
@@ -194,7 +205,7 @@ def generate_creative_package(
         "O título deve carregar keywords no início, ter curiosidade, especificidade e emoção, sem clickbait falso. "
         "A thumbnail deve ter no máximo três elementos, alto contraste, uma composição clara, texto opcional de até 4 palavras, "
         "safe zones e leitura em 120px. O texto da thumbnail não pode repetir o título integralmente. Remove AI tells. "
-        "Responde apenas com JSON válido nas chaves selected_title, title_candidates e thumbnail_variants."
+        "Responde apenas com JSON válido nas chaves selected_title, title_candidates, keywords e thumbnail_variants."
     )
     user = json.dumps(
         {
@@ -202,6 +213,7 @@ def generate_creative_package(
             "language": language or context["language"],
             "topic": topic.strip(),
             "reference_rules": reference_bundle(),
+            "keywords_schema": ["lista de 8 a 15 keywords SEO curtas, sem hashtags"],
             "title_candidates_schema": {
                 "title": "string",
                 "formula": "string",
@@ -241,6 +253,14 @@ def generate_creative_package(
         )
     if len(titles) < 20:
         raise CreativeGenerationError("Os títulos devolvidos pelo provider não têm conteúdo suficiente.")
+    raw_keywords = result.get("keywords")
+    keywords = [str(item).strip() for item in raw_keywords if str(item).strip()] if isinstance(raw_keywords, list) else []
+    selected_title = str(result.get("selected_title") or titles[0]["title"]).strip()
+    if selected_title not in {item["title"] for item in titles}:
+        selected_title = titles[0]["title"]
+    if not keywords:
+        keywords = _keywords_from_text(topic, selected_title)
+
     variants_raw = result.get("thumbnail_variants")
     if not isinstance(variants_raw, list) or len(variants_raw) < 3:
         raise CreativeGenerationError("O provider deve devolver pelo menos 3 variantes de thumbnail.")
@@ -264,12 +284,10 @@ def generate_creative_package(
         )
     if len(variants) < 3:
         raise CreativeGenerationError("As variantes de thumbnail devolvidas pelo provider estão incompletas.")
-    selected_title = str(result.get("selected_title") or titles[0]["title"]).strip()
-    if selected_title not in {item["title"] for item in titles}:
-        selected_title = titles[0]["title"]
     return {
         "title": selected_title,
         "title_candidates": titles,
+        "keywords": keywords[:15],
         "thumbnail_variant": variants[0],
         "thumbnail_variants": variants,
         "thumbnail_status": "prompt_ready",

package/hermes_ui/domain.py

@@ -7,7 +7,7 @@ from typing import Any
 from .notifications import record_notification
 from .storage import append_json, now, read_json, write_json
 
-STAGES = ["niche", "blueprint", "brand", "script", "title", "thumbnail", "video", "edit", "upload"]
+STAGES = ["niche", "blueprint", "brand", "topic", "script", "title", "keywords", "thumbnail_prompt", "thumbnail", "video", "edit", "upload"]
 VALID_STATES = {"to_do", "doing", "blocked", "done", "failed", "cancelled"}
 
 

package/hermes_ui/languages.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import base64
+from functools import lru_cache
 from typing import Any
 
 
@@ -589,6 +590,22 @@ for _row in _CONTENT_TOKEN_TRANSLATION_ROWS:
         UI_TOKEN_TRANSLATIONS[_code][_source] = _translated
 
 
+@lru_cache(maxsize=16)
+def _combined_translations(language: str) -> dict[str, str]:
+    """Build the immutable-language translation index once per process."""
+    return {
+        **UI_TRANSLATIONS.get(language, {}),
+        **UI_CONTENT_TRANSLATIONS.get(language, {}),
+        **UI_TOKEN_TRANSLATIONS.get(language, {}),
+    }
+
+
+@lru_cache(maxsize=16)
+def _sorted_translations(language: str) -> tuple[tuple[str, str], ...]:
+    """Cache longest-first token replacement order for each language."""
+    return tuple(sorted(_combined_translations(language).items(), key=lambda item: len(item[0]), reverse=True))
+
+
 def translate_ui_content(value: Any, language: Any = "pt") -> Any:
     """Translate visible Streamlit content while preserving non-text values and user data markup."""
     if not isinstance(value, str):
@@ -601,12 +618,7 @@ def translate_ui_content(value: Any, language: Any = "pt") -> Any:
     if exact is not None:
         return exact
     translated = value
-    combined_translations = {
-        **UI_TRANSLATIONS.get(code, {}),
-        **UI_CONTENT_TRANSLATIONS.get(code, {}),
-        **UI_TOKEN_TRANSLATIONS.get(code, {}),
-    }
-    for source, target in sorted(combined_translations.items(), key=lambda item: len(item[0]), reverse=True):
+    for source, target in _sorted_translations(code):
         if source != target and source in translated:
             translated = translated.replace(source, target)
     return translated

package/hermes_ui/pipeline_worker.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from integrations.upload_routing import upload_with_default_route
+from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_topic_for_channel
+from hermes_ui.script_documents import save_script_document
+from hermes_ui.script_generation import generate_script_document
+from hermes_ui.storage import STORAGE, ensure_storage, read_json, write_json
+from hermes_ui.thumbnail_generation import generate_thumbnail_image
+
+PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
+PIPELINE_LOG_FILENAME = "pipeline_worker.json"
+VIDEO_TIMEOUT_SECONDS = 20 * 60
+STALE_TASK_SECONDS = 2 * 60 * 60
+
+
+class PipelineError(RuntimeError):
+    """Raised when a pipeline stage cannot complete with an actionable error."""
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _settings() -> dict[str, Any]:
+    value = read_json("settings.json", {})
+    return value if isinstance(value, dict) else {}
+
+
+def _lock_path() -> Path:
+    ensure_storage()
+    return STORAGE / "state" / PIPELINE_LOCK_FILENAME
+
+
+def _acquire_lock() -> Path | None:
+    path = _lock_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        descriptor = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+        os.write(descriptor, str(os.getpid()).encode("ascii"))
+        os.close(descriptor)
+        return path
+    except FileExistsError:
+        return None
+
+
+def _write_worker_state(**updates: Any) -> None:
+    state = read_json(PIPELINE_LOG_FILENAME, {})
+    if not isinstance(state, dict):
+        state = {}
+    state.update(updates)
+    state["updated_at"] = _now()
+    write_json(PIPELINE_LOG_FILENAME, state)
+
+
+def _task_by_id(task_id: str) -> dict[str, Any] | None:
+    return next((task for task in read_json("tasks.json", []) if isinstance(task, dict) and task.get("id") == task_id), None)
+
+
+def _update(task_id: str, **updates: Any) -> dict[str, Any]:
+    from hermes_ui.domain import update_task
+
+    updated = update_task(task_id, updates)
+    if not updated:
+        raise PipelineError(f"Tarefa {task_id} deixou de existir durante a execução.")
+    return updated
+
+
+def _channel_for_task(task: dict[str, Any]) -> dict[str, Any]:
+    channel_id = str(task.get("channel_id") or "")
+    return next((channel for channel in read_json("channels.json", []) if str(channel.get("id")) == channel_id), {})
+
+
+def _blueprint_for_channel(channel: dict[str, Any]) -> dict[str, Any]:
+    blueprint_id = str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or "")
+    blueprints = read_json("blueprints.json", [])
+    if not isinstance(blueprints, list):
+        return {}
+    return next((item for item in blueprints if isinstance(item, dict) and str(item.get("id")) == blueprint_id), {})
+
+
+def _keywords(topic: str, title: str, niche: str = "") -> list[str]:
+    """Derive deterministic SEO keywords when the LLM does not return a keyword list."""
+    source = f"{title} {topic} {niche}".casefold()
+    words = re.findall(r"[\wÀ-ÿ]{4,}", source, flags=re.UNICODE)
+    blocked = {"para", "como", "sobre", "mais", "esse", "esta", "that", "this", "with", "from", "video"}
+    result: list[str] = []
+    for word in words:
+        if word in blocked or word in result:
+            continue
+        result.append(word)
+    return result[:15]
+
+
+def _save_json_artifact(task_id: str, name: str, payload: dict[str, Any]) -> str:
+    directory = STORAGE / "artifacts"
+    directory.mkdir(parents=True, exist_ok=True)
+    path = directory / f"{task_id}-{name}.json"
+    temporary = path.with_suffix(".tmp")
+    temporary.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    temporary.replace(path)
+    return str(path)
+
+
+def _run_video_helper(task: dict[str, Any]) -> Path:
+    helper_dir = Path(__file__).resolve().parents[1] / "seed" / "skills"
+    helper = helper_dir / "mpt_agent.py"
+    if not helper.is_file():
+        raise PipelineError("O helper de vídeo MoneyPrinterTurbo não está instalado no pacote.")
+    subject = str(task.get("topic") or "").strip()
+    if not subject:
+        raise PipelineError("A etapa Vídeo não recebeu um tema válido.")
+    settings = _settings()
+    env = os.environ.copy()
+    provider = str(settings.get("llm_provider") or "openai").strip()
+    env_values = {
+        "MPT_LLM_PROVIDER": provider,
+        "MPT_LLM_API_KEY": str(settings.get(f"{provider}_api_key") or "").strip(),
+        "MPT_LLM_BASE_URL": str(settings.get(f"{provider}_base_url") or "").strip(),
+        "MPT_LLM_MODEL_NAME": str(settings.get(f"{provider}_model_name") or "").strip(),
+        "MPT_PEXELS_API_KEY": str(settings.get("pexels_api_key") or "").strip(),
+    }
+    for key, value in env_values.items():
+        if value:
+            env[key] = value
+    command = ["uv", "run", "--no-project", "--python", "3.11", "python", "mpt_agent.py", "--subject", subject]
+    try:
+        result = subprocess.run(command, cwd=helper_dir, env=env, capture_output=True, text=True, timeout=VIDEO_TIMEOUT_SECONDS, check=False)
+    except FileNotFoundError as exc:
+        raise PipelineError("O comando uv não está instalado; não foi possível iniciar a geração de vídeo.") from exc
+    except subprocess.TimeoutExpired as exc:
+        raise PipelineError(f"A etapa Vídeo excedeu o limite de {VIDEO_TIMEOUT_SECONDS // 60} minutos e foi encerrada.") from exc
+    output = "\n".join(part for part in (result.stdout, result.stderr) if part)
+    if result.returncode == 10:
+        raise PipelineError("A geração de vídeo precisa de credenciais adicionais do MoneyPrinterTurbo.")
+    if result.returncode != 0:
+        detail = output[-1200:].strip() or "erro sem detalhes devolvidos pelo helper"
+        raise PipelineError(f"MoneyPrinterTurbo falhou na etapa Vídeo: {detail}")
+    match = re.search(r"(?m)^VIDEO_FILE=(.+)$", output)
+    video_path = Path(match.group(1).strip()).expanduser() if match else None
+    if not video_path or not video_path.is_file() or video_path.stat().st_size <= 0:
+        result_file = Path.home() / "MoneyPrinterTurbo" / ".agent-logs" / "moneyprinterturbo-video" / "latest-result.json"
+        if result_file.is_file():
+            try:
+                payload = json.loads(result_file.read_text(encoding="utf-8"))
+                video_path = Path(str(payload.get("video_file") or payload.get("VIDEO_FILE") or "")).expanduser()
+            except (OSError, json.JSONDecodeError):
+                video_path = None
+    if not video_path or not video_path.is_file() or video_path.stat().st_size <= 0:
+        raise PipelineError("MoneyPrinterTurbo terminou sem devolver um MP4 válido.")
+    return video_path
+
+
+def _run_task(task: dict[str, Any]) -> dict[str, Any]:
+    task_id = str(task.get("id") or "")
+    channel = _channel_for_task(task)
+    settings = _settings()
+    blueprint = _blueprint_for_channel(channel)
+    topic = str(task.get("topic") or "").strip()
+    if not topic or str(task.get("topic_source") or "") in {"auto", "llm_pending"}:
+        _update(task_id, stage="topic", state="doing", progress=5, error=None)
+        topic_result = generate_topic_for_channel(settings, channel, blueprint, user_context=str(task.get("topic_context") or ""))
+        topic = str(topic_result.get("topic") or "").strip()
+        if not topic:
+            raise PipelineError("A IA não devolveu um tema válido.")
+        _update(task_id, topic=topic, topic_source="llm", ai_generation={"topic": topic_result}, progress=12)
+
+    _update(task_id, stage="script", state="doing", progress=18, error=None)
+    script = generate_script_document(
+        settings,
+        document_type="Roteiro de vídeo",
+        title=str(task.get("title") or topic),
+        brief=topic,
+        language=str(task.get("language") or channel.get("language") or "Português"),
+        channel=channel,
+        blueprint=blueprint,
+        structure_notes=str((task.get("generation_settings") or {}).get("script_structure_notes") or ""),
+        generation_settings=task.get("generation_settings") if isinstance(task.get("generation_settings"), dict) else {},
+    )
+    script_record = save_script_document(script)
+    artifacts = dict(task.get("artifacts") or {})
+    artifacts["script"] = script_record.get("path", "")
+    _update(task_id, artifacts=artifacts, progress=30)
+
+    _update(task_id, stage="title", state="doing", progress=35)
+    creative = generate_creative_package(settings, channel, topic, blueprint, language=str(task.get("language") or channel.get("language") or "Português"))
+    title = str(creative.get("title") or topic).strip()
+    keywords = creative.get("keywords") if isinstance(creative.get("keywords"), list) else _keywords(topic, title, str(channel.get("niche") or ""))
+    title_artifact = _save_json_artifact(task_id, "title-keywords", {"topic": topic, "title": title, "keywords": keywords, "title_candidates": creative.get("title_candidates", [])})
+    _update(task_id, title=title, tags=keywords, artifacts={**artifacts, "title_keywords": title_artifact}, title_candidates=creative.get("title_candidates", []), progress=45)
+
+    _update(task_id, stage="keywords", state="doing", progress=48)
+    variant = creative.get("thumbnail_variant") if isinstance(creative.get("thumbnail_variant"), dict) else {}
+    prompt_payload = {"topic": topic, "title": title, "keywords": keywords, "thumbnail": variant, "requirements": {"aspect_ratio": "16:9", "resolution": "1920x1080", "max_elements": 3, "max_overlay_words": 4}}
+    prompt_artifact = _save_json_artifact(task_id, "thumbnail-prompt", prompt_payload)
+    artifacts = {**artifacts, "thumbnail_prompt_json": prompt_artifact}
+    _update(task_id, stage="thumbnail_prompt", state="doing", progress=52, thumbnail_prompt=str(variant.get("image_prompt") or ""), thumbnail_text=str(variant.get("overlay_text") or ""), thumbnail_status="prompt_ready", artifacts=artifacts)
+    _update(task_id, stage="thumbnail", state="doing", progress=56, thumbnail_prompt=str(variant.get("image_prompt") or ""), thumbnail_text=str(variant.get("overlay_text") or ""), thumbnail_status="prompt_ready", artifacts=artifacts)
+    thumbnail_path = generate_thumbnail_image(settings, str(variant.get("image_prompt") or ""), topic=topic, variant_index=0)
+    artifacts["thumbnail"] = str(thumbnail_path)
+    _update(task_id, artifacts=artifacts, thumbnail_status="generated", progress=62)
+
+    _update(task_id, stage="video", state="doing", progress=68)
+    video_path = _run_video_helper({**task, "topic": topic})
+    artifacts["video"] = str(video_path)
+    _update(task_id, artifacts=artifacts, progress=80)
+
+    _update(task_id, stage="upload", state="doing", progress=86)
+    result = upload_with_default_route(
+        settings,
+        storage_root=STORAGE,
+        channel=channel,
+        account=next((item for item in settings.get("youtube_batch_accounts", []) if isinstance(item, dict) and str(item.get("id")) == str(channel.get("google_account_id"))), None),
+        video_path=str(video_path),
+        title=title,
+        description=str(script.get("summary") or "") + "\n\n" + str(script.get("content") or "")[:5000],
+        tags=keywords,
+        language=str(task.get("language") or channel.get("language") or "pt-BR"),
+        privacy_status="unlisted",
+        thumbnail_path=str(thumbnail_path),
+        captions_path=str(artifacts.get("captions") or ""),
+    )
+    if not result.ok:
+        raise PipelineError(result.message)
+    artifacts["upload"] = result.data
+    return _update(task_id, stage="upload", state="done", progress=100, artifacts=artifacts, error=None)
+
+
+def run_once() -> dict[str, Any]:
+    ensure_storage()
+    lock = _acquire_lock()
+    if lock is None:
+        return {"ok": True, "busy": True}
+    try:
+        tasks = read_json("tasks.json", [])
+        candidate = next((task for task in tasks if isinstance(task, dict) and task.get("state") in {"to_do", "doing"}), None)
+        if not candidate:
+            _write_worker_state(last_task_id=None, last_error="", status="idle")
+            return {"ok": True, "status": "idle"}
+        task_id = str(candidate.get("id") or "")
+        _write_worker_state(last_task_id=task_id, status="running", last_error="")
+        try:
+            result = _run_task(candidate)
+            _write_worker_state(status="completed", last_error="")
+            return {"ok": True, "task_id": task_id, "task": result}
+        except Exception as exc:
+            message = str(exc)[:2000]
+            from hermes_ui.domain import update_task
+            update_task(task_id, {"state": "failed", "error": message})
+            _write_worker_state(status="failed", last_error=message)
+            return {"ok": False, "task_id": task_id, "error": message}
+    finally:
+        try:
+            lock.unlink()
+        except FileNotFoundError:
+            pass
+
+
+def run_worker(interval_seconds: int = 5) -> None:
+    ensure_storage()
+    while True:
+        run_once()
+        time.sleep(max(2, int(interval_seconds)))
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Executor do pipeline de criação de vídeos Thunderbolt")
+    parser.add_argument("--once", action="store_true")
+    parser.add_argument("--interval", type=int, default=5)
+    args = parser.parse_args()
+    if args.once:
+        print(json.dumps(run_once(), ensure_ascii=False), flush=True)
+    else:
+        run_worker(args.interval)
+
+
+if __name__ == "__main__":
+    main()

package/integrations/upload_routing.py

@@ -84,7 +84,7 @@ def upload_with_default_route(
     tags: list[str] | None = None,
     category_id: str = "22",
     language: str = "pt-BR",
-    privacy_status: str = "private",
+    privacy_status: str = "unlisted",
     thumbnail_path: str = "",
     captions_path: str = "",
     official_uploader: Callable[..., IntegrationResult] | None = None,

package/integrations/youtube_direct_upload.py

@@ -155,8 +155,12 @@ class YouTubeDirectUploader:
             "initialMetadata": {
                 "title": {"newTitle": title},
                 "description": {"newDescription": description},
-                "privacy": {"newPrivacy": visibility},
+                "privacy": {"newPrivacy": visibility or "unlisted"},
                 "draftState": {"isDraft": False},
+                "allowEmbedding": {"newAllowEmbedding": True},
+                "allowAudioRemixing": {"newAllowAudioRemixing": True},
+                "allowVideoRemixing": {"newAllowVideoRemixing": True},
+                "notifySubscribers": {"newNotifySubscribers": True},
                 "targetedAudience": {"operation": "MDE_TARGETED_AUDIENCE_UPDATE_OPERATION_SET", "newTargetedAudience": "MDE_TARGETED_AUDIENCE_TYPE_ALL"},
             },
             "botguardClientResponse": f"${hashlib.sha1(os.urandom(16)).hexdigest()}",
@@ -192,7 +196,7 @@ class YouTubeDirectUploader:
                 response.raise_for_status()
                 offset += len(chunk)
 
-    def upload(self, video_path: str | Path, *, title: str, description: str = "", visibility: str = "private", chunk_size: int | None = None) -> DirectUploadResult:
+    def upload(self, video_path: str | Path, *, title: str, description: str = "", visibility: str = "unlisted", chunk_size: int | None = None) -> DirectUploadResult:
         path = Path(video_path)
         validation_error = validate_direct_upload(path, self.channel, self.settings, self.account, self.storage_root)
         if validation_error:

package/integrations/youtube_upload.py

@@ -58,13 +58,19 @@ def build_agent_video_metadata(
     tags: list[str] | None = None,
     category_id: str = "22",
     language: str = "pt-BR",
-    privacy_status: str = "private",
+    privacy_status: str = "unlisted",
     publish_at: str | None = None,
+    embeddable: bool = True,
+    notify_subscribers: bool = True,
+    allow_audio_remixing: bool = True,
+    allow_video_remixing: bool = True,
 ) -> dict[str, Any]:
     """Build the snippet/status payload used by PublishingSchedulingAgent."""
     status: dict[str, Any] = {
-        "privacyStatus": privacy_status or "private",
+        "privacyStatus": privacy_status or "unlisted",
         "selfDeclaredMadeForKids": False,
+        "embeddable": bool(embeddable),
+        "publicStatsViewable": True,
     }
     if publish_at and status["privacyStatus"] == "private":
         # YouTube requires a future publishAt with privacyStatus=private.
@@ -235,13 +241,17 @@ class _GoogleYouTubeBase:
                 language=language,
                 privacy_status=privacy_status,
                 publish_at=publish_at,
+                embeddable=True,
+                notify_subscribers=True,
+                allow_audio_remixing=True,
+                allow_video_remixing=True,
             )
             try:
                 from googleapiclient.http import MediaFileUpload
             except ImportError as exc:
                 raise RuntimeError("A biblioteca de upload Google ainda não está instalada.") from exc
             media = MediaFileUpload(str(path), mimetype="video/mp4", chunksize=8 * 1024 * 1024, resumable=True)
-            request = youtube.videos().insert(part="snippet,status", body=body, media_body=media)
+            request = youtube.videos().insert(part="snippet,status", body=body, media_body=media, notifySubscribers=True)
             response = None
             while response is None:
                 _, response = request.next_chunk()
@@ -318,7 +328,7 @@ def upload_youtube_with_fallback(
     tags: list[str] | None = None,
     category_id: str = "22",
     language: str = "pt-BR",
-    privacy_status: str = "private",
+    privacy_status: str = "unlisted",
     publish_at: str | None = None,
     thumbnail_path: str | None = None,
     captions_path: str | None = None,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.2.90",
+  "version": "0.2.92",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",
@@ -20,6 +20,7 @@
     "seed/prompt_masters/**/*.md",
     "seed/blueprints/**/*.json",
     "seed/skills/*.md",
+    "seed/skills/*.py",
     "seed/references/*.md",
     "README.md",
     "MANUAL-INSTALACAO.md",

package/scripts/cli.mjs

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import { spawn, spawnSync } from "node:child_process";
+import http from "node:http";
+import net from "node:net";
 import { existsSync, mkdirSync, readFileSync, copyFileSync, readdirSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { join, resolve } from "node:path";
@@ -145,14 +147,69 @@ if (args[0] === "worker" || args.includes("--worker")) {
   run(python, ["-m", "hermes_ui.automation_worker", ...args.filter((arg) => arg !== "worker" && arg !== "--worker")], "worker de automação");
 }
 
+if (args[0] === "pipeline-worker" || args.includes("--pipeline-worker")) {
+  run(python, ["-m", "hermes_ui.pipeline_worker", ...args.filter((arg) => arg !== "pipeline-worker" && arg !== "--pipeline-worker")], "worker do pipeline de vídeos");
+}
+
 const port = process.env.THUNDERBOLT_PORT || process.env.HERMES_PORT || "3030";
+const publicPort = Number.parseInt(String(port), 10);
+const backendPort = Number.isFinite(publicPort) ? publicPort + 1 : 3031;
+const supportedLanguages = new Set(["en", "zh", "de", "vi", "tr", "pt", "ru", "es", "id", "it"]);
+
+const proxy = http.createServer((request, response) => {
+  const requestUrl = new URL(request.url || "/", `http://localhost:${publicPort}`);
+  const pathParts = requestUrl.pathname.split("/").filter(Boolean);
+  const languagePrefix = pathParts.length === 1 && supportedLanguages.has(pathParts[0]) ? pathParts[0] : "";
+  if (languagePrefix) {
+    requestUrl.pathname = "/";
+    requestUrl.searchParams.set("lang", languagePrefix);
+    response.writeHead(302, { Location: `${requestUrl.pathname}?${requestUrl.searchParams.toString()}` });
+    response.end();
+    return;
+  }
+  const upstream = http.request({
+    hostname: "127.0.0.1",
+    port: backendPort,
+    method: request.method,
+    path: `${requestUrl.pathname}${requestUrl.search}`,
+    headers: { ...request.headers, host: `127.0.0.1:${backendPort}` },
+  }, (upstreamResponse) => {
+    response.writeHead(upstreamResponse.statusCode || 502, upstreamResponse.headers);
+    upstreamResponse.pipe(response);
+  });
+  upstream.on("error", (error) => {
+    response.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+    response.end(`Thunderbolt backend indisponível: ${error.message}`);
+  });
+  request.pipe(upstream);
+});
+
+proxy.on("upgrade", (request, clientSocket, head) => {
+  const upstreamSocket = net.connect(backendPort, "127.0.0.1", () => {
+    const headers = Object.entries(request.headers)
+      .map(([name, value]) => `${name}: ${Array.isArray(value) ? value.join(", ") : value}`)
+      .join("\\r\\n");
+    upstreamSocket.write(`GET ${request.url} HTTP/1.1\\r\\n${headers}\\r\\n\\r\\n`);
+    if (head.length) upstreamSocket.write(head);
+    clientSocket.pipe(upstreamSocket).pipe(clientSocket);
+  });
+  upstreamSocket.on("error", () => clientSocket.destroy());
+});
+
+proxy.listen(publicPort, "127.0.0.1");
 const worker = spawn(python, ["-m", "hermes_ui.automation_worker"], {
   cwd: root,
   stdio: "inherit",
   env: runtimeEnv,
   windowsHide: false,
 });
-const child = spawn(python, ["-m", "streamlit", "run", main, "--server.port", port, "--server.address", "localhost"], {
+const pipelineWorker = spawn(python, ["-m", "hermes_ui.pipeline_worker"], {
+  cwd: root,
+  stdio: "inherit",
+  env: runtimeEnv,
+  windowsHide: false,
+});
+const child = spawn(python, ["-m", "streamlit", "run", main, "--server.port", String(backendPort), "--server.address", "127.0.0.1"], {
   cwd: root,
   stdio: "inherit",
   env: runtimeEnv,
@@ -160,7 +217,9 @@ const child = spawn(python, ["-m", "streamlit", "run", main, "--server.port", po
 });
 
 const stopWorker = () => {
+  proxy.close();
   if (!worker.killed) worker.kill();
+  if (!pipelineWorker.killed) pipelineWorker.kill();
 };
 process.on("SIGINT", stopWorker);
 process.on("SIGTERM", stopWorker);
@@ -169,3 +228,4 @@ child.on("exit", (code, signal) => {
   process.exit(code ?? (signal ? 1 : 0));
 });
 worker.on("error", (error) => console.error(`Thunderbolt worker: ${error.message}`));
+pipelineWorker.on("error", (error) => console.error(`Thunderbolt pipeline worker: ${error.message}`));

package/seed/skills/mpt_agent.py

@@ -0,0 +1,640 @@
+#!/usr/bin/env python3
+"""Cross-platform installation and video generation for the MoneyPrinterTurbo Skill."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import urllib.error
+import urllib.request
+import uuid
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+PROJECT_ARCHIVE_URL = (
+    "https://github.com/harry0703/MoneyPrinterTurbo/archive/refs/heads/main.zip"
+)
+DEFAULT_ROOT = Path.home() / "MoneyPrinterTurbo"
+DEFAULT_VOICE_NAME = "zh-CN-XiaoxiaoNeural-Female"
+NEEDS_INPUT_EXIT_CODE = 10
+SUPPORTED_SOURCES = {"pexels", "pixabay", "coverr", "local"}
+PEXELS_API_KEY_URL = "https://www.pexels.com/api/"
+PEXELS_VALIDATION_URL = "https://api.pexels.com/v1/collections?per_page=1"
+PEXELS_API_KEY_HELP_URL = (
+    "https://help.pexels.com/hc/en-us/articles/"
+    "900004904026-How-do-I-get-an-API-key"
+)
+
+# Keep the recommended list focused on commonly used providers. When an LLM
+# key is missing, the helper emits all choices at once to avoid extra turns.
+RECOMMENDED_LLM_PROVIDERS = {
+    "moonshot": (
+        "Kimi / Moonshot AI",
+        "https://platform.kimi.com?track_id=track-2f5441d6ffd84c509dd079d78e9db5dc&aff=moneyprinterturbo",
+    ),
+    "openai": ("OpenAI", "https://platform.openai.com/api-keys"),
+    "gemini": ("Google Gemini", "https://aistudio.google.com/app/apikey"),
+    "deepseek": ("DeepSeek", "https://platform.deepseek.com/api_keys"),
+    "volcengine": (
+        "ByteDance VolcEngine Ark / Doubao",
+        "https://www.volcengine.com/activity/ai618?utm_source=MoneyPrinterTurbo",
+    ),
+    "minimax": ("MiniMax", "https://platform.minimax.io/"),
+    "mimo": (
+        "Xiaomi MiMo",
+        "https://platform.xiaomimimo.com/docs/zh-CN/quick-start/first-api-call",
+    ),
+}
+KEYLESS_LLM_PROVIDERS = {"ollama", "litellm"}
+CUSTOM_OPENAI_PROVIDER = "oneapi"
+
+# Hidden providers such as Qwen, Azure, and Grok remain usable when already
+# selected, but are not automatic fallback candidates. A fully configured
+# generic OpenAI-compatible endpoint can be reused safely.
+ADDITIONAL_REUSABLE_PROVIDERS = (CUSTOM_OPENAI_PROVIDER,)
+
+
+class SkillError(RuntimeError):
+    """An actionable Skill error that can be reported without a traceback."""
+
+
+def log(message: str) -> None:
+    """Flush concise progress so the agent knows the long-running job started."""
+    print(f"[MoneyPrinterTurbo] {message}", flush=True)
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Install MoneyPrinterTurbo and generate a final video from a topic."
+    )
+    parser.add_argument("--subject", required=True, help="video topic")
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=DEFAULT_ROOT,
+        help=f"MoneyPrinterTurbo installation directory (default: {DEFAULT_ROOT})",
+    )
+    parser.add_argument(
+        "cli_args",
+        nargs=argparse.REMAINDER,
+        help="additional MoneyPrinterTurbo CLI arguments placed after --",
+    )
+    args = parser.parse_args(argv)
+    args.subject = args.subject.strip()
+    if not args.subject:
+        parser.error("--subject cannot be empty")
+    if args.cli_args and args.cli_args[0] == "--":
+        args.cli_args = args.cli_args[1:]
+    return args
+
+
+def _safe_extract(archive: zipfile.ZipFile, destination: Path) -> None:
+    """Reject ZIP entries that would escape the temporary extraction directory."""
+    destination = destination.resolve()
+    for member in archive.infolist():
+        target = (destination / member.filename).resolve()
+        if target != destination and destination not in target.parents:
+            raise SkillError(f"project archive contains an unsafe path: {member.filename}")
+    archive.extractall(destination)
+
+
+def ensure_project(root: Path) -> None:
+    """Reuse an existing project or install it from the official GitHub archive."""
+    root = root.expanduser().resolve()
+    if (root / "cli.py").is_file() and (root / "config.example.toml").is_file():
+        log(f"using existing project: {root}")
+        return
+    if root.exists() and any(root.iterdir()):
+        raise SkillError(f"installation directory exists but is not a valid project: {root}")
+
+    root.parent.mkdir(parents=True, exist_ok=True)
+    log(f"first-time installation: downloading the official project to {root}")
+    with tempfile.TemporaryDirectory(prefix="mpt-install-") as temp_dir_value:
+        temp_dir = Path(temp_dir_value)
+        archive_path = temp_dir / "MoneyPrinterTurbo.zip"
+        request = urllib.request.Request(
+            PROJECT_ARCHIVE_URL,
+            headers={"User-Agent": "MoneyPrinterTurbo-Agent-Skill"},
+        )
+        with urllib.request.urlopen(request, timeout=120) as response:
+            # Stream the archive to avoid holding a second full copy in memory.
+            with archive_path.open("wb") as archive_file:
+                shutil.copyfileobj(response, archive_file)
+        with zipfile.ZipFile(archive_path) as archive:
+            _safe_extract(archive, temp_dir)
+
+        candidates = [
+            path
+            for path in temp_dir.iterdir()
+            if path.is_dir() and (path / "cli.py").is_file()
+        ]
+        if len(candidates) != 1:
+            raise SkillError("download completed but no valid MoneyPrinterTurbo project was found")
+        if root.exists():
+            root.rmdir()
+        shutil.move(str(candidates[0]), str(root))
+    log("project download completed")
+
+
+def ensure_config(root: Path) -> Path:
+    """Create the initial configuration without overwriting an existing file."""
+    config_path = root / "config.toml"
+    if not config_path.exists():
+        shutil.copy2(root / "config.example.toml", config_path)
+        log(f"created configuration file: {config_path}")
+    return config_path
+
+
+def _plain_config_value(text: str, key: str) -> str:
+    """Read a simple top-level TOML value without printing its contents."""
+    match = re.search(rf"(?m)^{re.escape(key)}\s*=\s*(.*)$", text)
+    if not match:
+        return ""
+    value = match.group(1).split("#", 1)[0].strip()
+    if value.startswith('"') and value.endswith('"'):
+        return value[1:-1]
+    return value
+
+
+def _replace_config_value(text: str, key: str, value: object) -> str:
+    """Replace one active field while preserving the configuration layout."""
+    pattern = re.compile(rf"(?m)^({re.escape(key)}\s*=\s*).*$")
+    if not pattern.search(text):
+        raise SkillError(f"configuration field not found in config.toml: {key}")
+    encoded = json.dumps(value, ensure_ascii=False)
+    return pattern.sub(lambda match: f"{match.group(1)}{encoded}", text, count=1)
+
+
+def _has_configured_value(value: str) -> bool:
+    """Treat empty strings and whitespace-only key arrays as unconfigured."""
+    if not value:
+        return False
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError:
+        return bool(value.strip())
+    if isinstance(parsed, list):
+        return any(str(item).strip() for item in parsed)
+    return bool(str(parsed).strip())
+
+
+def _parse_string_list(value: str) -> list[str]:
+    """Parse a configured string list while removing blanks and duplicates."""
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError:
+        return []
+    if not isinstance(parsed, list):
+        return []
+    return list(dict.fromkeys(str(item).strip() for item in parsed if str(item).strip()))
+
+
+def apply_environment_config(config_path: Path) -> None:
+    """Write supplied credentials while logging field names only."""
+    provider = os.environ.get("MPT_LLM_PROVIDER", "").strip().lower()
+    if provider == "openai_compatible":
+        provider = CUSTOM_OPENAI_PROVIDER
+    llm_key = os.environ.get("MPT_LLM_API_KEY", "").strip()
+    base_url = os.environ.get("MPT_LLM_BASE_URL", "").strip()
+    model_name = os.environ.get("MPT_LLM_MODEL_NAME", "").strip()
+    pexels_key = os.environ.get("MPT_PEXELS_API_KEY", "").strip()
+    if not any((provider, llm_key, base_url, model_name, pexels_key)):
+        return
+
+    text = config_path.read_text(encoding="utf-8")
+    current_provider = _plain_config_value(text, "llm_provider") or "moonshot"
+    provider = provider or current_provider
+    changes: list[str] = []
+    if os.environ.get("MPT_LLM_PROVIDER", "").strip():
+        text = _replace_config_value(text, "llm_provider", provider)
+        changes.append("llm_provider")
+    if llm_key:
+        text = _replace_config_value(text, f"{provider}_api_key", llm_key)
+        changes.append(f"{provider}_api_key")
+    if base_url:
+        text = _replace_config_value(text, f"{provider}_base_url", base_url)
+        changes.append(f"{provider}_base_url")
+    if model_name:
+        text = _replace_config_value(text, f"{provider}_model_name", model_name)
+        changes.append(f"{provider}_model_name")
+    if pexels_key:
+        text = _replace_config_value(text, "pexels_api_keys", [pexels_key])
+        changes.append("pexels_api_keys")
+    config_path.write_text(text, encoding="utf-8")
+    log("updated configuration fields: " + ", ".join(changes))
+
+
+def _provider_is_ready(text: str, provider: str) -> bool:
+    """Return whether a provider has enough configuration to generate."""
+    if provider in KEYLESS_LLM_PROVIDERS:
+        return True
+    if not _has_configured_value(
+        _plain_config_value(text, f"{provider}_api_key")
+    ):
+        return False
+    if provider == CUSTOM_OPENAI_PROVIDER:
+        return all(
+            _has_configured_value(_plain_config_value(text, f"{provider}_{suffix}"))
+            for suffix in ("base_url", "model_name")
+        )
+    return True
+
+
+def reuse_existing_llm_provider(config_path: Path) -> str:
+    """
+    Reuse existing LLM credentials before asking the user for another key.
+
+    Keep the current provider when it is ready. Otherwise, scan configured
+    recommended providers in UI order and update ``llm_provider``. Credential
+    values are inspected in memory and are never logged.
+    """
+    text = config_path.read_text(encoding="utf-8")
+    current_provider = _plain_config_value(text, "llm_provider") or "moonshot"
+    if _provider_is_ready(text, current_provider):
+        return current_provider
+
+    reusable_providers = (
+        *RECOMMENDED_LLM_PROVIDERS,
+        *ADDITIONAL_REUSABLE_PROVIDERS,
+    )
+    for provider in reusable_providers:
+        if _provider_is_ready(text, provider):
+            text = _replace_config_value(text, "llm_provider", provider)
+            config_path.write_text(text, encoding="utf-8")
+            log(f"reusing configured LLM provider: {provider}")
+            return provider
+    return current_provider
+
+
+def selected_video_source(cli_args: list[str]) -> str:
+    """Read the effective material source from forwarded CLI arguments."""
+    for index, item in enumerate(cli_args):
+        if item == "--video-source" and index + 1 < len(cli_args):
+            return cli_args[index + 1].strip().lower()
+        if item.startswith("--video-source="):
+            return item.split("=", 1)[1].strip().lower()
+    return "pexels"
+
+
+def has_cli_option(cli_args: list[str], option: str) -> bool:
+    """Return whether forwarded arguments explicitly set a CLI option."""
+    return any(item == option or item.startswith(f"{option}=") for item in cli_args)
+
+
+def missing_config(config_path: Path, cli_args: list[str]) -> tuple[str, list[str]]:
+    """Return the active provider and only the fields required by this run."""
+    text = config_path.read_text(encoding="utf-8")
+    provider = _plain_config_value(text, "llm_provider") or "moonshot"
+    missing: list[str] = []
+    if provider not in KEYLESS_LLM_PROVIDERS and not _has_configured_value(
+        _plain_config_value(text, f"{provider}_api_key")
+    ):
+        missing.append(f"{provider}_api_key")
+    if provider == CUSTOM_OPENAI_PROVIDER:
+        for suffix in ("base_url", "model_name"):
+            field = f"{provider}_{suffix}"
+            if not _has_configured_value(_plain_config_value(text, field)):
+                missing.append(field)
+
+    source = selected_video_source(cli_args)
+    if source not in SUPPORTED_SOURCES:
+        raise SkillError(f"unsupported video source: {source}")
+    if source != "local":
+        value = _plain_config_value(text, f"{source}_api_keys")
+        if not _has_configured_value(value):
+            missing.append(f"{source}_api_keys")
+    return provider, missing
+
+
+def report_missing_config(provider: str, missing: list[str]) -> int:
+    """Tell the agent exactly which credentials must be requested."""
+    print("MPT_NEEDS_INPUT")
+    print(f"LLM_PROVIDER={provider}")
+    for field in missing:
+        print(f"MISSING={field}")
+    if any(field.endswith("_api_key") for field in missing):
+        print("LLM_PROVIDER_OPTIONS_BEGIN")
+        for provider_id, (label, url) in RECOMMENDED_LLM_PROVIDERS.items():
+            print(f"LLM_PROVIDER_OPTION={provider_id}|{label}|{url}")
+        print(
+            "LLM_PROVIDER_OPTION=oneapi|Other OpenAI-compatible provider|"
+            "requires an API key, API base URL, and model name"
+        )
+        print("LLM_PROVIDER_OPTIONS_END")
+    if any(field.startswith(f"{CUSTOM_OPENAI_PROVIDER}_") for field in missing):
+        print(
+            "OPENAI_COMPATIBLE_REQUIRED="
+            "API key, API base URL, model name"
+        )
+    if "pexels_api_keys" in missing:
+        print(f"PEXELS_API_KEY_URL={PEXELS_API_KEY_URL}")
+        print(f"PEXELS_API_KEY_HELP_URL={PEXELS_API_KEY_HELP_URL}")
+    print("Request only the listed values, set the environment variables, and rerun the same command.")
+    return NEEDS_INPUT_EXIT_CODE
+
+
+def report_invalid_pexels_config() -> int:
+    """Request only a new Pexels key when every configured key is rejected."""
+    print("MPT_NEEDS_INPUT")
+    print("INVALID=pexels_api_keys")
+    print(f"PEXELS_API_KEY_URL={PEXELS_API_KEY_URL}")
+    print(f"PEXELS_API_KEY_HELP_URL={PEXELS_API_KEY_HELP_URL}")
+    print("All configured Pexels API keys were rejected or are unavailable. Provide a new key.")
+    return NEEDS_INPUT_EXIT_CODE
+
+
+def _validate_pexels_key(api_key: str) -> str:
+    """
+    Return ``valid``, ``rejected``, or ``unknown`` for a Pexels key.
+
+    HTTP 401, 403, and rate-limited 429 responses make a key unusable for this
+    run. Network and server errors return unknown so the configuration is kept.
+    """
+    # Curated and popular search requests may hit a public cache and return 200
+    # without valid authorization. My Collections is account-specific, requires
+    # authentication, and still returns 200 for an empty collection list.
+    request = urllib.request.Request(
+        PEXELS_VALIDATION_URL,
+        headers={
+            "Authorization": api_key,
+            "User-Agent": "MoneyPrinterTurbo-Agent-Skill",
+        },
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=15) as response:
+            return "valid" if 200 <= response.status < 300 else "unknown"
+    except urllib.error.HTTPError as exc:
+        if exc.code in {401, 403, 429}:
+            return "rejected"
+        return "unknown"
+    except (TimeoutError, urllib.error.URLError):
+        return "unknown"
+
+
+def validate_pexels_config(config_path: Path, cli_args: list[str]) -> bool:
+    """
+    Validate all Pexels keys used by the default material source.
+
+    Downstream code selects configured keys randomly. Keeping rejected keys can
+    cause intermittent 401 responses and missing material results. If at least
+    one key is verified, retain only verified keys. If validation is impossible
+    because of a transient network failure, keep the original configuration.
+    """
+    if selected_video_source(cli_args) != "pexels":
+        return True
+
+    text = config_path.read_text(encoding="utf-8")
+    keys = _parse_string_list(_plain_config_value(text, "pexels_api_keys"))
+    if not keys:
+        return False
+
+    valid_keys: list[str] = []
+    rejected_count = 0
+    unknown_count = 0
+    for api_key in keys:
+        status = _validate_pexels_key(api_key)
+        if status == "valid":
+            valid_keys.append(api_key)
+        elif status == "rejected":
+            rejected_count += 1
+        else:
+            unknown_count += 1
+
+    if valid_keys:
+        if valid_keys != keys:
+            text = _replace_config_value(text, "pexels_api_keys", valid_keys)
+            config_path.write_text(text, encoding="utf-8")
+        log(
+            "Pexels key validation completed: "
+            f"valid={len(valid_keys)}, rejected={rejected_count}, "
+            f"unknown={unknown_count}"
+        )
+        return True
+    if unknown_count:
+        log("Pexels keys could not be verified due to a network or service error; keeping the existing configuration")
+        return True
+
+    log(f"Pexels key validation failed: all {rejected_count} configured keys are unusable")
+    return False
+
+
+def result_manifest_path(root: Path) -> Path:
+    return root / ".agent-logs" / "moneyprinterturbo-video" / "latest-result.json"
+
+
+def write_result_manifest(root: Path, payload: dict[str, object]) -> Path:
+    """
+    Atomically write the stable result file for agents that cannot wait.
+
+    The file contains task status and result paths only, never configuration
+    contents, credentials, or full logs.
+    """
+    result_path = result_manifest_path(root)
+    result_path.parent.mkdir(parents=True, exist_ok=True)
+    data = {
+        "updated_at": datetime.now(timezone.utc).isoformat(),
+        **payload,
+    }
+    unique_suffix = str(uuid.uuid4()).replace("-", "")
+    temp_path = result_path.with_name(
+        f".{result_path.name}.{os.getpid()}.{unique_suffix}.tmp"
+    )
+    temp_path.write_text(
+        json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+    temp_path.replace(result_path)
+    return result_path.resolve()
+
+
+def run_checked(command: list[str], *, cwd: Path) -> None:
+    """Run dependency sync quietly and show only the last 30 lines on failure."""
+    log("installing or verifying project dependencies with uv")
+    result = subprocess.run(
+        command,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        errors="replace",
+        check=False,
+    )
+    if result.returncode != 0:
+        output_tail = (result.stdout or "").splitlines()[-30:]
+        if output_tail:
+            print("\n".join(output_tail), file=sys.stderr)
+        raise SkillError(f"dependency installation failed with exit code {result.returncode}")
+
+
+def generate_video(
+    root: Path,
+    subject: str,
+    cli_args: list[str],
+) -> tuple[list[Path], Path, Path, Path]:
+    """Run one traceable CLI task and return only its final video files."""
+    uv = shutil.which("uv")
+    if not uv:
+        raise SkillError("uv was not found; reopen the terminal or add uv to PATH")
+    run_checked([uv, "sync", "--frozen"], cwd=root)
+
+    task_id = str(uuid.uuid4())
+    task_dir = root / "storage" / "tasks" / task_id
+    log_dir = root / ".agent-logs" / "moneyprinterturbo-video"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_path = log_dir / f"run-{task_id}.log"
+    write_result_manifest(
+        root,
+        {
+            "status": "running",
+            "subject": subject,
+            "task_id": task_id,
+            "task_dir": str(task_dir.resolve()),
+            "log_file": str(log_path.resolve()),
+            "video_files": [],
+        },
+    )
+    voice_args = (
+        []
+        if has_cli_option(cli_args, "--voice-name")
+        else ["--voice-name", DEFAULT_VOICE_NAME]
+    )
+    command = [
+        uv,
+        "run",
+        "python",
+        "cli.py",
+        *cli_args,
+        "--video-subject",
+        subject,
+        "--task-id",
+        task_id,
+        # Older CLI versions leave voice_name empty and fail during Edge TTS
+        # with ``Invalid voice ''``. Supply a stable Chinese voice unless the
+        # user has explicitly selected another voice.
+        *voice_args,
+        # A Skill request must produce a finished video. Force the final stage
+        # so forwarded options cannot stop at script, audio, or materials.
+        "--stop-at",
+        "video",
+    ]
+    log(f"starting video generation, task ID: {task_id}")
+    log(f"full generation log: {log_path}")
+    with log_path.open("w", encoding="utf-8") as log_file:
+        result = subprocess.run(
+            command,
+            cwd=root,
+            stdout=log_file,
+            stderr=subprocess.STDOUT,
+            text=True,
+            check=False,
+        )
+    if result.returncode != 0:
+        tail = log_path.read_text(encoding="utf-8", errors="replace").splitlines()[-30:]
+        if tail:
+            print("\n".join(tail), file=sys.stderr)
+        error = (
+            f"video generation failed with exit code {result.returncode}; "
+            f"log: {log_path}"
+        )
+        write_result_manifest(
+            root,
+            {
+                "status": "failed",
+                "subject": subject,
+                "task_id": task_id,
+                "task_dir": str(task_dir.resolve()),
+                "log_file": str(log_path.resolve()),
+                "video_files": [],
+                "error": error,
+            },
+        )
+        raise SkillError(error)
+
+    videos = sorted(
+        path.resolve()
+        for path in task_dir.glob("final-*.mp4")
+        if path.is_file() and path.stat().st_size > 0
+    )
+    if not videos:
+        error = f"generation completed without a valid final MP4; log: {log_path}"
+        write_result_manifest(
+            root,
+            {
+                "status": "failed",
+                "subject": subject,
+                "task_id": task_id,
+                "task_dir": str(task_dir.resolve()),
+                "log_file": str(log_path.resolve()),
+                "video_files": [],
+                "error": error,
+            },
+        )
+        raise SkillError(error)
+    result_path = write_result_manifest(
+        root,
+        {
+            "status": "completed",
+            "subject": subject,
+            "task_id": task_id,
+            "task_dir": str(task_dir.resolve()),
+            "log_file": str(log_path.resolve()),
+            "video_files": [str(video) for video in videos],
+        },
+    )
+    return videos, task_dir.resolve(), log_path.resolve(), result_path
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    root = args.root.expanduser().resolve()
+    try:
+        ensure_project(root)
+        config_path = ensure_config(root)
+        apply_environment_config(config_path)
+        reuse_existing_llm_provider(config_path)
+        provider, missing = missing_config(config_path, args.cli_args)
+        if missing:
+            write_result_manifest(
+                root,
+                {
+                    "status": "needs_input",
+                    "subject": args.subject,
+                    "missing": missing,
+                },
+            )
+            return report_missing_config(provider, missing)
+        if not validate_pexels_config(config_path, args.cli_args):
+            write_result_manifest(
+                root,
+                {
+                    "status": "needs_input",
+                    "subject": args.subject,
+                    "invalid": ["pexels_api_keys"],
+                },
+            )
+            return report_invalid_pexels_config()
+        videos, task_dir, log_path, result_path = generate_video(
+            root, args.subject, args.cli_args
+        )
+    except (OSError, SkillError, urllib.error.URLError, zipfile.BadZipFile) as exc:
+        print(f"MPT_ERROR={exc}", file=sys.stderr)
+        return 1
+
+    print("MPT_RESULT")
+    for video in videos:
+        print(f"VIDEO_FILE={video}")
+    print(f"TASK_DIR={task_dir}")
+    print(f"LOG_FILE={log_path}")
+    print(f"RESULT_FILE={result_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())