@danhachuel/thunderbolt 0.2.32 → 0.2.33

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.2.31
+> **Versão deste manual:** 0.2.33
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -100,13 +100,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.31 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.33 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.31 install
+npx --yes @danhachuel/thunderbolt@0.2.33 install
 ```
 
 A instalação normal é **segura para actualizações**: preserva `storage`, Blueprints, Brandings, configurações e artefactos do utilizador. Remove apenas `.venv`, o clone técnico do MoneyPrinterTurbo e dependências que serão recriadas. Uma pasta antiga sem dados do utilizador, como `C:\Users\<utilizador>\AppData\Local\hermes` da tentativa incompleta, pode ser removida; uma pasta antiga que contenha Blueprints, Brandings ou storage é preservada e apenas avisada no terminal. Feche processos Python, Node, Streamlit e MobaXterm que estejam a usar as pastas antes de executar.
@@ -220,6 +220,12 @@ Depois de instalar e diagnosticar:
 npx --yes @danhachuel/thunderbolt
 ```
 
+O comando normal inicia a UI e o worker local de Automação. O worker verifica o relógio local do computador e cria os lotes dos canais com **Automação ON** quando o horário `HH:MM` coincide. Para executar apenas o worker, sem abrir a UI:
+
+```bash
+npx --yes @danhachuel/thunderbolt worker
+```
+
 Abra no navegador:
 
 ```text
@@ -372,7 +378,7 @@ Após iniciar a aplicação, valide o seguinte percurso:
 9. **Pipeline > Limpador de Metadados:** suba um vídeo de terceiro, preencha título, preview, links, timestamps e tags, aplique a limpeza e descarregue a cópia limpa e o manifesto JSON. O original fica preservado e vídeos das páginas de criação não são aceites nesta área.
 10. **Configurações > Configurações Técnicas:** confirme que os caminhos e credenciais estão locais e não aparecem no Git.
 11. **Criação de Vídeos:** confirme que `Pexels/Pixabay` substitui o label antigo, que `Estilo IA` aparece apenas em `full_ia` e que `Apenas Música` exige áudio e guarda `background_mode=none`.
-12. **Automação:** no cartão de cada canal, escolha o **Blueprint padrão** e a **Voz padrão**, clique em `Guardar` e confirme que o resumo do cartão se actualiza. Configure também **Automação ON** e um horário `HH:MM`; confirme a lista de vídeos cadastrados. Os mesmos defaults aparecem em **Canais** e são usados em novas tarefas. A UI não inicia jobs em segundo plano nesta entrega.
+12. **Automação:** no cartão de cada canal, escolha o **Blueprint padrão** e a **Voz padrão**, clique em `Guardar` e confirme que o resumo do cartão se actualiza. Configure também **Automação ON** e um horário `HH:MM`; confirme a lista de vídeos cadastrados. Os mesmos defaults aparecem em **Canais** e são usados em novas tarefas. Inicie o Thunderbolt pelo launcher, confirme o aviso verde **Worker activo** e verifique que o relógio apresentado corresponde ao computador. O worker cria no máximo um lote por canal por dia quando o horário local coincide.
 13. **Configurações > Configurações Técnicas > Teste de vozes:** teste Edge/Azure ou provider configurado e confirme reprodução/download sem criação de tarefa.
 14. **Upload directo:** configure manualmente cookies, sessionInfo e INNERTUBE_API_KEY, atribua o `DELEGATED_SESSION_ID` no canal e teste apenas com um vídeo de validação. O método envia chunks de 256 KiB e não extrai cookies do navegador.
 15. **Configurações > MCP > Client MCP:** confirme que Short Video Maker, AutoVio, OpenMontage e OpenCut aparecem com as portas padrão editáveis. O estado **Activo** é uma preferência local; a detecção deve indicar **Não detectado** quando os serviços externos não estiverem instalados ou iniciados.
@@ -387,13 +393,13 @@ Ao abrir a página, o Thunderbolt prepara automaticamente os dados públicos atr
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. A análise inicial é automática; o botão **Analisar Nichos** recalcula os resultados depois de alterar os filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.31 install`; o instalador detecta e reutiliza o que já estiver válido.
+As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.33 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ## Pipeline: Criação de Vídeos, Criação de Músicas e Automação
 
 O modo `Pexels/Pixabay` representa materiais de stock. Ao seleccionar `full_ia`, o selector `Estilo IA` apresenta os 12 estilos disponíveis. Ao seleccionar `Apenas Música`, a UI obriga a escolher uma música existente, carregar um ficheiro ou solicitar uma música a um endpoint Suno configurado. O vídeo recebe `background_mode=none`, sem fundo Pexels/Pixabay ou IA.
 
-A aba **Automação** lista os canais e vídeos, permite escolher e guardar **Blueprint padrão** e **Voz padrão** por canal, guarda **Automação ON** e valida horários diários no formato `HH:MM`. Os valores ficam sincronizados com o editor existente no cartão da aba **Canais** e são copiados para novas tarefas. É apenas uma camada de UI nesta versão, sem execução de worker.
+A aba **Automação** lista os canais e vídeos, permite escolher e guardar **Blueprint padrão** e **Voz padrão** por canal, guarda **Automação ON** e valida horários diários no formato `HH:MM`. Os valores ficam sincronizados com o editor existente no cartão da aba **Canais** e são copiados para novas tarefas. O launcher inicia o worker local, que consulta o relógio do computador, cria lotes agendados na fila e evita duplicar o mesmo canal no mesmo dia.
 
 A área **Teste de vozes**, dentro de **Configurações > Configurações Técnicas**, é isolada da pipeline. O preview pode ser reproduzido e descarregado de `storage/voice_previews/`. Caminhos vazios, directórios, ficheiros vazios e previews sem permissões de leitura são ignorados com uma mensagem clara, sem traceback. Se uma instalação antiga mostrar que `edge-tts` está em falta, execute `npx.cmd --yes @danhachuel/thunderbolt install`; o detector reinstala apenas a dependência ausente.
 

package/README.md

@@ -16,7 +16,7 @@ A primeira versão implementa a camada UI independente com:
 | Brandings | Subaba própria dentro de Blueprints, upload/listagem de Brandings e criação conjunta com Blueprint |
 | Canais | Subabas de importação pública sem API Key, Data API opcional e cadastro manual independente |
 | Criação de Vídeos / Criação de Músicas | Subabas Criar vídeo e Vídeos; lotes; 51 rótulos de idioma; Pexels/Pixabay, full IA com Estilo IA e Apenas Música com agente musical; a segunda página reutiliza o mesmo fluxo com título próprio |
-| Automação | Lista de vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON e horário diário HH:MM; UI configurável sem worker em segundo plano |
+| Automação | Lista de vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON, horário diário HH:MM e worker local baseado no relógio do computador |
 | Niche Finder | Preparação e análise automáticas, filtros, K-Means, FP-Growth, regras de associação, clusters e gráfico Plotly nativo |
 | Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo experimental, TikTok, Instagram e Facebook Pages no front end |
 | MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
@@ -26,7 +26,7 @@ A primeira versão implementa a camada UI independente com:
 
 Os adaptadores do MoneyPrinterTurbo e de publicação nas plataformas são ligados pelas configurações locais e pelos pontos de integração em `integrations/`. A UI não inventa dados quando um serviço externo ou credencial não está disponível.
 
-## Navegação da UI 0.2.32
+## Navegação da UI 0.2.33
 
 A barra lateral mantém apenas os cinco níveis principais, nesta ordem: **Início**, **Pipeline**, **Automação**, **Niche Finder** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas**, **Upload** e **Limpador de Metadados**. **Configurações** é expansível e contém **Canais**, **Blueprints**, **MCP** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
 
@@ -63,6 +63,12 @@ node scripts/cli.mjs --check
 node scripts/cli.mjs
 ```
 
+O comando normal inicia a UI e o worker local de Automação. O worker verifica o relógio local do computador e coloca na fila os lotes de canais com **Automação ON** quando o horário `HH:MM` coincide. Para executar apenas o worker, sem abrir a UI:
+
+```bash
+node scripts/cli.mjs worker
+```
+
 O pacote está publicado no npm como `@danhachuel/thunderbolt` e pode ser executado directamente via `npx`:
 
 ```bash
@@ -109,9 +115,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.32 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.32 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.32
+npx.cmd --yes @danhachuel/thunderbolt@0.2.33 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.33 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.33
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:

package/app/main.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import json
 import re
-from datetime import date
+from datetime import date, datetime
 import sys
 from pathlib import Path
 
@@ -18,6 +18,7 @@ except (OSError, json.JSONDecodeError):
     APP_VERSION = ""
 
 from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, pipeline_summary, set_channel_defaults, transition_task, update_channel
+from hermes_ui.automation_worker import load_worker_status
 from hermes_ui.storage import BLUEPRINTS, ensure_storage, list_blueprint_files, load_blueprint_file, now, read_json, write_json
 from app.modules.niche_finder.core import NicheAnalysisError, run_niche_analysis
 from app.modules.niche_finder.data_loader import DatasetError, download_kaggle_dataset, load_dataframe
@@ -788,8 +789,18 @@ def render_videos():
 
 def render_automation():
     st.title("Automação")
-    st.caption("Agendamento diário da geração por canal. Esta versão configura e guarda a UI; não inicia gerações em segundo plano.")
-    st.info("A geração só será executada quando existir um worker/agendador ligado à pipeline. Activar Automação ON não inicia um processo automaticamente nesta etapa.")
+    st.caption("Agendamento diário da geração por canal. O worker verifica o relógio local do computador e coloca os lotes agendados na fila.")
+    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.")
+    last_tick = worker_status.get("last_tick_local")
+    if last_tick:
+        st.caption(f"Última verificação do worker: {last_tick}")
+    if worker_status.get("last_error"):
+        st.error(f"Último erro do worker: {worker_status['last_error']}")
     channels = read_json("channels.json", [])
     if not channels:
         st.info("Nenhum canal cadastrado para configurar.")

package/hermes_ui/automation_worker.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import argparse
+import os
+import time
+from datetime import datetime, tzinfo
+from pathlib import Path
+from typing import Any
+
+from . import storage
+from .domain import create_batch, create_tasks_for_batch
+
+WORKER_STATE_FILE = "automation_worker.json"
+LOCK_FILENAME = "automation_worker.lock"
+DEFAULT_INTERVAL_SECONDS = 10
+DEFAULT_STATE: dict[str, Any] = {
+    "worker_started_at": None,
+    "worker_pid": None,
+    "last_heartbeat_local": None,
+    "last_tick_local": None,
+    "last_error": "",
+    "last_runs": {},
+}
+
+
+def _local_now() -> datetime:
+    """Return the local wall-clock time of the computer running Thunderbolt."""
+    return datetime.now().astimezone()
+
+
+def _local_iso(value: datetime) -> str:
+    return value.astimezone().isoformat(timespec="seconds")
+
+
+def _state() -> dict[str, Any]:
+    saved = storage.read_json(WORKER_STATE_FILE, DEFAULT_STATE)
+    if not isinstance(saved, dict):
+        saved = {}
+    merged = {**DEFAULT_STATE, **saved}
+    if not isinstance(merged.get("last_runs"), dict):
+        merged["last_runs"] = {}
+    return merged
+
+
+def load_worker_status() -> dict[str, Any]:
+    """Read status displayed by the Automação page without starting a worker."""
+    status = _state()
+    heartbeat = str(status.get("last_heartbeat_local") or "")
+    status["alive"] = False
+    if heartbeat:
+        try:
+            heartbeat_at = datetime.fromisoformat(heartbeat)
+            status["alive"] = (datetime.now().astimezone() - heartbeat_at.astimezone()).total_seconds() <= 30
+        except ValueError:
+            status["alive"] = False
+    return status
+
+
+def _write_status(status: dict[str, Any]) -> None:
+    storage.write_json(WORKER_STATE_FILE, {**DEFAULT_STATE, **status})
+
+
+def _pid_alive(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
+def _acquire_lock() -> Path | None:
+    lock_path = storage.STORAGE / LOCK_FILENAME
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        descriptor = os.open(lock_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+    except FileExistsError:
+        try:
+            old_pid = int(lock_path.read_text(encoding="utf-8").strip())
+        except (OSError, ValueError):
+            old_pid = 0
+        if _pid_alive(old_pid):
+            return None
+        try:
+            lock_path.unlink()
+        except OSError:
+            return None
+        try:
+            descriptor = os.open(lock_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+        except FileExistsError:
+            return None
+    try:
+        os.write(descriptor, str(os.getpid()).encode("ascii"))
+    finally:
+        os.close(descriptor)
+    return lock_path
+
+
+def _release_lock(lock_path: Path | None) -> None:
+    if lock_path is not None:
+        try:
+            lock_path.unlink()
+        except OSError:
+            pass
+
+
+def _valid_schedule(value: Any) -> bool:
+    text = str(value or "").strip()
+    if len(text) != 5 or text[2] != ":":
+        return False
+    try:
+        hour, minute = (int(part) for part in text.split(":"))
+    except ValueError:
+        return False
+    return 0 <= hour <= 23 and 0 <= minute <= 59
+
+
+def _daily_quantity(channel: dict[str, Any]) -> int:
+    try:
+        return max(1, min(100, int(channel.get("daily_limit", 1))))
+    except (TypeError, ValueError):
+        return 1
+
+
+def _automation_topic(channel: dict[str, Any]) -> str:
+    topic = str(channel.get("automation_topic") or "").strip()
+    return topic or f"Geração automática — {channel.get('name') or 'Canal'}"
+
+
+def _batch_for_day(channel_id: str, day: str) -> dict[str, Any] | None:
+    batches = storage.read_json("batches.json", [])
+    if not isinstance(batches, list):
+        return None
+    for batch in reversed(batches):
+        if not isinstance(batch, dict) or channel_id not in (batch.get("channel_ids") or []):
+            continue
+        options = batch.get("options") or {}
+        if options.get("automation_worker") is True and options.get("automation_date") == day:
+            return batch
+    return None
+
+
+def _tasks_for_batch(batch_id: str) -> list[dict[str, Any]]:
+    tasks = storage.read_json("tasks.json", [])
+    return [task for task in tasks if isinstance(task, dict) and task.get("batch_id") == batch_id]
+
+
+def _create_channel_batch(channel: dict[str, Any], when: datetime) -> dict[str, Any]:
+    channel_id = str(channel["id"])
+    date_key = when.date().isoformat()
+    style_wide = str(channel.get("style_wide") or "pexels")
+    music_mode = style_wide == "music"
+    options = {
+        "language": channel.get("language") or "Português",
+        "format": "wide",
+        "style_wide": style_wide,
+        "style_ia": channel.get("style_ia") or "",
+        "music_mode": music_mode,
+        "background_mode": "none" if music_mode else ("ai" if style_wide == "full_ia" else "stock"),
+        "music_path": channel.get("music_path") or "",
+        "music_source": channel.get("music_source") or "",
+        "automation_worker": True,
+        "automation_date": date_key,
+        "automation_scheduled_at": _local_iso(when),
+    }
+    batch = create_batch(
+        "single",
+        [channel_id],
+        _automation_topic(channel),
+        _daily_quantity(channel),
+        options,
+    )
+    tasks = create_tasks_for_batch(batch)
+    return {"batch": batch, "tasks": tasks, "channel_id": channel_id}
+
+
+def run_once(when: datetime | None = None) -> dict[str, Any]:
+    """Run one deterministic local-time tick; safe to call from tests or a worker loop."""
+    current = when.astimezone() if when is not None and when.tzinfo else (when or _local_now())
+    current_minute = current.strftime("%H:%M")
+    day = current.date().isoformat()
+    status = _state()
+    status["last_tick_local"] = _local_iso(current)
+    status["last_heartbeat_local"] = _local_iso(current)
+    status["last_error"] = ""
+    created: list[dict[str, Any]] = []
+    skipped: list[str] = []
+    channels = storage.read_json("channels.json", [])
+    if not isinstance(channels, list):
+        channels = []
+    try:
+        for channel in channels:
+            if not isinstance(channel, dict):
+                continue
+            channel_id = str(channel.get("id") or "")
+            if not channel_id or not bool(channel.get("active", True)) or not bool(channel.get("automation_on", False)):
+                continue
+            if not _valid_schedule(channel.get("automation_time")) or str(channel.get("automation_time")).strip() != current_minute:
+                continue
+            existing = _batch_for_day(channel_id, day)
+            if existing:
+                existing_tasks = _tasks_for_batch(str(existing.get("id") or ""))
+                if not existing_tasks:
+                    existing_tasks = create_tasks_for_batch(existing)
+                skipped.append(channel_id)
+                continue
+            created.append(_create_channel_batch(channel, current))
+        for item in created:
+            batch = item["batch"]
+            status["last_runs"][item["channel_id"]] = {
+                "date": day,
+                "time": current_minute,
+                "batch_id": batch["id"],
+                "task_ids": [task["id"] for task in item["tasks"]],
+            }
+        _write_status(status)
+        return {
+            "ok": True,
+            "local_time": _local_iso(current),
+            "scheduled_time": current_minute,
+            "created": created,
+            "skipped": skipped,
+        }
+    except Exception as exc:
+        status["last_error"] = str(exc)
+        _write_status(status)
+        return {"ok": False, "local_time": _local_iso(current), "error": str(exc), "created": created}
+
+
+def run_worker(interval_seconds: int = DEFAULT_INTERVAL_SECONDS) -> None:
+    storage.ensure_storage()
+    lock_path = _acquire_lock()
+    if lock_path is None:
+        raise RuntimeError("Já existe um worker de automação activo para este storage do Thunderbolt.")
+    started = _local_now()
+    status = _state()
+    status.update({"worker_started_at": _local_iso(started), "worker_pid": os.getpid(), "last_error": ""})
+    _write_status(status)
+    try:
+        while True:
+            result = run_once()
+            if not result.get("ok"):
+                print(f"Thunderbolt worker: erro: {result.get('error')}", flush=True)
+            elif result.get("created"):
+                print(f"Thunderbolt worker: {len(result['created'])} canal(is) agendado(s) às {result['scheduled_time']}.", flush=True)
+            time.sleep(max(2, int(interval_seconds)))
+    finally:
+        current = _state()
+        current["worker_pid"] = None
+        current["last_heartbeat_local"] = None
+        _write_status(current)
+        _release_lock(lock_path)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Worker local de automação diária do Thunderbolt")
+    parser.add_argument("--once", action="store_true", help="Executa apenas um tick usando o relógio local")
+    parser.add_argument("--interval", type=int, default=DEFAULT_INTERVAL_SECONDS, help="Intervalo de verificação em segundos")
+    args = parser.parse_args()
+    if args.once:
+        storage.ensure_storage()
+        print(run_once(), flush=True)
+        return
+    run_worker(args.interval)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

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

package/scripts/cli.mjs

@@ -133,10 +133,39 @@ if (!existsSync(main)) {
   process.exit(1);
 }
 ensureRuntimeStorage();
+const storageDir = process.env.THUNDERBOLT_STORAGE_DIR || join(thunderboltHome, "storage");
+const runtimeEnv = {
+  ...process.env,
+  THUNDERBOLT_STORAGE_DIR: storageDir,
+  STREAMLIT_BROWSER_GATHER_USAGE_STATS: "false",
+  STREAMLIT_SERVER_HEADLESS: "true",
+};
+
+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");
+}
+
 const port = process.env.THUNDERBOLT_PORT || process.env.HERMES_PORT || "3030";
+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"], {
   cwd: root,
   stdio: "inherit",
-  env: { ...process.env, THUNDERBOLT_STORAGE_DIR: process.env.THUNDERBOLT_STORAGE_DIR || join(thunderboltHome, "storage") },
+  env: runtimeEnv,
+  windowsHide: false,
+});
+
+const stopWorker = () => {
+  if (!worker.killed) worker.kill();
+};
+process.on("SIGINT", stopWorker);
+process.on("SIGTERM", stopWorker);
+child.on("exit", (code, signal) => {
+  stopWorker();
+  process.exit(code ?? (signal ? 1 : 0));
 });
-child.on("exit", (code, signal) => process.exit(code ?? (signal ? 1 : 0)));
+worker.on("error", (error) => console.error(`Thunderbolt worker: ${error.message}`));