@danhachuel/thunderbolt 0.4.91 → 0.4.93

package/app/main.py

@@ -4,12 +4,16 @@ import io
 
 os.environ["PYTHONIOENCODING"] = "utf-8"
 os.environ["PYTHONUTF8"] = "1"
+os.environ["CLICK_NO_WIN_CONSOLE"] = "1"
 
 def _force_utf8_stream(stream: object) -> object:
+    if os.name != "nt":
+        return stream
     buffer = getattr(stream, "buffer", None)
-    encoding = str(getattr(stream, "encoding", "") or "").lower().replace("-", "_")
-    if buffer is not None and encoding != "utf_8":
-        return io.TextIOWrapper(buffer, encoding="utf-8", errors="replace", line_buffering=True)
+    if buffer is not None and not getattr(stream, "_thunderbolt_utf8", False):
+        wrapped = io.TextIOWrapper(buffer, encoding="utf-8", errors="replace", line_buffering=True)
+        setattr(wrapped, "_thunderbolt_utf8", True)
+        return wrapped
     return stream
 
 _original_stdout, _original_stderr = sys.stdout, sys.stderr
@@ -102,6 +106,7 @@ from hermes_ui.thumbnails import (
 from hermes_ui.draft_video import DRAFT_SETTING_SECTIONS, missing_content_fields, missing_setting_sections, normalise_saved_script, setting_widget_suffixes
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_thumbnail_prompt, generate_title_and_keywords, generate_topic_for_channel, generate_video_description, generate_video_keywords, generate_video_update_metadata
 from hermes_ui.media_generation import MediaGenerationError, format_media_generation_error, generate_image_for_card, generate_video_for_card
+from hermes_ui.canva_auth import authorization_url, create_pkce_pair, create_state, exchange_code
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
 from integrations.tiktok_public import fetch_public_tiktok_profile, normalize_tiktok_reference
 from integrations.youtube_update import YOUTUBE_UPDATE_VIDEO, YouTubeVideoUpdater
@@ -7060,7 +7065,7 @@ def _media_card_config_status(card: dict[str, Any]) -> tuple[str, str]:
         return "missing", "Missing key"
     if not str(card.get("base_url") or "").strip():
         return "missing", "Missing Base URL"
-    if not str(card.get("model") or "").strip() and card.get("supports_image") and card.get("provider") not in {"cloudflare_workers_ai"}:
+    if not str(card.get("model") or "").strip() and card.get("supports_image") and card.get("provider") not in {"cloudflare_workers_ai", "canva"}:
         return "missing", "Missing model"
     return "ready", "Configured"
 
@@ -7096,6 +7101,26 @@ def _render_media_provider_card(settings: dict[str, Any], cards: list[dict[str,
     cards[index] = card
     card_id = str(card["id"])
     definition = media_provider_definition(card.get("provider"))
+    if card.get("provider") == "canva":
+        callback_code = str(st.query_params.get("code") or "").strip()
+        callback_state = str(st.query_params.get("state") or "").strip()
+        pending_state = str(st.session_state.get(f"canva_state_{card_id}") or "")
+        if callback_code:
+            if callback_state != pending_state:
+                st.error("Canva OAuth rejeitado: state inválido. Inicie a autorização novamente.")
+            else:
+                try:
+                    token = exchange_code(str(card.get("client_id") or ""), str(card.get("client_secret") or ""), callback_code, str(card.get("redirect_uri") or ""), str(st.session_state.get(f"canva_verifier_{card_id}") or ""))
+                    card["oauth_token"] = token
+                    cards[index] = card
+                    _persist_media_cards(settings, cards, str(settings.get(MEDIA_IMAGE_ACTIVE_CARD_KEY) or ""), str(settings.get(MEDIA_VIDEO_ACTIVE_CARD_KEY) or ""))
+                    st.session_state.pop(f"canva_state_{card_id}", None)
+                    st.session_state.pop(f"canva_verifier_{card_id}", None)
+                    st.query_params.clear()
+                    st.success("Canva autorizada com sucesso.")
+                    st.rerun()
+                except Exception as exc:
+                    st.error(f"Não foi possível autorizar a Canva: {str(exc)[:240]}")
     with st.container(border=True):
         header_cols = st.columns([3.2, 1.2])
         with header_cols[0]:
@@ -7139,14 +7164,29 @@ def _render_media_provider_card(settings: dict[str, Any], cards: list[dict[str,
                 extra_cols = st.columns(len(definition.extra_fields))
                 for extra_col, field_name in zip(extra_cols, definition.extra_fields):
                     with extra_col:
-                        extra_values[field_name] = st.text_input(field_name.replace("_", " ").title(), value=str(card.get(field_name) or ""), key=f"media_card_{card_id}_{field_name}")
+                        extra_values[field_name] = st.text_input(field_name.replace("_", " ").title(), value=str(card.get(field_name) or ""), type="password" if field_name == "client_secret" else "default", key=f"media_card_{card_id}_{field_name}")
+            if definition.code == "canva":
+                supports_image = True
+                supports_video = False
+                st.caption("Canva Connect é usado exclusivamente para thumbnails no Pool de Imagem. Não é provider de vídeo.")
+                redirect_uri = str(card.get("redirect_uri") or "").strip()
+                if not redirect_uri:
+                    st.info("Defina o Redirect URI no Developer Portal Canva e repita-o neste card antes de autorizar.")
+                elif str(card.get("client_id") or "").strip() and str(card.get("client_secret") or "").strip():
+                    if st.button("Autorizar Canva", key=f"media_card_{card_id}_authorize"):
+                        verifier, challenge = create_pkce_pair()
+                        state = create_state()
+                        st.session_state[f"canva_verifier_{card_id}"] = verifier
+                        st.session_state[f"canva_state_{card_id}"] = state
+                        st.link_button("Abrir autorização Canva", authorization_url(str(card.get("client_id")), redirect_uri, "design:content:read design:content:write", state, challenge), use_container_width=True)
+                st.caption("Estado OAuth: autorizado" if (card.get("oauth_token") or {}).get("access_token") else "Estado OAuth: não autorizado")
             status_cols = st.columns(4)
             with status_cols[0]:
                 enabled = st.checkbox("Provider activo", value=bool(card.get("enabled", True)), key=f"media_card_{card_id}_enabled")
             with status_cols[1]:
                 supports_image = st.checkbox("Pool Imagem", value=bool(card.get("supports_image", definition.supports_image)), key=f"media_card_{card_id}_image")
             with status_cols[2]:
-                supports_video = st.checkbox("Pool Vídeo", value=bool(card.get("supports_video", definition.supports_video)), key=f"media_card_{card_id}_video")
+                supports_video = False if definition.code == "canva" else st.checkbox("Pool Vídeo", value=bool(card.get("supports_video", definition.supports_video)), key=f"media_card_{card_id}_video")
             with status_cols[3]:
                 priority = st.number_input("Prioridade", min_value=0, max_value=999, value=int(card.get("priority", index)), step=1, key=f"media_card_{card_id}_priority")
             action_cols = st.columns(4)

package/hermes_ui/canva_auth.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import secrets
+import time
+from typing import Any, Mapping
+from urllib.parse import urlencode
+
+import requests
+
+AUTHORIZE_URL = "https://www.canva.com/api/oauth/authorize"
+TOKEN_URL = "https://api.canva.com/rest/v1/oauth/token"
+
+
+def _b64(value: bytes) -> str:
+    return base64.urlsafe_b64encode(value).rstrip(b"=").decode("ascii")
+
+
+def create_pkce_pair() -> tuple[str, str]:
+    verifier = _b64(secrets.token_bytes(64))
+    challenge = _b64(hashlib.sha256(verifier.encode("ascii")).digest())
+    return verifier, challenge
+
+
+def create_state() -> str:
+    return _b64(secrets.token_bytes(48))
+
+
+def authorization_url(client_id: str, redirect_uri: str, scope: str, state: str, code_challenge: str) -> str:
+    params = {
+        "code_challenge": code_challenge,
+        "code_challenge_method": "S256",
+        "scope": " ".join(str(scope or "").split()),
+        "response_type": "code",
+        "client_id": str(client_id).strip(),
+        "state": str(state).strip(),
+        "redirect_uri": str(redirect_uri).strip(),
+    }
+    return f"{AUTHORIZE_URL}?{urlencode(params)}"
+
+
+def exchange_code(client_id: str, client_secret: str, code: str, redirect_uri: str, code_verifier: str, *, timeout: int = 30) -> dict[str, Any]:
+    response = requests.post(
+        TOKEN_URL,
+        data={
+            "grant_type": "authorization_code",
+            "code": code,
+            "code_verifier": code_verifier,
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "redirect_uri": redirect_uri,
+        },
+        headers={"Accept": "application/json"},
+        timeout=timeout,
+    )
+    if response.status_code >= 400:
+        raise RuntimeError(f"Canva OAuth devolveu HTTP {response.status_code}: {response.text[:240]}")
+    payload = response.json()
+    if not payload.get("access_token"):
+        raise RuntimeError("Canva OAuth não devolveu access_token.")
+    return _with_expiry(payload)
+
+
+def refresh_access_token(client_id: str, client_secret: str, refresh_token: str, *, timeout: int = 30) -> dict[str, Any]:
+    response = requests.post(
+        TOKEN_URL,
+        data={
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "client_id": client_id,
+            "client_secret": client_secret,
+        },
+        headers={"Accept": "application/json"},
+        timeout=timeout,
+    )
+    if response.status_code >= 400:
+        raise RuntimeError(f"Refresh Canva devolveu HTTP {response.status_code}: {response.text[:240]}")
+    return _with_expiry(response.json())
+
+
+def _with_expiry(payload: Mapping[str, Any]) -> dict[str, Any]:
+    result = dict(payload)
+    try:
+        result["expires_at"] = int(time.time()) + max(0, int(payload.get("expires_in", 0)))
+    except (TypeError, ValueError):
+        result["expires_at"] = 0
+    return result
+
+
+def token_is_expiring(token: Mapping[str, Any], margin_seconds: int = 90) -> bool:
+    try:
+        return int(token.get("expires_at", 0)) <= int(time.time()) + margin_seconds
+    except (TypeError, ValueError):
+        return True

package/hermes_ui/canva_client.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, Mapping
+
+import requests
+
+from .canva_auth import refresh_access_token, token_is_expiring
+
+API_ROOT = "https://api.canva.com/rest/v1"
+
+
+class CanvaClient:
+    def __init__(self, card: Mapping[str, Any], *, token_saver=None) -> None:
+        self.card = dict(card)
+        self.token_saver = token_saver
+        self.client_id = str(card.get("client_id") or "").strip()
+        self.client_secret = str(card.get("client_secret") or "").strip()
+        self.token = dict(card.get("oauth_token") or {})
+        self.base_url = str(card.get("base_url") or API_ROOT).rstrip("/")
+
+    def _save_token(self, token: Mapping[str, Any]) -> None:
+        self.token = dict(token)
+        if self.token_saver:
+            self.token_saver(self.token)
+
+    def _access_token(self) -> str:
+        if not self.token.get("access_token"):
+            raise RuntimeError("Canva não está autorizada. Autorize a integração em Configuração API > Imagem e Video IA.")
+        if token_is_expiring(self.token):
+            refresh = str(self.token.get("refresh_token") or "").strip()
+            if not refresh:
+                raise RuntimeError("O token Canva expirou e não existe refresh token. Autorize novamente.")
+            self._save_token(refresh_access_token(self.client_id, self.client_secret, refresh))
+        return str(self.token["access_token"])
+
+    def request(self, method: str, path: str, *, json: Mapping[str, Any] | None = None, timeout: int = 60) -> dict[str, Any]:
+        refreshed = False
+        for attempt in range(4):
+            try:
+                token = self._access_token()
+                response = requests.request(method, f"{self.base_url}/{path.lstrip('/')}", headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json", "Accept": "application/json"}, json=json, timeout=timeout)
+            except requests.RequestException as exc:
+                if attempt == 3:
+                    raise RuntimeError(f"Falha de rede na Canva: {str(exc)[:200]}") from exc
+                time.sleep(2 ** attempt)
+                continue
+            if response.status_code == 401 and not refreshed and self.token.get("refresh_token"):
+                self._save_token(refresh_access_token(self.client_id, self.client_secret, str(self.token["refresh_token"])))
+                refreshed = True
+                continue
+            if response.status_code == 429:
+                if attempt == 3:
+                    raise RuntimeError("Canva devolveu HTTP 429: limite de pedidos atingido.")
+                time.sleep(2 ** attempt)
+                continue
+            if response.status_code >= 400:
+                raise RuntimeError(f"Canva devolveu HTTP {response.status_code}: {response.text[:240]}")
+            return response.json()
+        raise RuntimeError("Canva não respondeu após as tentativas disponíveis.")
+
+    def create_design(self, width: int = 1280, height: int = 720, *, title: str = "Thunderbolt thumbnail") -> dict[str, Any]:
+        if not (40 <= width <= 8000 and 40 <= height <= 8000 and width * height <= 25_000_000):
+            raise ValueError("Dimensões Canva inválidas: cada dimensão deve estar entre 40 e 8000 e a área não pode exceder 25.000.000 px².")
+        return self.request("POST", "designs", json={"type": "type_and_asset", "design_type": {"type": "custom", "width": width, "height": height}, "title": title})
+
+    def export_design(self, design_id: str, *, file_type: str = "png", quality: str = "regular") -> str:
+        if file_type not in {"png", "jpg"}:
+            raise ValueError("A Canva thumbnail só suporta PNG ou JPG.")
+        if quality not in {"regular", "pro"}:
+            raise ValueError("A qualidade Canva deve ser regular ou pro.")
+        payload = self.request("POST", "exports", json={"design_id": design_id, "format": {"type": file_type, "export_quality": quality}})
+        job = payload.get("job") or payload
+        job_id = str(job.get("id") or "").strip()
+        if not job_id:
+            raise RuntimeError("Canva não devolveu o ID do job de exportação.")
+        return job_id
+
+    def get_export_job_status(self, job_id: str) -> dict[str, Any]:
+        return self.request("GET", f"exports/{job_id}", json=None)
+
+    def wait_export(self, job_id: str, *, attempts: int = 30, interval: float = 2.0) -> str:
+        for _ in range(attempts):
+            payload = self.get_export_job_status(job_id)
+            job = payload.get("job") or payload
+            status = str(job.get("status") or "").lower()
+            if status == "success" and job.get("urls"):
+                return str(job["urls"][0])
+            if status == "failed":
+                error = job.get("error") or {}
+                raise RuntimeError(f"Exportação Canva falhou: {error.get('code') or error}")
+            time.sleep(interval)
+        raise RuntimeError("A exportação Canva excedeu o tempo de espera.")
+
+    def download_export(self, url: str, destination: Path) -> Path:
+        try:
+            response = requests.get(url, timeout=90)
+            response.raise_for_status()
+        except requests.RequestException as exc:
+            raise RuntimeError(f"Não foi possível descarregar a thumbnail Canva: {str(exc)[:200]}") from exc
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_bytes(response.content)
+        return destination
+
+    def create_and_export_thumbnail(self, *, title: str, width: int = 1280, height: int = 720) -> Path:
+        design = self.create_design(width, height, title=title)
+        design_id = str((design.get("design") or design).get("id") or "")
+        if not design_id:
+            raise RuntimeError("Canva não devolveu o ID do design.")
+        job_id = self.export_design(design_id, file_type=str(self.card.get("export_format") or "png"), quality=str(self.card.get("export_quality") or "regular"))
+        url = self.wait_export(job_id)
+        destination = Path(str(self.card.get("output_path") or "thumbnail-canva.png"))
+        return self.download_export(url, destination)

package/hermes_ui/media_generation.py

@@ -38,8 +38,9 @@ from .provider_routing import (
     ProviderRoutingError,
     route_json_request,
 )
-from .storage import STORAGE, ensure_storage
+from .storage import STORAGE, ensure_storage, write_json
 from .thumbnail_generation import _compose_thumbnail_prompt, generate_thumbnail_image, normalize_thumbnail_bytes
+from .canva_client import CanvaClient
 
 
 class MediaGenerationError(RuntimeError):
@@ -327,6 +328,27 @@ def generate_image_for_card(
     """Generate one image with the selected media card."""
     card = dict(card)
     provider = str(card.get("provider") or "").strip().lower()
+    if provider == "canva":
+        ensure_storage()
+        export_format = str(card.get("export_format") or "png").lower()
+        destination = STORAGE / "thumbnails" / f"canva-{abs(hash((topic, prompt, variant_index))) & 0xffffffffffffffff:x}.{export_format if export_format in {'png', 'jpg'} else 'png'}"
+        card["output_path"] = str(destination)
+        def save_token(token: Mapping[str, Any]) -> None:
+            updated = dict(settings)
+            saved_cards = [dict(item) for item in updated.get("media_provider_cards", []) if isinstance(item, Mapping)]
+            for saved_card in saved_cards:
+                if str(saved_card.get("id")) == str(card.get("id")):
+                    saved_card["oauth_token"] = dict(token)
+            updated["media_provider_cards"] = saved_cards
+            write_json("settings.json", updated)
+        try:
+            return CanvaClient(card, token_saver=save_token).create_and_export_thumbnail(
+                title=str(topic or "Thunderbolt thumbnail")[:255],
+                width=int(card.get("thumbnail_width") or 1280),
+                height=int(card.get("thumbnail_height") or 720),
+            )
+        except Exception as exc:
+            raise MediaGenerationError(str(exc)) from exc
     if provider == "nano_banana":
         merged = dict(settings)
         merged["gemini_image_api_key"] = _api_key(card)
@@ -394,9 +416,10 @@ def generate_image_from_pool(
     lettering_text: str = "",
     lettering_prompt: str = "",
     reference_image: Path | None = None,
+    thumbnail_only: bool = False,
 ) -> Path:
     """Try eligible image cards in priority order, without cross-pool fallback."""
-    cards = media_cards_for_pool(settings, "image")
+    cards = media_cards_for_pool(settings, "image", thumbnail_only=True) if thumbnail_only else media_cards_for_pool(settings, "image")
     if not cards:
         raise MediaGenerationError("Não existem providers activos no pool de imagem.")
     errors: list[str] = []

package/hermes_ui/media_providers.py

@@ -55,6 +55,17 @@ MEDIA_PROVIDER_CATALOG: tuple[MediaProviderDefinition, ...] = (
         api_style="gemini_interactions",
         description="Geração de imagem nativa Gemini para thumbnails e artes.",
     ),
+    MediaProviderDefinition(
+        "canva",
+        "Canva Connect",
+        default_base_url="https://api.canva.com/rest/v1",
+        requires_api_key=False,
+        supports_image=True,
+        supports_video=False,
+        api_style="canva_connect",
+        extra_fields=("client_id", "client_secret", "redirect_uri", "export_quality", "export_format", "thumbnail_width", "thumbnail_height"),
+        description="Canva Connect para criação e exportação de thumbnails; não é usado no pool de vídeo.",
+    ),
     MediaProviderDefinition(
         "pollinations",
         "Pollinations.ai",
@@ -203,9 +214,12 @@ def normalize_media_card(card: Any, index: int = 0) -> dict[str, Any]:
         "supports_text": bool(source.get("supports_text", definition.supports_text)),
         "api_style": definition.api_style,
         "local": definition.local,
+        "thumbnail_only": provider == "canva",
     }
     for field in definition.extra_fields:
         result[field] = str(source.get(field) or "").strip()
+    if provider == "canva":
+        result["oauth_token"] = dict(source.get("oauth_token") or {}) if isinstance(source.get("oauth_token"), Mapping) else {}
     if provider == "nano_banana":
         result["aspect_ratio"] = str(source.get("aspect_ratio") or INTERNAL_IMAGE_ASPECT_RATIO).strip()
         result["image_size"] = str(source.get("image_size") or INTERNAL_IMAGE_SIZE).strip()
@@ -311,12 +325,14 @@ def apply_media_provider_cards_to_settings(settings: Mapping[str, Any], cards: l
     return result
 
 
-def media_cards_for_pool(settings: Mapping[str, Any], pool: str) -> list[dict[str, Any]]:
+def media_cards_for_pool(settings: Mapping[str, Any], pool: str, *, thumbnail_only: bool = False) -> list[dict[str, Any]]:
     migrated, _ = ensure_media_provider_cards(settings)
     capability = "supports_image" if pool == "image" else "supports_video" if pool == "video" else "supports_text"
     active_key = MEDIA_IMAGE_ACTIVE_CARD_KEY if pool == "image" else MEDIA_VIDEO_ACTIVE_CARD_KEY if pool == "video" else ""
     active_id = str(migrated.get(active_key) or "")
     cards = [dict(item) for item in migrated.get(MEDIA_CARDS_KEY, []) if item.get("enabled", True) and item.get(capability)]
+    if pool == "image" and not thumbnail_only:
+        cards = [card for card in cards if not card.get("thumbnail_only")]
     # A prioridade é o contrato principal do failover. O cartão activo legado
     # só serve de desempate entre cartões com a mesma prioridade, para não
     # ignorar uma escolha explícita do utilizador por causa de estado antigo.

package/hermes_ui/thumbnails.py

@@ -10,7 +10,7 @@ from typing import Any
 from .creative_generation import _language_instruction, generate_thumbnail_prompt
 from .media_generation import generate_image_from_pool
 from .media_providers import media_cards_for_pool
-from .storage import STORAGE, ensure_storage, now, read_json, update_json
+from .storage import STORAGE, ensure_storage, now, read_json, update_json, write_json
 from .thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
 from .thumbnail_blueprints import thumbnail_blueprint_for_channel
 
@@ -49,6 +49,7 @@ def _generate_image_with_pool(
         reference_image=reference_image,
         lettering_text=lettering_text,
         lettering_prompt=lettering_prompt,
+        thumbnail_only=True,
     )
 
 

package/package.json

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

package/scripts/cli.mjs

@@ -26,7 +26,7 @@ const venvPython = platform() === "win32" ? join(venvDir, "Scripts", "python.exe
 const python = process.env.THUNDERBOLT_PYTHON || process.env.HERMES_PYTHON || (existsSync(venvPython) ? venvPython : (platform() === "win32" ? "python" : "python3"));
 const main = resolve(root, "app", "main.py");
 const settingsPath = join(thunderboltHome, "storage", "state", "settings.json");
-const pythonEnvironment = { ...process.env, PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1" };
+const pythonEnvironment = { ...process.env, PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1", CLICK_NO_WIN_CONSOLE: "1" };
 
 function run(command, commandArgs, label = "comando", environment = process.env) {
   console.log(`Thunderbolt: a iniciar ${label}...`);
@@ -155,6 +155,7 @@ const runtimeEnv = {
   ...process.env,
   PYTHONIOENCODING: "utf-8",
   PYTHONUTF8: "1",
+  CLICK_NO_WIN_CONSOLE: "1",
   THUNDERBOLT_STORAGE_DIR: storageDir,
   STREAMLIT_BROWSER_GATHER_USAGE_STATS: "false",
   STREAMLIT_SERVER_HEADLESS: "true",
@@ -257,7 +258,7 @@ function startStreamlit() {
   child = spawn(python, ["-m", "streamlit", "run", main, "--server.port", String(backendPort), "--server.address", "127.0.0.1"], {
     cwd: root,
     stdio: "inherit",
-    env: { ...runtimeEnv, PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1", THUNDERBOLT_LAUNCHER_RESTART: "1" },
+    env: { ...runtimeEnv, PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1", CLICK_NO_WIN_CONSOLE: "1", THUNDERBOLT_LAUNCHER_RESTART: "1" },
     windowsHide: false,
   });
   child.on("error", (error) => {

package/scripts/install.mjs

@@ -42,7 +42,7 @@ const defaultMpt = process.env.MONEYPRINTER_PATH || join(thunderboltHome, "Money
 const dependencyStatePath = join(thunderboltHome, "storage", "state", "install-state.json");
 const forceDeps = args.includes("--force-deps");
 const refreshMoneyPrinter = args.includes("--refresh-moneyprinter");
-const pythonEnvironment = { ...process.env, PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1" };
+const pythonEnvironment = { ...process.env, PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1", CLICK_NO_WIN_CONSOLE: "1" };
 
 function legacyRoots() {
   const userProfile = process.env.USERPROFILE || home;