@danhachuel/thunderbolt 0.6.38 → 0.6.40

package/app/main.py

@@ -94,6 +94,7 @@ from hermes_ui.update_manager import check_version, restart_current_process, upd
 
 from hermes_ui.script_documents import list_script_documents, read_script_document, save_script_document, script_storage_path
 from hermes_ui.script_generation import generate_script_document
+from hermes_ui.video_length import channel_video_length, length_generation_settings, words_from_channel_time
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
 from hermes_ui.elevenlabs_voices import ElevenLabsVoicesError, cached_personal_voices, fetch_personal_voices, personal_voice_options
 from hermes_ui.thumbnail_generation import ThumbnailGenerationError, generate_thumbnail_image
@@ -130,6 +131,7 @@ from integrations.session_info_health import check_account_session_info_health
 from integrations.youtube_session_manager import renew_account_session
 from integrations.youtube_batch import account_key as youtube_batch_account_key, account_status as youtube_batch_account_status, authorize_account as authorize_youtube_batch_account, delete_account_token as delete_youtube_batch_token, list_my_channels as list_youtube_batch_channels, loopback_redirect_uri
 from integrations.youtube_upload import authorize_youtube_agent
+from integrations.tiktok_public import fetch_public_tiktok_profile
 from integrations.youtube_growth_api import find_account_for_channel as find_youtube_growth_account
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
@@ -731,6 +733,10 @@ def generate_video_content_for_ui(
     subject, topic_result = resolve_video_subject_for_generation(settings, channel, subject, blueprint)
 
     blueprint = blueprint if isinstance(blueprint, dict) else blueprint_for_channel(channel)
+    generation_settings = {
+        **(generation_settings or {}),
+        **length_generation_settings(channel, blueprint),
+    }
     script_result = generate_script_document(
         settings,
         document_type="Roteiro de vídeo",
@@ -740,7 +746,7 @@ def generate_video_content_for_ui(
         channel=channel,
         blueprint=blueprint,
         structure_notes=str((generation_settings or {}).get("script_structure_notes") or ""),
-        generation_settings=generation_settings or {},
+        generation_settings=generation_settings,
     )
     script = str(script_result.get("content") or "").strip()
     keywords = generate_video_keywords(
@@ -2343,6 +2349,12 @@ def render_tiktok_channels():
                     with card_cols[4]:
                         st.metric("Vídeos", format_metric_number(channel.get("video_count")))
                     with card_cols[5]:
+                        if st.button("↻", key=f"refresh_tiktok_metrics_{channel_id}", help="Actualizar Seguidores, Vídeos e Curtidas", use_container_width=True):
+                            with st.spinner("A actualizar métricas TikTok…"):
+                                refreshed, message = _refresh_tiktok_channel_metrics(channel)
+                            (st.success if refreshed else st.warning)(message)
+                            if refreshed:
+                                st.rerun()
                         active = st.toggle("Activo", value=bool(channel.get("active", True)), key=f"tiktok_import_card_active_{channel_id}")
                         if active != bool(channel.get("active", True)):
                             update_channel(channel_id, {"active": active})
@@ -2503,6 +2515,42 @@ def _format_channel_count(value: Any) -> str:
         return str(value)
 
 
+def _channel_average_video_time(channel: dict[str, Any], *, prompt_master: str = "") -> tuple[str, str, int]:
+    blueprint = blueprint_for_channel(channel) if is_youtube_channel_record(channel) else {}
+    words, duration, source = channel_video_length(channel, blueprint, prompt_master)
+    return duration, source, words
+
+
+def _refresh_youtube_channel_metrics(channel: dict[str, Any], youtube: YouTubeAdapter) -> tuple[bool, str]:
+    result = youtube.fetch_channel_public(str(channel.get("url") or channel.get("handle") or ""))
+    if not result.ok or not isinstance(result.data, dict):
+        return False, result.message
+    data = result.data
+    update_channel(str(channel["id"]), {
+        "subscriber_count": data.get("subscriber_count"),
+        "video_count": data.get("video_count"),
+        "view_count": data.get("view_count"),
+        "metrics_source": data.get("metrics_source", "youtube_public_page"),
+        "last_public_lookup_at": data.get("last_public_lookup_at", now()),
+    })
+    return True, "Métricas YouTube actualizadas."
+
+
+def _refresh_tiktok_channel_metrics(channel: dict[str, Any]) -> tuple[bool, str]:
+    result = fetch_public_tiktok_profile(str(channel.get("url") or channel.get("handle") or ""))
+    if not result.ok or not isinstance(result.data, dict):
+        return False, result.message
+    data = result.data
+    update_channel(str(channel["id"]), {
+        "subscriber_count": data.get("subscriber_count"),
+        "likes_count": data.get("likes_count"),
+        "video_count": data.get("video_count"),
+        "metrics_source": data.get("metrics_source", "tiktok_public_page"),
+        "last_public_lookup_at": data.get("last_public_lookup_at", now()),
+    })
+    return True, "Métricas TikTok actualizadas."
+
+
 def render_channels():
     st.title("Canais Youtube")
     st.caption("Escolha entre importar dados públicos do YouTube ou preencher o canal manualmente.")
@@ -2990,6 +3038,12 @@ def render_channels():
             with header_cols[4]:
                 st.metric("Visualizações", _format_channel_count(channel.get("view_count")))
             with header_cols[5]:
+                if st.button("↻", key=f"refresh_youtube_metrics_{channel_id}", help="Actualizar Inscritos, Vídeos e Visualizações", use_container_width=True):
+                    with st.spinner("A actualizar métricas YouTube…"):
+                        refreshed, message = _refresh_youtube_channel_metrics(channel, youtube)
+                    (st.success if refreshed else st.warning)(message)
+                    if refreshed:
+                        st.rerun()
                 active = st.toggle("Activo", value=channel.get("active", True), key=f"active_{channel_id}")
                 if active != channel.get("active"):
                     update_channel(channel_id, {"active": active})
@@ -5349,7 +5403,7 @@ def render_tiktok_automation():
     for channel in channels:
         channel_id = str(channel["id"])
         with st.container(border=True):
-            header_cols = st.columns([0.55, 2.35, 1.35, 1.5, 1.35])
+            header_cols = st.columns([0.55, 2.15, 1.25, 1.35, 1.55, 1.2])
             with header_cols[0]:
                 profile_image = _tiktok_avatar_url(channel)
                 if profile_image:
@@ -5363,6 +5417,11 @@ def render_tiktok_automation():
                 enabled = st.toggle("Automação ligada", value=bool(channel.get("automation_on", False)), key=f"tiktok_automation_on_{channel_id}")
             with header_cols[3]:
                 schedule_time = st.text_input("Horário (HH:MM)", value=channel.get("automation_time", "00:00"), key=f"tiktok_automation_time_{channel_id}")
+            with header_cols[4]:
+                prompt_file = TIKTOK_PROMPT_MASTERS / str(channel.get("default_prompt_master") or channel.get("prompt_master") or "")
+                prompt_content = load_prompt_master_file(prompt_file) if prompt_file.is_file() else ""
+                calculated_time, calculated_source, calculated_words = _channel_average_video_time(channel, prompt_master=prompt_content)
+                average_video_time = st.text_input("Tempo Medio de Video (HH:MM)", value=str(channel.get("average_video_time") or calculated_time), key=f"tiktok_average_video_time_{channel_id}", help=f"Referência média: {calculated_words or 0} palavras · fonte: {calculated_source}. Use 00:00 para voltar ao Prompt Master.")
             default_cols = st.columns([1.0, 1.0, 1.35, 1.45, 1.55, 1.0], gap="small")
             with default_cols[0]:
                 st.markdown("**Idioma do roteiro**")
@@ -5385,9 +5444,11 @@ def render_tiktok_automation():
                 if st.button("Guardar", key=f"tiktok_automation_save_{channel_id}", use_container_width=True, type="primary"):
                     if not valid_hhmm(schedule_time):
                         st.error("Use o formato HH:MM, por exemplo 08:30.")
+                    elif not valid_hhmm(average_video_time):
+                        st.error("O Tempo Medio de Video deve estar no formato HH:MM, por exemplo 00:02.")
                     else:
                         avatar_url = _tiktok_avatar_url(channel)
-                        update_channel(channel_id, {"automation_on": bool(enabled), "automation_time": schedule_time.strip(), "default_prompt_master": prompt, "prompt_master": prompt, "platform": "tiktok", "format": automation_format, "video_aspect_ratio": "Portrait 9:16", "style_wide": "portrait", "avatar_url": avatar_url, "thumbnail_url": avatar_url})
+                        update_channel(channel_id, {"automation_on": bool(enabled), "automation_time": schedule_time.strip(), "average_video_time": average_video_time.strip() or "00:00", "average_video_word_count": words_from_channel_time(average_video_time), "default_prompt_master": prompt, "prompt_master": prompt, "platform": "tiktok", "format": automation_format, "video_aspect_ratio": "Portrait 9:16", "style_wide": "portrait", "avatar_url": avatar_url, "thumbnail_url": avatar_url})
                         st.success("Automação TikTok guardada.")
                         st.rerun()
     _render_tiktok_automation_cards()
@@ -5521,7 +5582,7 @@ def render_automation():
             automation_voice = current_voice
             paired_thumbnail = thumbnail_blueprint_for_blueprint(automation_blueprint)
             automation_format = str(channel.get("format") or "wide")
-            header_cols = st.columns([0.62, 2.15, 1.55, 1.25, 1.25, 1.45, 1.3], gap="small")
+            header_cols = st.columns([0.58, 1.95, 1.4, 1.15, 1.15, 1.25, 1.25, 1.45], gap="small")
             with header_cols[0]:
                 if channel.get("thumbnail_url"):
                     st.image(channel["thumbnail_url"], width=48)
@@ -5546,6 +5607,9 @@ def render_automation():
                 st.caption(str(channel.get("video_aspect_ratio") or "Landscape 16:9"))
             with header_cols[6]:
                 schedule_time = st.text_input("Horário (HH:MM)", value=channel.get("automation_time", "00:00"), key=f"automation_time_{channel_id}")
+            with header_cols[7]:
+                calculated_time, calculated_source, calculated_words = _channel_average_video_time(channel)
+                average_video_time = st.text_input("Tempo Medio de Video (HH:MM)", value=str(channel.get("average_video_time") or calculated_time), key=f"average_video_time_{channel_id}", help=f"Referência média: {calculated_words or 0} palavras · fonte: {calculated_source}. Use 00:00 para voltar ao Blueprint.")
 
             control_cols = st.columns([1.8, 1.8, 1.35, 1.2], gap="small")
             with control_cols[0]:
@@ -5571,10 +5635,14 @@ def render_automation():
                 if st.button("Guardar", key=f"automation_save_{channel_id}", use_container_width=True, type="primary"):
                     if not valid_hhmm(schedule_time):
                         st.error("Use o formato HH:MM, por exemplo 08:30.")
+                    elif not valid_hhmm(average_video_time):
+                        st.error("O Tempo Medio de Video deve estar no formato HH:MM, por exemplo 00:02.")
                     else:
                         update_channel(channel_id, {
                             "automation_on": bool(enabled),
                             "automation_time": schedule_time.strip(),
+                            "average_video_time": average_video_time.strip() or "00:00",
+                            "average_video_word_count": words_from_channel_time(average_video_time),
                             "format": automation_format,
                         })
                         set_channel_defaults(channel_id, automation_blueprint, automation_voice)

package/hermes_ui/automation_worker.py

@@ -22,6 +22,7 @@ from .domain import create_batch, create_tasks_for_batch
 from .languages import language_code
 from .material_sources import selected_material_source
 from .notifications import record_notification
+from .video_length import length_generation_settings
 from integrations.session_info_health import check_all_accounts_session_info_health, emit_session_info_health_alerts
 
 WORKER_STATE_FILE = "automation_worker.json"
@@ -165,6 +166,19 @@ def _blueprint_for_channel(channel: dict[str, Any]) -> dict[str, Any]:
     return {}
 
 
+def _length_settings(channel: dict[str, Any], blueprint: dict[str, Any]) -> dict[str, Any]:
+    prompt_content = ""
+    prompt_id = str(channel.get("default_prompt_master") or channel.get("prompt_master") or "").strip()
+    if prompt_id:
+        prompt_path = storage.TIKTOK_PROMPT_MASTERS / prompt_id
+        if prompt_path.is_file():
+            try:
+                prompt_content = storage.load_prompt_master_file(prompt_path)
+            except (OSError, ValueError):
+                prompt_content = ""
+    return length_generation_settings(channel, blueprint, prompt_content)
+
+
 def _creative_payload(channel: dict[str, Any]) -> tuple[str, dict[str, Any]]:
     settings = storage.read_json("settings.json", {})
     blueprint = _blueprint_for_channel(channel)
@@ -194,7 +208,7 @@ def _creative_payload(channel: dict[str, Any]) -> tuple[str, dict[str, Any]]:
         "thumbnail_blueprint_id": str(channel.get("default_thumbnail_blueprint_id") or channel.get("thumbnail_blueprint_id") or ""),
         "voice": str(channel.get("default_voice") or channel.get("voice") or ""),
         "material_source": material_source,
-        "generation_settings": {"video_keywords": editorial.get("keywords", []), "material_source": material_source},
+        "generation_settings": {"video_keywords": editorial.get("keywords", []), "material_source": material_source, **_length_settings(channel, blueprint)},
         "ai_generation": {"topic": topic_package, "editorial": editorial},
     }
     return topic_package["topic"], payload
@@ -241,7 +255,7 @@ def _pending_payload(channel: dict[str, Any]) -> tuple[str, dict[str, Any]]:
         "thumbnail_blueprint_id": str(channel.get("default_thumbnail_blueprint_id") or channel.get("thumbnail_blueprint_id") or ""),
         "voice": str(channel.get("default_voice") or channel.get("voice") or ""),
         "material_source": material_source,
-        "generation_settings": {"material_source": material_source},
+        "generation_settings": {"material_source": material_source, **_length_settings(channel, blueprint)},
         "ai_generation": {},
     }
     return "", payload

package/hermes_ui/script_generation.py

@@ -43,6 +43,7 @@ def generate_script_document(
     blueprint_payload = blueprint or {}
     generation_settings_payload = generation_settings or {}
     if normalized_type == "video_script":
+        target_word_count = generation_settings_payload.get("target_word_count")
         output_requirements = {
             "content": "roteiro completo em Markdown, com título, gancho, cenas, narração e indicações visuais/sonoras",
             "summary": "resumo editorial em uma frase",
@@ -52,7 +53,8 @@ def generate_script_document(
             f"escrevendo título, resumo e conteúdo integralmente em {language_name} ({language_code}). "
             "alinhado exclusivamente ao nicho e às regras do Blueprint fornecido. Não inventes factos sensíveis, "
             "não uses introduções genéricas, não escrevas comentários sobre IA e não incluas um CTA vazio. "
-            "Responde apenas com JSON válido nas chaves title, summary e content."
+            + (f"Escreve aproximadamente {int(target_word_count)} palavras; trata este valor como uma referência média e não como um limite rígido. " if target_word_count else "")
+            + "Responde apenas com JSON válido nas chaves title, summary e content."
         )
     else:
         output_requirements = {

package/hermes_ui/video_length.py

@@ -0,0 +1,132 @@
+"""Shared video-length estimation and channel override helpers."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+WORDS_PER_MINUTE = 150
+AVERAGE_VIDEO_TIME_KEY = "average_video_time"
+AVERAGE_VIDEO_WORD_COUNT_KEY = "average_video_word_count"
+
+
+def valid_hhmm(value: Any) -> bool:
+    match = re.fullmatch(r"\s*(\d{1,3}):(\d{2})\s*", str(value or ""))
+    if not match:
+        return False
+    hours, minutes = int(match.group(1)), int(match.group(2))
+    return hours >= 0 and 0 <= minutes <= 59
+
+
+def minutes_from_hhmm(value: Any) -> int:
+    if not valid_hhmm(value):
+        return 0
+    hours, minutes = (int(part) for part in str(value).strip().split(":"))
+    return hours * 60 + minutes
+
+
+def hhmm_from_minutes(value: Any) -> str:
+    try:
+        total = max(0, int(value))
+    except (TypeError, ValueError):
+        total = 0
+    return f"{total // 60:02d}:{total % 60:02d}"
+
+
+def _numbers(value: Any) -> list[int]:
+    if isinstance(value, bool):
+        return []
+    if isinstance(value, (int, float)):
+        return [int(value)] if value > 0 else []
+    return [int(item.replace(",", "")) for item in re.findall(r"(?<![\w])\d[\d,.]*(?![\w])", str(value or "")) if int(item.replace(",", "").replace(".", "")) > 0]
+
+
+def _configured_word_count(value: Any, key: str = "") -> int:
+    """Find an explicit word target, or convert an explicit character target."""
+    if isinstance(value, dict):
+        for child_key, child in value.items():
+            normalized = str(child_key).casefold().replace("_", " ").replace("-", " ")
+            if any(token in normalized for token in ("word", "words", "palavra", "palavras")):
+                numbers = _numbers(child)
+                if numbers:
+                    return max(numbers) if len(numbers) > 1 else numbers[0]
+            result = _configured_word_count(child, str(child_key))
+            if result:
+                return result
+        return 0
+    if isinstance(value, list):
+        normalized_key = key.casefold().replace("_", " ").replace("-", " ")
+        if any(token in normalized_key for token in ("character", "caracter", "char length", "length requirement")):
+            numbers = [number for child in value for number in _numbers(child)]
+            if numbers:
+                return max(1, round((sum(numbers) / len(numbers)) / 6))
+        for child in value:
+            result = _configured_word_count(child, key)
+            if result:
+                return result
+        return 0
+    text = str(value or "")
+    normalized_key = key.casefold().replace("_", " ").replace("-", " ")
+    if any(token in normalized_key for token in ("word", "words", "palavra", "palavras")):
+        numbers = _numbers(text)
+        if numbers:
+            return max(numbers) if len(numbers) > 1 else numbers[0]
+    if any(token in normalized_key for token in ("character", "caracter", "char length", "length requirement")):
+        numbers = _numbers(text)
+        if numbers:
+            return max(1, round((sum(numbers) / len(numbers)) / 6))
+    return 0
+
+
+def explicit_word_count(blueprint: Any = None, prompt_master: str = "") -> int:
+    """Return only an explicit target; never count the instructions themselves."""
+    result = _configured_word_count(blueprint)
+    if result:
+        return result
+    matches = re.findall(r"(?:at least|minimum of|around|approximately|exactly|entre|mínimo de|cerca de|aproximadamente)\s+(\d[\d,.]*)\s+(?:words|word|palavras|palavra)", prompt_master, flags=re.IGNORECASE)
+    if matches:
+        return max(1, int(matches[-1].replace(",", "").replace(".", "")))
+    return 0
+
+
+def channel_video_length(channel: dict[str, Any], blueprint: Any = None, prompt_master: str = "") -> tuple[int, str, str]:
+    """Return (word_count, hh:mm, source), preferring channel override over defaults."""
+    configured_time = minutes_from_hhmm(channel.get(AVERAGE_VIDEO_TIME_KEY))
+    configured_words = int(channel.get(AVERAGE_VIDEO_WORD_COUNT_KEY) or 0) if str(channel.get(AVERAGE_VIDEO_WORD_COUNT_KEY) or "0").isdigit() else 0
+    if configured_time:
+        return configured_time * WORDS_PER_MINUTE, hhmm_from_minutes(configured_time), "canal"
+    if configured_words:
+        return configured_words, hhmm_from_minutes(round(configured_words / WORDS_PER_MINUTE)), "canal"
+    words = explicit_word_count(blueprint, prompt_master)
+    if words:
+        return words, hhmm_from_minutes(round(words / WORDS_PER_MINUTE)), "Blueprint/Prompt Master"
+    return 0, "00:00", "sem referência"
+
+
+def words_from_channel_time(value: Any) -> int:
+    minutes = minutes_from_hhmm(value)
+    return minutes * WORDS_PER_MINUTE if minutes else 0
+
+
+def length_generation_settings(channel: dict[str, Any], blueprint: Any = None, prompt_master: str = "") -> dict[str, Any]:
+    words, duration, source = channel_video_length(channel, blueprint, prompt_master)
+    if not words:
+        return {}
+    return {
+        "target_word_count": words,
+        "target_video_duration": duration,
+        "target_word_count_source": source,
+    }
+
+__all__ = [
+    "AVERAGE_VIDEO_TIME_KEY",
+    "AVERAGE_VIDEO_WORD_COUNT_KEY",
+    "WORDS_PER_MINUTE",
+    "channel_video_length",
+    "explicit_word_count",
+    "hhmm_from_minutes",
+    "length_generation_settings",
+    "minutes_from_hhmm",
+    "valid_hhmm",
+    "words_from_channel_time",
+]

package/integrations/instagram_public.py

@@ -152,6 +152,17 @@ def _fetch_web_profile_user(username: str) -> dict[str, Any] | None:
                     merged[key] = value
         return merged
 
+    def extract_user(payload: Any) -> Mapping[str, Any] | None:
+        if not isinstance(payload, Mapping):
+            return None
+        candidates = [
+            payload.get('user'),
+            (payload.get('data') or {}).get('user') if isinstance(payload.get('data'), Mapping) else None,
+            (payload.get('graphql') or {}).get('user') if isinstance(payload.get('graphql'), Mapping) else None,
+            (payload.get('data') or {}).get('profile') if isinstance(payload.get('data'), Mapping) else None,
+        ]
+        return next((candidate for candidate in candidates if isinstance(candidate, Mapping)), None)
+
     request_headers = [
         headers,
         {**headers, 'User-Agent': 'Instagram 390.0.0.0.50 Android', 'Accept': 'application/json, text/plain, */*'},
@@ -169,7 +180,7 @@ def _fetch_web_profile_user(username: str) -> dict[str, Any] | None:
                 if best_user:
                     return best_user
                 continue
-            user = ((payload.get('data') or {}).get('user') if isinstance(payload, dict) else None)
+            user = extract_user(payload)
             if isinstance(user, dict):
                 best_user = merge_profile(best_user, user)
                 if profile_quality(best_user) >= 4:
@@ -189,7 +200,7 @@ def _fetch_web_profile_user(username: str) -> dict[str, Any] | None:
                     check=False,
                 )
                 payload = json.loads(completed.stdout) if completed.returncode == 0 and completed.stdout else None
-                user = ((payload.get('data') or {}).get('user') if isinstance(payload, dict) else None)
+                user = extract_user(payload)
                 if isinstance(user, dict):
                     best_user = merge_profile(best_user, user)
                     if profile_quality(best_user) >= 4:
@@ -215,7 +226,7 @@ def _fetch_web_profile_user(username: str) -> dict[str, Any] | None:
                         if response is None or response.status >= 400:
                             continue
                         payload = json.loads(page.locator('body').inner_text(timeout=5000))
-                        user = ((payload.get('data') or {}).get('user') if isinstance(payload, dict) else None)
+                        user = extract_user(payload)
                         if isinstance(user, dict):
                             best_user = merge_profile(best_user, user)
                             if profile_quality(best_user) >= 4:

package/package.json

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