@danhachuel/thunderbolt 0.3.82 → 0.3.84

package/app/main.py

@@ -3505,7 +3505,7 @@ def _render_pipeline_worker_banner(worker_status: dict[str, Any], active_count:
         st.warning("Worker de vídeo sem heartbeat recente. O launcher deve estar aberto para processar as tarefas.")
     heartbeat = worker_status.get("last_heartbeat_at") or worker_status.get("updated_at")
     if heartbeat:
-        st.caption(f"{_pipeline_time_age(heartbeat)} · timeout de execução: {STALE_TASK_SECONDS // 60} minutos")
+        st.caption(f"{_pipeline_time_age(heartbeat)} · vídeo: até 90 min com watchdog de inactividade de 10 min")
     if worker_status.get("last_error"):
         st.error(f"Último erro do worker: {worker_status['last_error']}")
 

package/hermes_ui/pipeline_worker.py

@@ -4,6 +4,7 @@ import json
 import os
 import queue
 import re
+import signal
 import subprocess
 import threading
 import time
@@ -27,6 +28,8 @@ from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_th
 PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
 PIPELINE_LOG_FILENAME = "pipeline_worker.json"
 VIDEO_TIMEOUT_SECONDS = 20 * 60
+LONG_STOCK_VIDEO_TIMEOUT_SECONDS = 90 * 60
+VIDEO_IDLE_TIMEOUT_SECONDS = 10 * 60
 STALE_TASK_SECONDS = VIDEO_TIMEOUT_SECONDS + 5 * 60
 WORKER_HEARTBEAT_TIMEOUT_SECONDS = 15
 CASCADE_STAGE_ORDER = ("topic", "script", "title", "keywords", "video", "thumbnail_prompt", "thumbnail", "upload")
@@ -184,13 +187,14 @@ def _recover_stale_tasks() -> list[str]:
         if not updated_at:
             continue
         age_seconds = (current_time - updated_at.astimezone(timezone.utc)).total_seconds()
-        if age_seconds <= STALE_TASK_SECONDS:
+        timeout_seconds = _task_stale_timeout_seconds(task)
+        if age_seconds <= timeout_seconds:
             continue
         task_id = str(task.get("id") or "")
         if not task_id:
             continue
         message = (
-            f"A tarefa ficou sem heartbeat durante mais de {STALE_TASK_SECONDS // 60} minutos. "
+            f"A tarefa ficou sem heartbeat durante mais de {timeout_seconds // 60} minutos. "
             "Foi marcada como falhada para evitar execução eterna; reveja o log do worker."
         )
         failed_stage = str(task.get("stage") or "pipeline")
@@ -568,7 +572,21 @@ def _persist_video_diagnostics(task: dict[str, Any], output: str) -> dict[str, s
 
 def _stop_process(process: subprocess.Popen[str]) -> None:
     if process.poll() is None:
-        process.kill()
+        try:
+            process_id = getattr(process, "pid", None)
+            if os.name != "nt" and process_id:
+                os.killpg(os.getpgid(process_id), signal.SIGKILL)
+            elif os.name == "nt" and process_id:
+                subprocess.run(
+                    ["taskkill", "/PID", str(process_id), "/T", "/F"],
+                    check=False,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+            else:
+                process.kill()
+        except (OSError, ProcessLookupError):
+            process.kill()
     try:
         process.wait(timeout=5)
     except subprocess.TimeoutExpired:
@@ -602,6 +620,34 @@ def _normalise_video_route(task: dict[str, Any], settings: dict[str, Any]) -> st
     return raw if raw in {"pexels", "pixabay", "local"} else "pexels"
 
 
+def _video_timeout_seconds(task: dict[str, Any], settings: dict[str, Any] | None = None) -> int:
+    """Reserve extra bounded time only for long stock-video downloads and assembly."""
+    effective_settings = settings if isinstance(settings, dict) else _settings()
+    route = _normalise_video_route(task, effective_settings)
+    script = str(task.get("video_script") or "").strip()
+    if route in {"pexels", "pixabay"} and len(script) >= 1_200:
+        return max(VIDEO_TIMEOUT_SECONDS, LONG_STOCK_VIDEO_TIMEOUT_SECONDS)
+    return VIDEO_TIMEOUT_SECONDS
+
+
+def _task_stale_timeout_seconds(task: dict[str, Any]) -> int:
+    """Keep stale-task recovery aligned with the actual execution budget."""
+    if str(task.get("stage") or "").strip().casefold() == "video":
+        return _video_timeout_seconds(task) + 5 * 60
+    return STALE_TASK_SECONDS
+
+
+def _latest_helper_log_activity(log_path: Path | None, previous_mtime: float) -> tuple[float, bool]:
+    """Return whether the helper's file log advanced without reading its content."""
+    if log_path is None:
+        return previous_mtime, False
+    try:
+        current_mtime = log_path.stat().st_mtime
+    except OSError:
+        return previous_mtime, False
+    return (current_mtime, current_mtime > previous_mtime)
+
+
 def _mpt_aspect_ratio(value: Any, format_value: Any = "") -> str:
     raw = str(value or format_value or "").strip().casefold()
     if raw in {"landscape 16:9", "wide", "16:9", "landscape"}:
@@ -847,6 +893,7 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     output_lines: list[str] = []
     line_queue: queue.Queue[str | None] = queue.Queue()
     started_at = time.monotonic()
+    timeout_seconds = _video_timeout_seconds(task, settings)
     process: subprocess.Popen[str] | None = None
 
     def _read_output() -> None:
@@ -863,6 +910,7 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
             command,
             cwd=helper_dir,
             env=env,
+            start_new_session=os.name != "nt",
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
@@ -879,6 +927,9 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
     output_finished = False
     last_heartbeat = 0.0
     last_output_line = ""
+    last_activity_at = started_at
+    helper_log_path: Path | None = None
+    helper_log_mtime = 0.0
     try:
         while True:
             try:
@@ -888,9 +939,19 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
                 elif line:
                     last_output_line = _redact_helper_output(line).strip()
                     output_lines.append(line)
+                    last_activity_at = time.monotonic()
+                    match = re.search(r"full generation log:\s*(.+)$", last_output_line, flags=re.IGNORECASE)
+                    if match:
+                        candidate = Path(match.group(1).strip()).expanduser()
+                        helper_log_path = candidate if candidate.is_file() else None
             except queue.Empty:
                 pass
             elapsed = time.monotonic() - started_at
+            helper_log_mtime, helper_log_advanced = _latest_helper_log_activity(helper_log_path, helper_log_mtime)
+            if helper_log_advanced:
+                last_activity_at = time.monotonic()
+                if not last_output_line:
+                    last_output_line = "[MoneyPrinterTurbo] actividade de geração confirmada"
             if elapsed - last_heartbeat >= 5:
                 # O helper expõe o resultado final, mas não uma percentagem estável.
                 # Mantemos uma faixa reservada para a etapa de vídeo e avançamos-a
@@ -917,9 +978,17 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
                 last_heartbeat = elapsed
             if process.poll() is not None and output_finished:
                 break
-            if elapsed >= VIDEO_TIMEOUT_SECONDS:
+            if elapsed >= timeout_seconds:
                 _stop_process(process)
-                message = f"A etapa Vídeo excedeu o limite de {VIDEO_TIMEOUT_SECONDS // 60} minutos e foi encerrada."
+                message = f"A etapa Vídeo excedeu o limite de {timeout_seconds // 60} minutos e foi encerrada."
+                metadata = _failure_attribution(task, settings, "video", error=message)
+                raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
+            if time.monotonic() - last_activity_at >= VIDEO_IDLE_TIMEOUT_SECONDS:
+                _stop_process(process)
+                message = (
+                    "A etapa Vídeo não apresentou actividade comprovada do motor durante "
+                    f"{VIDEO_IDLE_TIMEOUT_SECONDS // 60} minutos e foi encerrada."
+                )
                 metadata = _failure_attribution(task, settings, "video", error=message)
                 raise PipelineError(_failure_message(message, metadata), failure_metadata=metadata)
     finally:

package/package.json

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