@danhachuel/thunderbolt 0.5.8 → 0.5.11

package/app/main.py

@@ -7169,6 +7169,7 @@ def _render_media_provider_card(settings: dict[str, Any], cards: list[dict[str,
             if definition.code == "canva":
                 base_url = definition.default_base_url
                 st.text_input("Base URL", value=base_url, disabled=True, key=f"media_card_{card_id}_base_url_display")
+                st.caption("Canva MCP directo: https://mcp.canva.com/mcp — a autenticação MCP é aberta pelo Thunderbolt na primeira utilização.")
             else:
                 base_url = st.text_input("Base URL", value=str(card.get("base_url") or definition.default_base_url), key=f"media_card_{card_id}_base_url")
             extra_values: dict[str, str] = {}

package/app/modules/canva_skills/thumbnail_workflow.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from hermes_ui.thumbnail_blueprints import thumbnail_blueprint_for_channel
+
+
+class CanvaThumbnailWorkflowError(RuntimeError):
+    """Raised when a Canva thumbnail workflow cannot complete safely."""
+
+
+def _keywords(text: str) -> list[str]:
+    words = re.findall(r"[\wÀ-ÿ]{3,}", str(text or "").lower(), flags=re.UNICODE)
+    stopwords = {"para", "com", "uma", "the", "and", "from", "this", "that"}
+    return list(dict.fromkeys(word for word in words if word not in stopwords))[:8]
+
+
+def load_local_thumbnail_blueprint(channel: Mapping[str, Any] | None = None, blueprint_id: str = "") -> dict[str, Any]:
+    """Resolve the Thunderbolt-local Thumbnail Blueprint; Canva is never queried for it."""
+    context = dict(channel or {})
+    if blueprint_id:
+        context["thumbnail_blueprint_id"] = blueprint_id
+    blueprint = thumbnail_blueprint_for_channel(context)
+    content = str(blueprint.get("content") or "").strip()
+    if not content:
+        raise CanvaThumbnailWorkflowError(
+            "Nenhum Thumbnail Blueprint local foi encontrado no Thunderbolt."
+        )
+    return blueprint
+
+
+def build_search_query(title: str, topic: str = "", blueprint: Mapping[str, Any] | None = None) -> str:
+    """Build Canva search terms from the video context, not from a Canva template search."""
+    base = _keywords(f"{title} {topic}")
+    niche = _keywords(str((blueprint or {}).get("niche") or ""))
+    return " ".join((base + niche)[:10])
+
+
+def select_design(candidates: list[Mapping[str, Any]], width: int, height: int) -> dict[str, Any]:
+    """Choose an existing Canva design with the requested thumbnail dimensions."""
+    if not candidates:
+        raise CanvaThumbnailWorkflowError("A pesquisa Canva não encontrou designs para a thumbnail.")
+
+    def score(item: Mapping[str, Any]) -> tuple[int, int]:
+        thumbnail = item.get("thumbnail") if isinstance(item.get("thumbnail"), Mapping) else {}
+        item_width = int(thumbnail.get("width") or 0)
+        item_height = int(thumbnail.get("height") or 0)
+        exact = int(item_width == width and item_height == height)
+        ratio_delta = abs((item_width / item_height) - (width / height)) if item_width and item_height else 99
+        return exact, -int(ratio_delta * 1000)
+
+    return dict(max(candidates, key=score))
+
+
+def run_thumbnail_workflow(
+    *,
+    title: str,
+    topic: str,
+    channel: Mapping[str, Any] | None,
+    blueprint_id: str = "",
+    width: int = 1280,
+    height: int = 720,
+    search_designs: Callable[[str], list[Mapping[str, Any]]],
+    edit_design: Callable[[str, Mapping[str, Any], Mapping[str, Any]], Mapping[str, Any]],
+    export_design: Callable[[str, str, str, int, int], Path],
+) -> Path:
+    """Run local Blueprint -> search -> edit -> export with injected Canva operations.
+
+    The injected operations are the official Canva connector boundary. This keeps
+    local Blueprint files private and prevents the REST-only blank-design fallback.
+    """
+    blueprint = load_local_thumbnail_blueprint(channel, blueprint_id)
+    query = build_search_query(title, topic, blueprint)
+    candidates = search_designs(query)
+    selected = select_design(candidates, width, height)
+    design_id = str(selected.get("id") or "").strip()
+    if not design_id:
+        raise CanvaThumbnailWorkflowError("A pesquisa Canva devolveu um design sem design_id.")
+    changes = {
+        "title": title,
+        "topic": topic,
+        "blueprint_id": str(blueprint.get("id") or ""),
+        "blueprint_content": str(blueprint.get("content") or ""),
+        "search_query": query,
+        "lettering": title,
+        "width": width,
+        "height": height,
+    }
+    edited = dict(edit_design(design_id, changes, blueprint))
+    edited_id = str(edited.get("design_id") or design_id).strip()
+    if not edited_id or edited.get("status") in {"pending_approval", "manual_action_required"}:
+        raise CanvaThumbnailWorkflowError(
+            "A edição Canva não foi confirmada; a thumbnail não será exportada."
+        )
+    return export_design(edited_id, "png", "medium", width, height)
+
+
+__all__ = [
+    "CanvaThumbnailWorkflowError",
+    "build_search_query",
+    "load_local_thumbnail_blueprint",
+    "run_thumbnail_workflow",
+    "select_design",
+]

package/hermes_ui/api_key_tests.py

@@ -128,6 +128,20 @@ def test_nano_banana_credentials(api_key: str, model: str) -> dict[str, Any]:
     )
 
 
+def test_canva_credentials(card: Mapping[str, Any]) -> dict[str, Any]:
+    """Validate Canva with the configured API key or OAuth access token."""
+    source = dict(card) if isinstance(card, Mapping) else {}
+    api_key = str(source.get("api_key") or "").strip()
+    oauth_token = source.get("oauth_token") if isinstance(source.get("oauth_token"), Mapping) else {}
+    token = api_key or str(oauth_token.get("access_token") or "").strip()
+    if not token:
+        return _missing("Introduza a API key ou autorize o Canva antes de testar este provider.")
+    return _get(
+        "https://api.canva.com/rest/v1/users/me",
+        headers={"Authorization": f"Bearer {token}", "Accept": "application/json"},
+    )
+
+
 def test_google_lyria_credentials(api_key: str, model: str) -> dict[str, Any]:
     """Validate access to the selected Lyria model without requesting audio generation."""
     api_key = str(api_key or "").strip()
@@ -146,6 +160,8 @@ def test_media_provider_card(card: Mapping[str, Any]) -> dict[str, Any]:
     """Run a bounded, non-generative check for an image/video provider card."""
     source = dict(card) if isinstance(card, Mapping) else {}
     provider = str(source.get("provider") or "").strip().lower()
+    if provider == "canva":
+        return test_canva_credentials(source)
     api_key = str(source.get("api_key") or "").strip()
     model = str(source.get("model") or "").strip()
     base_url = str(source.get("base_url") or "").strip().rstrip("/")

package/hermes_ui/automation_worker.py

@@ -4,8 +4,6 @@ import io
 
 os.environ["PYTHONIOENCODING"] = "utf-8"
 os.environ["PYTHONUTF8"] = "1"
-os.environ["CLICK_NO_WIN_CONSOLE"] = "1"
-os.environ["PYTHONLEGACYWINDOWSSTDIO"] = "1"
 _original_stdout, _original_stderr = sys.stdout, sys.stderr
 if getattr(sys.stdout, "buffer", None) is not None and str(getattr(sys.stdout, "encoding", "") or "").lower().replace("-", "_") != "utf_8":
     sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True)

package/hermes_ui/canva_mcp_client.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+from pathlib import Path
+from typing import Any, Mapping
+
+MCP_URL = "https://mcp.canva.com/mcp"
+PROTOCOL_VERSION = "2025-06-18"
+
+
+class CanvaMCPError(RuntimeError):
+    pass
+
+
+class CanvaMCPClient:
+    """Direct local MCP client for Canva, using the official mcp-remote adapter."""
+
+    def __init__(self, *, endpoint: str = MCP_URL, timeout: int = 120) -> None:
+        self.endpoint = endpoint
+        self.timeout = timeout
+        self._next_id = 0
+        self._process: subprocess.Popen[str] | None = None
+        self._messages: queue.Queue[dict[str, Any]] = queue.Queue()
+        self._reader: threading.Thread | None = None
+
+    def _command(self) -> list[str]:
+        executable = shutil.which("npx.cmd") or shutil.which("npx") or "npx"
+        return [executable, "--yes", "mcp-remote@latest", self.endpoint]
+
+    def connect(self) -> dict[str, Any]:
+        if self._process and self._process.poll() is None:
+            return {}
+        env = {
+            **os.environ,
+            "MCP_REMOTE_QUIET": "1",
+            "PYTHONIOENCODING": "utf-8",
+            "PYTHONUTF8": "1",
+        }
+        self._process = subprocess.Popen(
+            self._command(),
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            bufsize=1,
+        )
+        self._reader = threading.Thread(target=self._read_stdout, name="canva-mcp-reader", daemon=True)
+        self._reader.start()
+        result = self.request(
+            "initialize",
+            {
+                "protocolVersion": PROTOCOL_VERSION,
+                "capabilities": {},
+                "clientInfo": {"name": "Thunderbolt", "version": "0.5.8"},
+            },
+        )
+        self.notify("notifications/initialized", {})
+        return result
+
+    def _read_stdout(self) -> None:
+        assert self._process and self._process.stdout
+        for line in self._process.stdout:
+            try:
+                message = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(message, dict):
+                self._messages.put(message)
+
+    def notify(self, method: str, params: Mapping[str, Any]) -> None:
+        self._send({"jsonrpc": "2.0", "method": method, "params": dict(params)})
+
+    def _send(self, message: Mapping[str, Any]) -> None:
+        if not self._process or self._process.poll() is not None or not self._process.stdin:
+            raise CanvaMCPError("A sessão directa Canva MCP não está ligada.")
+        self._process.stdin.write(json.dumps(message, ensure_ascii=False) + "\n")
+        self._process.stdin.flush()
+
+    def request(self, method: str, params: Mapping[str, Any]) -> dict[str, Any]:
+        self._next_id += 1
+        request_id = self._next_id
+        self._send({"jsonrpc": "2.0", "id": request_id, "method": method, "params": dict(params)})
+        deadline = time.monotonic() + self.timeout
+        while time.monotonic() < deadline:
+            try:
+                message = self._messages.get(timeout=0.5)
+            except queue.Empty:
+                if self._process and self._process.poll() is not None:
+                    raise CanvaMCPError("O processo mcp-remote terminou antes de responder.")
+                continue
+            if message.get("id") != request_id:
+                continue
+            if message.get("error"):
+                error = message["error"]
+                raise CanvaMCPError(str(error.get("message") or error))
+            result = message.get("result")
+            return result if isinstance(result, dict) else {"result": result}
+        raise CanvaMCPError(f"Timeout na operação MCP {method}.")
+
+    def tools(self) -> list[dict[str, Any]]:
+        result = self.request("tools/list", {})
+        tools = result.get("tools")
+        return [dict(tool) for tool in tools if isinstance(tool, Mapping)] if isinstance(tools, list) else []
+
+    def call(self, name: str, arguments: Mapping[str, Any] | None = None) -> dict[str, Any]:
+        result = self.request("tools/call", {"name": name, "arguments": dict(arguments or {})})
+        if result.get("isError"):
+            raise CanvaMCPError(self._text(result.get("content")) or "A ferramenta Canva devolveu erro.")
+        return result
+
+    @staticmethod
+    def _text(content: Any) -> str:
+        if isinstance(content, list):
+            return "\n".join(str(item.get("text") or "") for item in content if isinstance(item, Mapping)).strip()
+        return str(content or "").strip()
+
+    def find_tool(self, *names: str) -> str:
+        available = {str(tool.get("name")) for tool in self.tools()}
+        for name in names:
+            if name in available:
+                return name
+        raise CanvaMCPError(f"A sessão Canva MCP não disponibiliza nenhuma destas operações: {', '.join(names)}.")
+
+    def close(self) -> None:
+        if self._process and self._process.poll() is None:
+            self._process.terminate()
+            try:
+                self._process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+        self._process = None
+
+    def __enter__(self) -> "CanvaMCPClient":
+        self.connect()
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+
+__all__ = ["CanvaMCPClient", "CanvaMCPError", "MCP_URL"]

package/hermes_ui/canva_mcp_workflow.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Mapping
+
+import requests
+
+from .canva_mcp_client import CanvaMCPClient, CanvaMCPError
+
+
+def _payload(result: Mapping[str, Any]) -> Any:
+    if isinstance(result.get("structuredContent"), Mapping):
+        return result["structuredContent"]
+    content = result.get("content")
+    if isinstance(content, list):
+        for item in content:
+            if isinstance(item, Mapping) and isinstance(item.get("json"), (dict, list)):
+                return item["json"]
+            if isinstance(item, Mapping) and item.get("text"):
+                try:
+                    return json.loads(str(item["text"]))
+                except (TypeError, ValueError):
+                    continue
+    return result
+
+
+def _items(value: Any) -> list[dict[str, Any]]:
+    if isinstance(value, Mapping):
+        for key in ("items", "designs", "results"):
+            if isinstance(value.get(key), list):
+                return [dict(item) for item in value[key] if isinstance(item, Mapping)]
+    return []
+
+
+def _first_id(value: Any, keys: tuple[str, ...]) -> str:
+    if isinstance(value, Mapping):
+        for key in keys:
+            candidate = str(value.get(key) or "").strip()
+            if candidate:
+                return candidate
+        for child in value.values():
+            found = _first_id(child, keys)
+            if found:
+                return found
+    elif isinstance(value, list):
+        for child in value:
+            found = _first_id(child, keys)
+            if found:
+                return found
+    return ""
+
+
+def _first_text_element(value: Any) -> str:
+    if isinstance(value, Mapping):
+        for key in ("element_id", "id"):
+            candidate = str(value.get(key) or "").strip()
+            if candidate and any(token in str(value).lower() for token in ("text", "richtext", "content")):
+                return candidate
+        for child in value.values():
+            found = _first_text_element(child)
+            if found:
+                return found
+    elif isinstance(value, list):
+        for child in value:
+            found = _first_text_element(child)
+            if found:
+                return found
+    return ""
+
+
+def _first_page(value: Any) -> tuple[str, list[dict[str, Any]]]:
+    pages: list[dict[str, Any]] = []
+    if isinstance(value, Mapping) and isinstance(value.get("pages"), list):
+        pages = [dict(page) for page in value["pages"] if isinstance(page, Mapping)]
+    page_id = str((pages[0] if pages else {}).get("page_id") or "").strip()
+    return page_id, pages
+
+
+def run_direct_canva_thumbnail(
+    *,
+    title: str,
+    topic: str,
+    prompt: str,
+    blueprint: Mapping[str, Any],
+    destination: Path,
+    width: int,
+    height: int,
+    quality: str = "medium",
+) -> Path:
+    """Run the user-triggered Canva MCP flow in the local Thunderbolt process."""
+    with CanvaMCPClient() as client:
+        available = {str(item.get("name")) for item in client.tools()}
+        search_name = "search-designs" if "search-designs" in available else "search_designs"
+        result = _payload(client.call(search_name, {
+            "query": " ".join(word for word in f"{title} {topic}".split() if len(word) >= 3)[:255],
+            "sort_by": "relevance",
+            "ownership": "any",
+            "limit": 25,
+            "user_intent": "Find an existing Canva design to edit as a Thunderbolt thumbnail.",
+        }))
+        candidates = _items(result)
+        if not candidates:
+            raise CanvaMCPError("Canva não encontrou designs para as palavras-chave da thumbnail.")
+        selected = candidates[0]
+        design_id = str(selected.get("id") or "").strip()
+        if not design_id:
+            raise CanvaMCPError("A pesquisa Canva devolveu um design sem ID.")
+
+        get_name = "get-design-content" if "get-design-content" in available else "get_design_content"
+        content = _payload(client.call(get_name, {
+            "design_id": design_id,
+            "user_intent": "Inspect the selected Canva design before applying the thumbnail edit.",
+        }))
+        start_name = "start-editing-transaction" if "start-editing-transaction" in available else "start_editing_transaction"
+        started = _payload(client.call(start_name, {
+            "design_id": design_id,
+            "user_intent": "Edit the selected design according to the local Thunderbolt Thumbnail Blueprint.",
+        }))
+        transaction_id = _first_id(started, ("transaction_id",))
+        if not transaction_id:
+            raise CanvaMCPError("Canva não devolveu uma transacção de edição.")
+        page_id, pages = _first_page(started)
+        element_id = _first_text_element(started) or _first_text_element(content)
+        if not element_id:
+            raise CanvaMCPError("O design Canva não devolveu um elemento de texto editável.")
+        perform_name = "perform-editing-operations" if "perform-editing-operations" in available else "perform_editing_operations"
+        operations = [{"type": "replace_text", "element_id": element_id, "text": title[:255]}]
+        performed = _payload(client.call(perform_name, {
+            "transaction_id": transaction_id,
+            "operations": operations,
+            "page_index": 1,
+            "pages": pages,
+            "user_intent": f"Apply this local Thumbnail Blueprint to the thumbnail: {blueprint.get('id', '')}. Prompt: {prompt[:1000]}",
+        }))
+        commit_name = "commit-editing-transaction" if "commit-editing-transaction" in available else "commit_editing_transaction"
+        client.call(commit_name, {
+            "transaction_id": transaction_id,
+            "user_intent": "Save the approved thumbnail lettering edit before export.",
+        })
+        formats_name = "get-export-formats" if "get-export-formats" in available else "get_export_formats"
+        formats = _payload(client.call(formats_name, {
+            "design_id": design_id,
+            "user_intent": "Verify PNG export support before exporting the finished thumbnail.",
+        }))
+        format_text = json.dumps(formats, ensure_ascii=False).lower()
+        if '"png"' not in format_text:
+            raise CanvaMCPError("O design Canva seleccionado não suporta exportação PNG.")
+        export_name = "export-design" if "export-design" in available else "export_design"
+        exported = _payload(client.call(export_name, {
+            "design_id": design_id,
+            "format": {
+                "type": "png",
+                "width": width,
+                "height": height,
+                "export_quality": "pro" if quality == "high" else "regular",
+                "lossless": True,
+                "pages": [1],
+            },
+            "user_intent": "Export the finished Thunderbolt thumbnail as PNG.",
+        }))
+        url = _first_id(exported, ("url", "download_url"))
+        if not url:
+            raise CanvaMCPError("Canva não devolveu URL de download do PNG.")
+        response = requests.get(url, timeout=90)
+        response.raise_for_status()
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_bytes(response.content)
+        return destination
+
+
+__all__ = ["run_direct_canva_thumbnail"]

package/hermes_ui/media_generation.py

@@ -41,6 +41,7 @@ from .provider_routing import (
 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
+from .canva_mcp_workflow import run_direct_canva_thumbnail
 
 
 class MediaGenerationError(RuntimeError):
@@ -324,6 +325,7 @@ def generate_image_for_card(
     lettering_text: str = "",
     lettering_prompt: str = "",
     reference_image: Path | None = None,
+    thumbnail_blueprint: Mapping[str, Any] | None = None,
 ) -> Path:
     """Generate one image with the selected media card."""
     card = dict(card)
@@ -333,6 +335,23 @@ def generate_image_for_card(
         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)
+        blueprint = dict(thumbnail_blueprint or {})
+        if not str(blueprint.get("content") or "").strip():
+            raise MediaGenerationError("Canva exige um Thumbnail Blueprint local válido.")
+        try:
+            return run_direct_canva_thumbnail(
+                title=str(topic or "Thunderbolt thumbnail")[:255],
+                topic=topic,
+                prompt=prompt,
+                blueprint=blueprint,
+                destination=destination,
+                width=int(card.get("thumbnail_width") or 1280),
+                height=int(card.get("thumbnail_height") or 720),
+                quality=str(card.get("export_quality") or "medium"),
+            )
+        except Exception as exc:
+            raise MediaGenerationError(str(exc)) from exc
+
         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)]
@@ -417,6 +436,7 @@ def generate_image_from_pool(
     lettering_prompt: str = "",
     reference_image: Path | None = None,
     thumbnail_only: bool = False,
+    thumbnail_blueprint: Mapping[str, Any] | None = None,
 ) -> Path:
     """Try eligible image cards in priority order, without cross-pool fallback."""
     cards = media_cards_for_pool(settings, "image", thumbnail_only=True) if thumbnail_only else media_cards_for_pool(settings, "image")
@@ -434,6 +454,7 @@ def generate_image_from_pool(
                 lettering_text=lettering_text,
                 lettering_prompt=lettering_prompt,
                 reference_image=reference_image,
+                thumbnail_blueprint=thumbnail_blueprint,
             )
         except MediaGenerationError as exc:
             errors.append(f"{card.get('provider')}: {str(exc)[:180]}")

package/hermes_ui/pipeline_worker.py

@@ -4,8 +4,6 @@ import io
 
 os.environ["PYTHONIOENCODING"] = "utf-8"
 os.environ["PYTHONUTF8"] = "1"
-os.environ["CLICK_NO_WIN_CONSOLE"] = "1"
-os.environ["PYTHONLEGACYWINDOWSSTDIO"] = "1"
 _original_stdout, _original_stderr = sys.stdout, sys.stderr
 if getattr(sys.stdout, "buffer", None) is not None and str(getattr(sys.stdout, "encoding", "") or "").lower().replace("-", "_") != "utf_8":
     sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True)
@@ -84,6 +82,7 @@ def _generate_pipeline_thumbnail(
     variant_index: int = 0,
     lettering_text: str = "",
     lettering_prompt: str = "",
+    thumbnail_blueprint: dict[str, Any] | None = None,
 ) -> Path:
     """Use the image pool while keeping the legacy single-Nano call seam."""
     cards = media_cards_for_pool(settings, "image")
@@ -103,6 +102,7 @@ def _generate_pipeline_thumbnail(
         variant_index=variant_index,
         lettering_text=lettering_text,
         lettering_prompt=lettering_prompt,
+        thumbnail_blueprint=thumbnail_blueprint,
     )
 
 
@@ -1494,6 +1494,7 @@ def _run_task(task: dict[str, Any]) -> dict[str, Any]:
                 variant_index=0,
                 lettering_text=str(variant.get("overlay_text") or ""),
                 lettering_prompt=str(variant.get("lettering_prompt") or ""),
+                thumbnail_blueprint=blueprint,
             )
         except (MediaGenerationError, ThumbnailGenerationError) as exc:
             raise PipelineError(f"A thumbnail não foi gerada; o vídeo já está disponível em {video_path}: {exc}") from exc

package/hermes_ui/thumbnails.py

@@ -24,6 +24,7 @@ def _generate_image_with_pool(
     lettering_text: str = "",
     lettering_prompt: str = "",
     reference_image: Path | None = None,
+    thumbnail_blueprint: dict[str, Any] | None = None,
 ) -> Path:
     """Use the legacy Nano adapter when it is the only active image card.
 
@@ -50,6 +51,7 @@ def _generate_image_with_pool(
         lettering_text=lettering_text,
         lettering_prompt=lettering_prompt,
         thumbnail_only=True,
+        thumbnail_blueprint=thumbnail_blueprint,
     )
 
 
@@ -260,7 +262,26 @@ def generate_thumbnail_for_task(
         raise ThumbnailGenerationError("A thumbnail não tem um prompt de imagem para gerar.")
     _archive_image(str(task_id), record.get("image_path"))
     visual_prompt = record["prompt"]
-    rules = str((thumbnail_blueprint or {}).get("content") or "").strip()
+    effective_blueprint = dict(thumbnail_blueprint or {})
+    configured_cards = settings.get("media_provider_cards", []) if isinstance(settings, dict) else []
+    canva_selected = any(
+        isinstance(item, dict)
+        and str(item.get("provider") or "").lower() == "canva"
+        and bool(item.get("enabled", True))
+        for item in configured_cards
+    ) if isinstance(configured_cards, list) else False
+    if not effective_blueprint and canva_selected:
+        channels = read_json("channels.json", [])
+        channel = next(
+            (item for item in channels if isinstance(item, dict) and str(item.get("id") or "") == record["channel_id"]),
+            {},
+        ) if isinstance(channels, list) else {}
+        effective_blueprint = thumbnail_blueprint_for_channel(
+            {**channel, "thumbnail_blueprint_id": record["thumbnail_blueprint_id"] or channel.get("thumbnail_blueprint_id", "")}
+        )
+    rules = str(effective_blueprint.get("content") or "").strip()
+    if canva_selected and not rules:
+        raise ThumbnailGenerationError("A tarefa não tem um Thumbnail Blueprint local válido.")
     if rules:
         visual_prompt = f"{visual_prompt}\n\nTHUMBNAIL BLUEPRINT — FOLLOW THESE VISUAL RULES:\n{rules}"
     image_path = _generate_image_with_pool(
@@ -270,6 +291,7 @@ def generate_thumbnail_for_task(
         variant_index=record["variant_index"],
         lettering_text=record.get("thumbnail_text") or "",
         lettering_prompt=record.get("lettering_prompt") or "",
+        thumbnail_blueprint=effective_blueprint,
     )
     updated = _update_thumbnail_task(
         task_id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.5.08",
+  "version": "0.5.11",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",
@@ -25,7 +25,6 @@
     "seed/references/*.md",
     "seed/references/*.sql",
     "README.md",
-    "CHANGELOG.md",
     "MANUAL-INSTALACAO.md",
     "THIRD-PARTY-NOTICES.md",
     "requirements.txt",

package/scripts/cli.mjs

@@ -7,12 +7,6 @@ import { homedir, platform } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-// Definir no processo pai para Click/Streamlit herdarem as opções no Windows.
-process.env.CLICK_NO_WIN_CONSOLE = "1";
-process.env.PYTHONIOENCODING = "utf-8";
-process.env.PYTHONUTF8 = "1";
-process.env.PYTHONLEGACYWINDOWSSTDIO = "1";
-
 const root = resolve(fileURLToPath(new URL(".", import.meta.url)), "..");
 const args = process.argv.slice(2);
 

package/CHANGELOG.md

@@ -1,5 +0,0 @@
-# Changelog
-
-## 0.5.08 (normalizado pelo npm para 0.5.8)
-
-Corrigido o erro `LookupError: unknown encoding: utf-16-le` que podia ocorrer durante o shutdown do Streamlit no Windows. O launcher Node agora materializa as variáveis de encoding e `CLICK_NO_WIN_CONSOLE` no processo pai antes de iniciar Python; os workers de automação e pipeline também aplicam as mesmas definições antes dos imports restantes.