@danhachuel/thunderbolt 0.6.64 → 0.6.66

package/app/main.py

@@ -116,7 +116,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 DEFAULT_AVERAGE_VIDEO_TIME, channel_video_length, length_generation_settings, words_from_channel_time
+from hermes_ui.video_length import DEFAULT_AVERAGE_VIDEO_TIME, channel_video_length, channel_video_time_value, 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
@@ -2374,10 +2374,10 @@ def render_tiktok_channels():
                         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 DEFAULT_AVERAGE_VIDEO_TIME), key=f"tiktok_channel_average_video_time_{channel_id}", help=f"Referência: {calculated_words or 0} palavras · {calculated_source}.")
+                        average_video_time = st.text_input("Tempo Medio de Video", value=channel_video_time_value(channel), key=f"tiktok_channel_average_video_time_{channel_id}", help=f"Referência: {calculated_words or 0} palavras · {calculated_source}.")
                         if st.button("Guardar tempo", key=f"save_tiktok_channel_average_video_time_{channel_id}", use_container_width=True):
                             if not valid_hhmm(average_video_time):
-                                st.error("Use o formato HH:MM, por exemplo 00:02.")
+                                st.error("Use o formato MM:SS, por exemplo 12:00.")
                             else:
                                 update_channel(channel_id, {"average_video_time": average_video_time.strip() or DEFAULT_AVERAGE_VIDEO_TIME, "average_video_word_count": words_from_channel_time(average_video_time)})
                                 st.success("Tempo médio do canal TikTok guardado.")
@@ -3073,10 +3073,10 @@ def render_channels():
                 st.metric("Visualizações", _format_channel_count(channel.get("view_count")))
             with header_cols[5]:
                 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 DEFAULT_AVERAGE_VIDEO_TIME), key=f"youtube_channel_average_video_time_{channel_id}", help=f"Referência: {calculated_words or 0} palavras · {calculated_source}.")
+                average_video_time = st.text_input("Tempo Medio de Video", value=channel_video_time_value(channel), key=f"youtube_channel_average_video_time_{channel_id}", help=f"Referência: {calculated_words or 0} palavras · {calculated_source}.")
                 if st.button("Guardar tempo", key=f"save_youtube_channel_average_video_time_{channel_id}", use_container_width=True):
                     if not valid_hhmm(average_video_time):
-                        st.error("Use o formato HH:MM, por exemplo 00:02.")
+                        st.error("Use o formato MM:SS, por exemplo 12:00.")
                     else:
                         update_channel(channel_id, {"average_video_time": average_video_time.strip() or DEFAULT_AVERAGE_VIDEO_TIME, "average_video_word_count": words_from_channel_time(average_video_time)})
                         st.success("Tempo médio do canal YouTube guardado.")
@@ -5465,7 +5465,7 @@ def render_tiktok_automation():
                 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 DEFAULT_AVERAGE_VIDEO_TIME), key=f"tiktok_average_video_time_{channel_id}", help=f"Referência média: {calculated_words or 0} palavras · fonte: {calculated_source}.")
+                average_video_time = st.text_input("Tempo Medio de Video", value=channel_video_time_value(channel), key=f"tiktok_average_video_time_{channel_id}", help=f"Referência média: {calculated_words or 0} palavras · fonte: {calculated_source}.")
             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**")
@@ -5489,7 +5489,7 @@ def render_tiktok_automation():
                     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.")
+                        st.error("O Tempo Medio de Video deve estar no formato MM:SS, por exemplo 12:00.")
                     else:
                         avatar_url = _tiktok_avatar_url(channel)
                         update_channel(channel_id, {"automation_on": bool(enabled), "automation_time": schedule_time.strip(), "average_video_time": average_video_time.strip() or DEFAULT_AVERAGE_VIDEO_TIME, "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})
@@ -5653,7 +5653,7 @@ def render_automation():
                 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 DEFAULT_AVERAGE_VIDEO_TIME), key=f"average_video_time_{channel_id}", help=f"Referência média: {calculated_words or 0} palavras · fonte: {calculated_source}.")
+                average_video_time = st.text_input("Tempo Medio de Video", value=channel_video_time_value(channel), key=f"average_video_time_{channel_id}", help=f"Referência média: {calculated_words or 0} palavras · fonte: {calculated_source}.")
 
             control_cols = st.columns([1.8, 1.8, 1.35, 1.2], gap="small")
             with control_cols[0]:
@@ -5680,7 +5680,7 @@ def render_automation():
                     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.")
+                        st.error("O Tempo Medio de Video deve estar no formato MM:SS, por exemplo 12:00.")
                     else:
                         update_channel(channel_id, {
                             "automation_on": bool(enabled),

package/hermes_ui/video_length.py

@@ -6,32 +6,43 @@ from pathlib import Path
 from typing import Any
 
 WORDS_PER_MINUTE = 150
-DEFAULT_AVERAGE_VIDEO_TIME = "00:12"
+DEFAULT_AVERAGE_VIDEO_TIME = "12:00"
 AVERAGE_VIDEO_TIME_KEY = "average_video_time"
 AVERAGE_VIDEO_WORD_COUNT_KEY = "average_video_word_count"
 
 
+def channel_video_time_value(channel: dict[str, Any]) -> str:
+    """Return the card value, migrating only the historical twelve-minute default."""
+    value = str(channel.get(AVERAGE_VIDEO_TIME_KEY) or "").strip()
+    configured_words = str(channel.get(AVERAGE_VIDEO_WORD_COUNT_KEY) or "").strip()
+    if value == "00:12" and configured_words in {"", "0", "1800"}:
+        return DEFAULT_AVERAGE_VIDEO_TIME
+    return value or DEFAULT_AVERAGE_VIDEO_TIME
+
+
 def valid_hhmm(value: Any) -> bool:
+    """Keep the historical helper name while validating a MM:SS duration."""
     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
+    minutes, seconds = int(match.group(1)), int(match.group(2))
+    return minutes >= 0 and 0 <= seconds <= 59
 
 
-def minutes_from_hhmm(value: Any) -> int:
+def minutes_from_hhmm(value: Any) -> float:
+    """Convert a stored MM:SS duration to fractional minutes."""
     if not valid_hhmm(value):
         return 0
-    hours, minutes = (int(part) for part in str(value).strip().split(":"))
-    return hours * 60 + minutes
+    minutes, seconds = (int(part) for part in str(value).strip().split(":"))
+    return minutes + seconds / 60
 
 
 def hhmm_from_minutes(value: Any) -> str:
     try:
-        total = max(0, int(value))
+        total_seconds = max(0, round(float(value) * 60))
     except (TypeError, ValueError):
-        total = 0
-    return f"{total // 60:02d}:{total % 60:02d}"
+        total_seconds = 0
+    return f"{total_seconds // 60:02d}:{total_seconds % 60:02d}"
 
 
 def _numbers(value: Any) -> list[int]:
@@ -91,23 +102,26 @@ def explicit_word_count(blueprint: Any = None, prompt_master: str = "") -> int:
 
 
 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))
+    """Return (word_count, mm:ss, source), preferring channel override over defaults."""
+    raw_configured_time = str(channel.get(AVERAGE_VIDEO_TIME_KEY) or "").strip()
     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 raw_configured_time == "00:12" and configured_words in {0, 1800}:
+        raw_configured_time = DEFAULT_AVERAGE_VIDEO_TIME
+    configured_time = minutes_from_hhmm(raw_configured_time)
     if configured_time:
-        return configured_time * WORDS_PER_MINUTE, hhmm_from_minutes(configured_time), "canal"
+        return round(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"
     default_minutes = minutes_from_hhmm(DEFAULT_AVERAGE_VIDEO_TIME)
-    return default_minutes * WORDS_PER_MINUTE, DEFAULT_AVERAGE_VIDEO_TIME, "padrão do canal"
+    return round(default_minutes * WORDS_PER_MINUTE), DEFAULT_AVERAGE_VIDEO_TIME, "padrão do canal"
 
 
 def words_from_channel_time(value: Any) -> int:
     minutes = minutes_from_hhmm(value)
-    return minutes * WORDS_PER_MINUTE if minutes else 0
+    return round(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]:
@@ -124,6 +138,7 @@ __all__ = [
     "AVERAGE_VIDEO_TIME_KEY",
     "AVERAGE_VIDEO_WORD_COUNT_KEY",
     "DEFAULT_AVERAGE_VIDEO_TIME",
+    "channel_video_time_value",
     "WORDS_PER_MINUTE",
     "channel_video_length",
     "explicit_word_count",

package/integrations/instagram_public.py

@@ -605,10 +605,25 @@ def fetch_public_instagram_posts(source: str, limit: int = 10) -> IntegrationRes
             return IntegrationResult(False, 'Esta conta é privada. O Instagram não disponibiliza posts sem uma sessão autenticada.', reference | {'posts': [], 'is_private': True})
         if platform.system() == 'Windows':
             html_posts = api_user.get('_html_posts') or []
-            return IntegrationResult(bool(html_posts), 'Posts públicos encontrados.' if html_posts else 'Não foi possível encontrar posts públicos nesta página do Instagram.', reference | {'posts': html_posts[:max(1, int(limit))]})
+            print(f'Posts no user inicial para @{reference["username"]}: {len(html_posts)}')
+            if html_posts:
+                return IntegrationResult(True, 'Posts públicos encontrados.', reference | {'posts': html_posts[:max(1, int(limit))]})
     if platform.system() == 'Windows':
         html_content = _fetch_instagram_html_with_playwright(reference['url'], reference['username'])
-        posts = _extract_posts_from_html(html_content, limit) if html_content else []
+        html_user = _extract_profile_user_from_html(html_content, reference['username']) if html_content else {}
+        media = html_user.get('edge_owner_to_timeline_media') if isinstance(html_user, Mapping) else {}
+        edges = media.get('edges') if isinstance(media, Mapping) else []
+        print(f'JSON do perfil extraído no Windows para @{reference["username"]}: {bool(html_user)}; edges encontrados: {len(edges or [])}')
+        posts: list[dict[str, Any]] = []
+        for edge in edges or []:
+            node = edge.get('node') if isinstance(edge, Mapping) else edge
+            if isinstance(node, dict):
+                post = _post_from_node(node)
+                if post:
+                    posts.append(post)
+        if not posts:
+            posts = _extract_posts_from_html(html_content, limit) if html_content else []
+        posts = posts[:max(1, int(limit))]
         print(f'Posts extraídos no Windows para @{reference["username"]}: {len(posts)}')
         if not posts and html_content:
             try:
@@ -618,7 +633,7 @@ def fetch_public_instagram_posts(source: str, limit: int = 10) -> IntegrationRes
                 print(f'HTML de debug dos posts guardado em storage/debug_posts.html para @{reference["username"]}')
             except OSError as exc:
                 print(f'Não foi possível guardar storage/debug_posts.html: {exc}')
-        return IntegrationResult(bool(posts), 'Posts públicos encontrados.' if posts else 'Não foi possível encontrar posts públicos nesta página do Instagram.', reference | {'posts': posts[:max(1, int(limit))]})
+        return IntegrationResult(bool(posts), 'Posts públicos encontrados.' if posts else 'Não foi possível encontrar posts públicos nesta página do Instagram.', reference | {'posts': posts})
     try:
         response = requests.get(reference['url'], headers={'User-Agent': 'Mozilla/5.0', 'Accept-Language': 'pt-BR,pt;q=0.9,en;q=0.8'}, timeout=15)
     except requests.RequestException as exc:

package/package.json

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