@danhachuel/thunderbolt 0.6.65 → 0.6.67

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

@@ -585,11 +585,64 @@ def _post_from_node(node: dict[str, Any]) -> dict[str, Any] | None:
     }
 
 
+def _fetch_posts_with_ytdlp(username: str, limit: int = 10) -> list[dict[str, Any]]:
+    """Fetch public Instagram post metadata with the installed yt-dlp CLI."""
+    import subprocess
+
+    url = f'https://www.instagram.com/{username}/'
+    cmd = [
+        'yt-dlp', '--dump-json', '--no-download', '--flat-playlist',
+        '--playlist-end', str(max(1, int(limit))), url,
+    ]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30, check=False)
+        if result.returncode != 0:
+            print(f'yt-dlp erro para @{username}: {result.stderr.strip()}')
+            return []
+        posts: list[dict[str, Any]] = []
+        for line in result.stdout.splitlines():
+            if not line.strip():
+                continue
+            try:
+                data = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            post_id = str(data.get('id') or '').strip()
+            post_url = str(data.get('webpage_url') or data.get('url') or '').strip()
+            shortcode = post_id or (post_url.rstrip('/').split('/')[-1] if post_url else '')
+            if not shortcode and not post_id:
+                continue
+            timestamp = data.get('timestamp') or data.get('release_timestamp') or ''
+            thumbnail = str(data.get('thumbnail') or '').strip()
+            posts.append({
+                'id': post_id or shortcode,
+                'shortcode': shortcode,
+                'url': post_url or f'https://www.instagram.com/p/{shortcode}/',
+                'image_url': thumbnail,
+                'display_url': thumbnail,
+                'caption': str(data.get('description') or data.get('title') or '').strip(),
+                'published_at': timestamp,
+                'timestamp': timestamp,
+                'is_video': bool(data.get('vcodec') not in (None, 'none')),
+            })
+        posts = posts[:max(1, int(limit))]
+        print(f'yt-dlp sucesso para @{username}: {len(posts)} posts')
+        return posts
+    except Exception as exc:
+        print(f'yt-dlp exceção para @{username}: {exc}')
+        return []
+
+
 def fetch_public_instagram_posts(source: str, limit: int = 10) -> IntegrationResult:
     try:
         reference = normalize_instagram_reference(source)
     except ValueError as exc:
         return IntegrationResult(False, str(exc), {})
+    if platform.system() == 'Windows':
+        ytdlp_posts = _fetch_posts_with_ytdlp(reference['username'], limit)
+        print(f'yt-dlp posts retornados para @{reference["username"]}: {len(ytdlp_posts)}')
+        if ytdlp_posts:
+            return IntegrationResult(True, f'{len(ytdlp_posts)} posts obtidos via yt-dlp', reference | {'posts': ytdlp_posts})
     api_user = _fetch_web_profile_user(reference['username'])
     if api_user:
         api_posts: list[dict[str, Any]] = []

package/package.json

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