@danhachuel/thunderbolt 0.3.77 → 0.3.79

package/MANUAL-INSTALACAO.md

@@ -2,7 +2,7 @@
 
 Este manual descreve a instalação local da UI Thunderbolt, baseada no MoneyPrinterTurbo, utilizando o pacote npm `@danhachuel/thunderbolt`. O fluxo recomendado instala automaticamente o ambiente Python, as dependências da aplicação, as dependências do MoneyPrinterTurbo, o Streamlit e o suporte FFmpeg através de `imageio-ffmpeg`.
 
-> **Versão deste manual:** 0.3.77
+> **Versão deste manual:** 0.3.78
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -817,3 +817,9 @@ No card **OpenAI / NVIDIA NIM**, o campo **Modelo** é uma lista suspensa. Use *
 Quando Azure Speech SDK V2 estiver seleccionado, o Thunderbolt prepara a narração em segmentos antes de iniciar o MoneyPrinterTurbo. O tamanho interno dos segmentos é reduzido automaticamente para velocidades de fala lentas, o áudio final é validado e a CLI recebe `--custom-audio-file`. A geração é bloqueada se não houver confirmação dos segmentos; isto evita regressar à chamada monolítica do Azure que pode falhar com `maximum media duration of 600000ms`.
 
 Na interface, uma tarefa em execução mostra a última actividade do helper e o tempo decorrido da etapa Vídeo. Se ocorrer uma falha, consulte o caminho `LOG_FILE` ou `RESULT_FILE` apresentado no erro. A linha `updated configuration fields` é apenas sincronização inicial de configuração e não é a causa terminal. Nunca copie chaves, cookies, tokens ou o conteúdo integral do roteiro para pedidos de suporte.
+
+## 17. Quando o card mostra apenas o início da falha de vídeo
+
+A partir da versão 0.3.78, o card **Backlog Vídeos** mostra a causa terminal e disponibiliza **Ver diagnóstico completo**. As mensagens `Pexels key validation completed`, `installing or verifying project dependencies with uv` e `TASK_DIR` são apenas progresso ou metadados; não são, por si só, uma falha.
+
+Se o `uv` falhar, o erro inclui o detalhe seguro do resolver. Se a CLI do MoneyPrinterTurbo falhar, o resumo inclui `MPT_ERROR` e mantém `Log completo` e `Manifesto`. A interface não exibe chaves, cookies ou tokens. O tempo limite da verificação de dependências é de 15 minutos; a etapa é encerrada em vez de ficar indefinidamente sem resposta.

package/README.md

@@ -432,3 +432,9 @@ O campo **Modelo** em **Configuração API > API Keys > LLM — providers e mode
 No fluxo MoneyPrinterTurbo, a voz Azure Speech SDK V2 é preparada antes da CLI upstream. O Thunderbolt divide o roteiro em segmentos conservadores ajustados à velocidade, concatena o áudio localmente e só inicia o motor depois de confirmar o ficheiro e a contagem de segmentos. Se essa preparação falhar, a tarefa é interrompida e não existe fallback silencioso para uma chamada monolítica sujeita ao limite de 600000 ms.
 
 Durante a execução, o backlog mostra a actividade recente do helper e o tempo da etapa Vídeo. Em caso de falha, a mensagem terminal é extraída do output accionável, enquanto as linhas `using existing project` e `updated configuration fields` deixam de ser tratadas como causa. Os caminhos do log e do manifesto são preservados mesmo quando a falha ocorre antes da criação do MP4.
+
+## Correcção de diagnóstico da etapa Vídeo — 0.3.78
+
+A mensagem do card de vídeo deixou de mostrar apenas os primeiros 240 caracteres. A UI apresenta um resumo de erro com até 700 caracteres e disponibiliza um expander não editável com o diagnóstico completo, incluindo os caminhos do log e do manifesto quando existem. Linhas de sucesso de Pexels, sincronização do projecto, verificação do `uv` e marcadores de caminho são excluídas do resumo terminal.
+
+A verificação `uv sync --frozen` tem agora timeout controlado, detalhe seguro do resolver em caso de falha e confirmação explícita quando termina. O estado do manifesto é marcado como `failed` mesmo quando a falha acontece antes de a CLI do MoneyPrinterTurbo iniciar.

package/app/main.py

@@ -3592,7 +3592,15 @@ def _render_video_task_state(task: dict[str, Any]) -> None:
         except (TypeError, ValueError):
             pass
     if task.get("error"):
-        st.caption(str(task.get("error"))[:240])
+        error_text = str(task.get("error") or "").strip()
+        st.error(error_text[:700])
+        if len(error_text) > 700 or task.get("video_log") or task.get("video_result"):
+            with st.expander("Ver diagnóstico completo", expanded=False):
+                st.code(error_text[:6000])
+                if task.get("video_log"):
+                    st.caption(f"Log completo: {task.get('video_log')}")
+                if task.get("video_result"):
+                    st.caption(f"Manifesto: {task.get('video_result')}")
 
 
 def render_videos():
@@ -5389,11 +5397,25 @@ def _render_api_test_feedback(settings: dict[str, Any], test_key: str, result: d
     st.error(ui_text("Último teste: chamada falhou", language) + suffix)
 
 
-def _render_api_test_control(settings: dict[str, Any], test_key: str, callback: Any, *, widget_key: str) -> None:
-    """Render a form-safe diagnostic button and persist its redacted result."""
+def _render_api_test_control(
+    settings: dict[str, Any],
+    test_key: str,
+    callback: Any,
+    *,
+    widget_key: str,
+    persist_callback: Any = None,
+) -> None:
+    """Render a form-safe diagnostic button and persist its redacted result.
+
+    ``persist_callback`` keeps a card whose fields live in the global form
+    consistent: testing it must not appear successful while its values remain
+    only in the browser session.
+    """
     if st.form_submit_button("Testar chamada API", use_container_width=True, key=widget_key):
         with st.spinner(ui_text("A testar chamada API…", current_ui_language())):
             try:
+                if persist_callback is not None:
+                    persist_callback()
                 result = callback()
             except Exception:
                 result = {"status": "error", "message": "A chamada de diagnóstico falhou."}
@@ -5824,11 +5846,23 @@ def render_settings():
                         azure_speech_key = text_setting("Azure Speech key", "azure_speech_key", secret=True)
                         _render_credential_status(azure_speech_key)
                         azure_speech_region = text_setting("Azure Speech region", "azure_speech_region")
+
+                        def save_azure_speech() -> None:
+                            settings.update({
+                                "azure_speech_key": azure_speech_key.strip(),
+                                "azure_speech_region": azure_speech_region.strip(),
+                            })
+                            write_json("settings.json", settings)
+
+                        if st.form_submit_button("Guardar Azure Speech", type="primary", use_container_width=True, key="save_azure_speech"):
+                            save_azure_speech()
+                            st.success("Azure Speech guardado.")
                         _render_api_test_control(
                             settings,
                             "voice:azure_speech",
                             lambda: test_voice_provider("azure_speech", {"azure_speech_key": azure_speech_key, "azure_speech_region": azure_speech_region}),
                             widget_key="api_test_voice_azure",
+                            persist_callback=save_azure_speech,
                         )
 
                     with st.container(border=True):

package/hermes_ui/pipeline_worker.py

@@ -317,12 +317,15 @@ def _redact_helper_output(text: str) -> str:
     return text
 
 def _terminal_helper_detail(output: str) -> str:
-    """Return the last actionable helper lines, not startup/configuration noise."""
-    lines = [_redact_helper_output(line).strip() for line in str(output or "").splitlines()]
-    lines = [line for line in lines if line]
-    noise_markers = ("using existing project:", "updated configuration fields:", "starting video generation, task id:")
-    actionable = [line for line in lines if not any(marker in line.casefold() for marker in noise_markers)]
-    return "\n".join((actionable or lines)[-12:]).strip()
+    """Return concise actionable failure lines, never startup or path markers."""
+    raw_lines = [_redact_helper_output(line).strip() for line in str(output or "").splitlines()]
+    lines = [line for line in raw_lines if line]
+    metadata_prefixes = ("TASK_DIR=", "LOG_FILE=", "RESULT_FILE=", "VIDEO_FILE=")
+    noise_markers = ("using existing project:", "updated configuration fields:", "starting video generation, task id:", "installing or verifying project dependencies with uv", "pexels key validation completed:")
+    useful = [line for line in lines if not line.startswith(metadata_prefixes) and not any(marker in line.casefold() for marker in noise_markers)]
+    failure_markers = ("mpt_error=", "traceback", "exception", "error", "failed", "falhou", "failure", "missing", "invalid", "timeout", "timed out", "not found", "exceeded", "excedeu")
+    failures = [line for line in useful if any(marker in line.casefold() for marker in failure_markers)]
+    return "\n".join((failures or useful)[-8:]).strip()
 
 
 def _helper_failure_markers(output: str) -> dict[str, Any]:
@@ -522,12 +525,13 @@ def _failure_message(message: str, metadata: dict[str, Any]) -> str:
 
 
 def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, str]:
-    """Persist only bounded helper diagnostics and return its declared file paths."""
+    """Persist bounded helper diagnostics and a safe terminal summary."""
     task_id = str(task.get("id") or "").strip()
     if not task_id:
         return {}
     log_file = _helper_output_value(output, "LOG_FILE")
     result_file = _helper_output_value(output, "RESULT_FILE")
+    terminal_detail = _terminal_helper_detail(output)
     try:
         markers = _helper_failure_markers(output)
         payload: dict[str, Any] = {
@@ -535,6 +539,7 @@ def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, s
             "log_file": log_file,
             "result_file": result_file,
             "output_tail": _redact_helper_output(output[-6000:]),
+            "terminal_detail": terminal_detail,
             "helper_provider": markers["helper_provider"],
             "missing_fields": markers["missing_fields"],
             "invalid_fields": markers["invalid_fields"],
@@ -543,7 +548,10 @@ def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, s
         current = _task_by_id(task_id) or task
         artifacts = dict(current.get("artifacts") or {})
         artifacts["video_diagnostics"] = artifact_path
-        updates: dict[str, Any] = {"artifacts": artifacts}
+        updates: dict[str, Any] = {
+            "artifacts": artifacts,
+            "video_diagnostic_summary": terminal_detail,
+        }
         if log_file:
             updates["video_log"] = log_file
             artifacts["video_log"] = log_file

package/package.json

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

package/scripts/cli.mjs

@@ -193,6 +193,11 @@ const proxy = http.createServer((request, response) => {
 });
 
 proxy.on("upgrade", (request, clientSocket, head) => {
+  // Clientes remotos podem encerrar o WebSocket antes de o Streamlit concluir
+  // a resposta. Tratar ECONNRESET impede que o Node termine o launcher.
+  clientSocket.on("error", () => {
+    if (!clientSocket.destroyed) clientSocket.destroy();
+  });
   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}`)
@@ -201,10 +206,14 @@ proxy.on("upgrade", (request, clientSocket, head) => {
     if (head.length) upstreamSocket.write(head);
     clientSocket.pipe(upstreamSocket).pipe(clientSocket);
   });
-  upstreamSocket.on("error", () => clientSocket.destroy());
+  upstreamSocket.on("error", () => {
+    if (!clientSocket.destroyed) clientSocket.destroy();
+  });
 });
 
-proxy.listen(publicPort, "127.0.0.1", () => {
+// O backend Streamlit fica em 127.0.0.1; apenas o proxy escuta em todas as
+// interfaces para que o encaminhamento seguro do ambiente consiga alcançá-lo.
+proxy.listen(publicPort, () => {
   console.log(`Thunderbolt: interface disponível em http://localhost:${publicPort}/`);
 });
 const worker = spawn(python, ["-m", "hermes_ui.automation_worker"], {

package/seed/skills/mpt_agent.py

@@ -25,6 +25,7 @@ PROJECT_ARCHIVE_URL = (
 )
 DEFAULT_ROOT = Path.home() / "MoneyPrinterTurbo"
 CHUNKED_SYNTHESIS_TIMEOUT_SECONDS = 15 * 60
+DEPENDENCY_SYNC_TIMEOUT_SECONDS = 15 * 60
 DEFAULT_VOICE_NAME = "zh-CN-XiaoxiaoNeural-Female"
 NEEDS_INPUT_EXIT_CODE = 10
 SUPPORTED_SOURCES = {"pexels", "pixabay", "coverr", "local"}
@@ -623,24 +624,37 @@ def write_result_manifest(root: Path, payload: dict[str, object]) -> Path:
     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."""
+    """Run dependency sync with a bounded wait and safe failure output."""
     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,
-    )
+    try:
+        result = subprocess.run(
+            command,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            errors="replace",
+            check=False,
+            timeout=DEPENDENCY_SYNC_TIMEOUT_SECONDS,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise SkillError(
+            "A verificação das dependências com uv excedeu 15 minutos; "
+            "a execução foi interrompida."
+        ) from exc
+    output = result.stdout or ""
+    for key in ("MPT_LLM_API_KEY", "MPT_PEXELS_API_KEY", "MPT_PIXABAY_API_KEY", "AZURE_SPEECH_KEY", "AZURE_SPEECH_REGION"):
+        secret = os.environ.get(key, "").strip()
+        if secret:
+            output = output.replace(secret, "[redacted]")
     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}")
+        output_tail = "\n".join(output.splitlines()[-30:]).strip()
+        raise SkillError(
+            f"dependency installation failed with exit code {result.returncode}. "
+            + (f"Detalhe do uv: {output_tail}" if output_tail else "O uv não devolveu detalhes.")
+        )
+    log("project dependencies verified with uv")
 
 
 def generate_video(