@danhachuel/thunderbolt 0.4.92 → 0.4.94

package/README.md

@@ -451,3 +451,11 @@ O Thunderbolt integra o [jusTokenMax](https://github.com/Kalmantic/jusTokenMax)
 A configuração encontra-se em **Configuração API > API Keys > Optimização de tokens — jusTokenMax**. É possível activar ou desactivar o optimizador, controlar os levers por tipo, verificar a versão instalada, consultar métricas e limpar apenas os artefactos derivados. Os originais permanecem em `storage/state/token_optimizer_originals/` e podem ser recuperados pelo hash através do módulo interno.
 
 A instalação do pacote inclui `justokenmax` a partir do repositório oficial. Se o CLI não estiver disponível ou ocorrer um erro, o Thunderbolt usa o conteúdo original e regista um fallback local; a geração não fica bloqueada. API keys, passwords, tokens e blobs base64 são redigidos antes de serem guardados em artefactos derivados.
+
+## Canva Skills — automação criativa
+
+O Thunderbolt inclui as seis Canva Skills activas do pacote oficial `canva-sdks/canva-skills`, adaptadas para chamadas REST directas: `resize-for-social-media`, `bulk-create`, `implement-feedback`, `edit-design`, `get-design-feedback` e `brand-check`. A página `Canva Skills` permite executar as operações sobre um card Canva autorizado em **Configuração API > API Keys > Imagem e Video IA**.
+
+A criação em lote usa o endpoint oficial de Autofill e requer Canva Enterprise (ou quota de trial durante desenvolvimento). A criação de variantes sociais copia o design e exporta cada variante; a Connect REST pública não oferece um endpoint geral de resize responsivo, por isso a dimensão alvo é registada e o link de edição Canva é disponibilizado para ajustes finais. A API REST também não expõe as transacções de edição usadas pelo MCP; `edit-design` e `implement-feedback` funcionam como preparação aprovada e identificam claramente as alterações que exigem edição manual, sem efectuar commits falsos.
+
+O fluxo automático de thumbnails continua a usar Canva exclusivamente no Pool de Imagem para thumbnails. Canva nunca é seleccionado para geração de vídeo. Consulte `app/modules/canva_skills/` para os módulos e `app/pages/canva_skills.py` para a interface.

package/app/main.py

@@ -7,6 +7,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)
     if buffer is not None and not getattr(stream, "_thunderbolt_utf8", False):
         wrapped = io.TextIOWrapper(buffer, encoding="utf-8", errors="replace", line_buffering=True)
@@ -104,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
@@ -7062,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"
 
@@ -7098,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]:
@@ -7141,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/app/modules/canva_skills/__init__.py

@@ -0,0 +1,14 @@
+"""Deterministic REST adaptations of the active Canva agent skills."""
+
+from .config import CANVA_SKILL_SCOPES, PLATFORM_DIMENSIONS
+from .resize import resize_for_social_media
+from .bulk import bulk_create_thumbnails
+from .feedback import get_design_feedback, implement_feedback
+from .edit import edit_design
+from .brand import list_brand_kits, check_brand_compliance
+
+__all__ = [
+    "CANVA_SKILL_SCOPES", "PLATFORM_DIMENSIONS", "resize_for_social_media",
+    "bulk_create_thumbnails", "get_design_feedback", "implement_feedback",
+    "edit_design", "list_brand_kits", "check_brand_compliance",
+]

package/app/modules/canva_skills/brand.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .client import CanvaSkillsClient
+
+
+def list_brand_kits(*, client: CanvaSkillsClient) -> list[dict[str, Any]]:
+    payload = client.get("brand-templates", {"limit": 100})
+    return list(payload.get("items") or payload.get("brand_templates") or [])
+
+
+def check_brand_compliance(design_id: str, brand_kit_id: str, *, client: CanvaSkillsClient) -> dict[str, Any]:
+    design = client.get(f"designs/{design_id}").get("design", {})
+    templates = list_brand_kits(client=client)
+    selected = next((item for item in templates if str(item.get("id")) == brand_kit_id), None)
+    if selected is None:
+        raise ValueError("Brand Template/kit não encontrado ou sem permissão.")
+    return {"design_id": design_id, "brand_kit_id": brand_kit_id, "on_brand": [], "off_brand": [], "cannot_verify": [{"category": "colors", "reason": "A metadata REST não expõe paleta completa."}, {"category": "typography", "reason": "A metadata REST não expõe fontes completas."}, {"category": "logo", "reason": "É necessária inspecção visual no Canva."}], "design_title": design.get("title", ""), "brand_template_title": selected.get("title", "")}

package/app/modules/canva_skills/bulk.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from .client import CanvaSkillsClient
+
+
+def _autofill(client: CanvaSkillsClient, template_id: str, row: Mapping[str, Any], title: str) -> str:
+    data = {key: value if isinstance(value, Mapping) else {"type": "text", "text": str(value)} for key, value in row.items()}
+    payload = client.post("autofills", {"type": "create_from_brand_template", "brand_template_id": template_id, "data": data, "title": title[:255] or "Thunderbolt thumbnail"})
+    job = payload.get("job") or payload
+    job_id = str(job.get("id") or "")
+    if not job_id:
+        raise RuntimeError("A Canva não devolveu o job de autofill.")
+    for _ in range(60):
+        status_payload = client.get(f"autofills/{job_id}")
+        status_job = status_payload.get("job") or status_payload
+        status = str(status_job.get("status") or "").lower()
+        if status == "success":
+            design = status_job.get("design") or {}
+            design_id = str(design.get("id") or status_job.get("design_id") or "")
+            if design_id:
+                return design_id
+        if status == "failed":
+            raise RuntimeError(f"Autofill Canva falhou: {status_job.get('error') or status_job}")
+    raise RuntimeError("Autofill Canva excedeu o tempo de espera.")
+
+
+def bulk_create_thumbnails(template_id: str, data: list[Mapping[str, Any]], export_format: str = "png", *, client: CanvaSkillsClient) -> list[dict[str, Any]]:
+    if not template_id.strip():
+        raise ValueError("É necessário indicar um Brand Template Canva.")
+    results = []
+    for row in data:
+        design_id = _autofill(client, template_id, row, str(row.get("titulo") or row.get("title") or "Thunderbolt thumbnail"))
+        job_id = client.export_design(design_id, file_type=export_format.lower())
+        results.append({"design_id": design_id, "export_url": client.wait_export(job_id), "metadata": dict(row)})
+    return results

package/app/modules/canva_skills/client.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from hermes_ui.canva_client import CanvaClient
+
+
+class CanvaSkillsClient(CanvaClient):
+    """REST client shared by the adapted Canva Skills."""
+
+    def get(self, endpoint: str, params: Mapping[str, Any] | None = None) -> dict[str, Any]:
+        return self.request("GET", endpoint, params=params)
+
+    def post(self, endpoint: str, data: Mapping[str, Any] | None = None) -> dict[str, Any]:
+        return self.request("POST", endpoint, json=data or {})
+
+    def delete(self, endpoint: str) -> dict[str, Any]:
+        return self.request("DELETE", endpoint)
+
+
+def client_from_card(card: Mapping[str, Any], token_saver=None) -> CanvaSkillsClient:
+    return CanvaSkillsClient(card, token_saver=token_saver)

package/app/modules/canva_skills/config.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+PLATFORM_DIMENSIONS = {
+    "youtube_thumbnail": (1280, 720),
+    "tiktok": (1080, 1920),
+    "instagram_post": (1080, 1080),
+    "instagram_story": (1080, 1920),
+    "facebook_post": (1200, 630),
+    "facebook_story": (1080, 1920),
+    "linkedin_post": (1200, 627),
+}
+
+CANVA_SKILL_SCOPES = "design:content:read design:content:write design:meta:read brandtemplate:meta:read brandtemplate:content:read comment:read comment:write"
+SUPPORTED_EXPORT_FORMATS = {"png", "jpg"}

package/app/modules/canva_skills/edit.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from .client import CanvaSkillsClient
+
+
+def edit_design(design_id: str, changes: Mapping[str, Any], *, client: CanvaSkillsClient, auto_commit: bool = False) -> dict[str, Any]:
+    """Prepare a safe edit request; REST Connect has no public edit transaction endpoint."""
+    if not auto_commit:
+        return {"status": "pending_approval", "design_id": design_id, "changes": dict(changes)}
+    return {"status": "manual_action_required", "design_id": design_id, "changes": dict(changes), "message": "A Canva Connect REST API não expõe start/perform/commit editing transactions; abra o edit_url no Canva para aplicar estas alterações manualmente."}

package/app/modules/canva_skills/feedback.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from .client import CanvaSkillsClient
+
+
+def get_design_feedback(design_id: str, *, client: CanvaSkillsClient) -> dict[str, Any]:
+    design_payload = client.get(f"designs/{design_id}")
+    design = design_payload.get("design") or design_payload
+    findings = []
+    title = str(design.get("title") or "").strip()
+    if not title:
+        findings.append({"category": "readability", "severity": "medium", "message": "O design não tem título identificável na metadata."})
+    thumb = design.get("thumbnail") or {}
+    if thumb.get("width") and thumb.get("height") and thumb["width"] / thumb["height"] < 1.5:
+        findings.append({"category": "layout", "severity": "high", "message": "A proporção da thumbnail parece inadequada para YouTube 16:9."})
+    return {"design_id": design_id, "visual_hierarchy": findings, "layout": [], "readability": [], "consistency": [], "accessibility": [], "limitations": ["A Connect REST não expõe uma análise visual completa nem listagem de threads de comentários; os itens não verificáveis ficam explícitos."]}
+
+
+def implement_feedback(design_id: str, feedback_items: list[Mapping[str, Any]], *, client: CanvaSkillsClient, approved: bool = False) -> dict[str, Any]:
+    if not approved:
+        return {"status": "pending_approval", "design_id": design_id, "items": [dict(item) for item in feedback_items]}
+    return {"status": "manual_action_required", "design_id": design_id, "applied": [], "manual": [dict(item) for item in feedback_items], "message": "A Connect REST pública não fornece transacções de edição; nenhuma alteração foi cometida."}

package/app/modules/canva_skills/models.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class PlatformAsset:
+    platform: str
+    width: int
+    height: int
+    design_id: str = ""
+    export_url: str = ""
+    edit_url: str = ""
+
+
+@dataclass
+class SkillResult:
+    status: str
+    message: str = ""
+    data: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class FeedbackItem:
+    category: str
+    text: str
+    actionable: bool = False
+    source_id: str = ""

package/app/modules/canva_skills/resize.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from .client import CanvaSkillsClient
+from .config import PLATFORM_DIMENSIONS, SUPPORTED_EXPORT_FORMATS
+
+
+def resize_for_social_media(design_id: str, platforms: list[str], export_format: str = "png", *, client: CanvaSkillsClient) -> dict[str, dict[str, Any]]:
+    """Create platform variants and export them.
+
+    Connect REST currently has no general resize endpoint. The skill therefore
+    creates a copy for each platform and records target dimensions; users can
+    refine the copy through Canva's edit URL when exact responsive layout is
+    required.
+    """
+    if export_format.lower() not in SUPPORTED_EXPORT_FORMATS:
+        raise ValueError("O formato deve ser png ou jpg.")
+    results: dict[str, dict[str, Any]] = {}
+    for platform in platforms:
+        if platform not in PLATFORM_DIMENSIONS:
+            continue
+        copied = client.post("designs", {"type": "design", "design_id": design_id, "page_numbers": [1]})
+        design = copied.get("design") or copied
+        variant_id = str(design.get("id") or "")
+        if not variant_id:
+            raise RuntimeError(f"A Canva não devolveu o design da variante {platform}.")
+        job_id = client.export_design(variant_id, file_type=export_format.lower())
+        url = client.wait_export(job_id)
+        urls = design.get("urls") or {}
+        results[platform] = {"design_id": variant_id, "export_url": url, "edit_url": urls.get("edit_url", ""), "width": PLATFORM_DIMENSIONS[platform][0], "height": PLATFORM_DIMENSIONS[platform][1], "resize_note": "A Connect REST não aplica resize responsivo; a dimensão é metadado para edição/exportação."}
+    return results

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, params: 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, params=params, 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.92",
+  "version": "0.4.94",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",