@danhachuel/thunderbolt 0.6.23 → 0.6.25

package/app/social_networks_ui.py

@@ -13,7 +13,7 @@ from hermes_ui.influencers import InfluencerBackendError, STANDALONE_CONTENT_INF
 from hermes_ui.storage import read_json, write_json
 from hermes_ui.countries import COUNTRY_OPTIONS
 from hermes_ui.languages import LANGUAGE_CODES, language_code, language_label
-from integrations.instagram_public import fetch_public_instagram_posts, fetch_public_instagram_profile, normalize_instagram_bio
+from integrations.instagram_public import fetch_public_instagram_posts, fetch_public_instagram_profile, normalize_instagram_bio, normalize_instagram_metric
 from integrations.meta_social import test_facebook_pages_api_card, test_instagram_api_card
 
 
@@ -38,6 +38,10 @@ def _profile_metric(profile: Mapping[str, Any], *keys: str) -> Any:
     return None
 
 
+def _metric_input(value: Any) -> int | None:
+    return normalize_instagram_metric(value)
+
+
 def _language_index(value: Any) -> int:
     code = language_code(value)
     return list(LANGUAGE_CODES).index(code) if code in LANGUAGE_CODES else list(LANGUAGE_CODES).index("pt")
@@ -288,6 +292,7 @@ def _save_public_profile(data: Mapping[str, Any], *, country: str, language: str
         "name": name,
         "url": url,
         "handle": _clean(data.get("handle")),
+        "bio": normalize_instagram_bio(data.get("bio")),
         "country": country.strip(),
         "language": language.strip(),
         "post_count": data.get("post_count"),
@@ -300,6 +305,14 @@ def _save_public_profile(data: Mapping[str, Any], *, country: str, language: str
     return create_channel(name, url, metadata)
 
 
+def _merge_instagram_refresh(existing: Mapping[str, Any], refreshed: Mapping[str, Any]) -> dict[str, Any]:
+    merged = dict(refreshed)
+    for field in ("subscriber_count", "following_count", "post_count", "bio", "avatar_url"):
+        if merged.get(field) in (None, "") and existing.get(field) not in (None, ""):
+            merged[field] = existing[field]
+    return merged
+
+
 def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, Any]], settings: Mapping[str, Any]) -> None:
     profile_id = _clean(profile.get("id"))
     edit_key = f"edit_instagram_profile_{profile_id}"
@@ -329,10 +342,7 @@ def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, A
                 if st.button("↻", help="Actualizar posts, seguidores e seguindo", key=f"refresh_instagram_{profile_id}"):
                     result = fetch_public_instagram_profile(_clean(profile.get("url")) or _clean(profile.get("handle")))
                     if result.ok:
-                        refreshed = dict(result.data)
-                        for field in ("subscriber_count", "following_count", "post_count", "bio", "avatar_url"):
-                            if refreshed.get(field) in (None, "") and profile.get(field) not in (None, ""):
-                                refreshed[field] = profile[field]
+                        refreshed = _merge_instagram_refresh(profile, result.data)
                         update_channel(profile_id, {**refreshed, "platform": "instagram", "country": profile.get("country", ""), "language": profile.get("language", ""), "character_id": profile.get("character_id", "")})
                         st.success("Métricas Instagram actualizadas.")
                         st.rerun()
@@ -368,15 +378,16 @@ def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, A
                 with edit_cols[0]:
                     name = st.text_input("Nome", value=_clean(profile.get("name")), key=f"instagram_edit_name_{profile_id}")
                     handle = st.text_input("handler", value=_clean(profile.get("handle")), key=f"instagram_edit_handle_{profile_id}")
+                    bio = st.text_area("Bio", value=normalize_instagram_bio(profile.get("bio")), key=f"instagram_edit_bio_{profile_id}")
                     country = st.selectbox("País", _country_options(), index=_country_index(profile.get("country")), format_func=_country_label, key=f"instagram_edit_country_{profile_id}")
                     language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=_language_index(profile.get("language")), format_func=language_label, key=f"instagram_edit_language_{profile_id}")
                 with edit_cols[1]:
-                    posts = st.number_input("posts", min_value=0, value=int(profile.get("post_count") or 0), key=f"instagram_edit_posts_{profile_id}")
-                    followers = st.number_input("Seguidores", min_value=0, value=int(profile.get("subscriber_count") or 0), key=f"instagram_edit_followers_{profile_id}")
-                    following = st.number_input("seguindo", min_value=0, value=int(profile.get("following_count") or 0), key=f"instagram_edit_following_{profile_id}")
+                    posts = st.number_input("posts", min_value=0, value=_metric_input(profile.get("post_count")), placeholder="Não encontrado", key=f"instagram_edit_posts_{profile_id}")
+                    followers = st.number_input("Seguidores", min_value=0, value=_metric_input(profile.get("subscriber_count")), placeholder="Não encontrado", key=f"instagram_edit_followers_{profile_id}")
+                    following = st.number_input("seguindo", min_value=0, value=_metric_input(profile.get("following_count")), placeholder="Não encontrado", key=f"instagram_edit_following_{profile_id}")
                 save_edit = st.form_submit_button("Guardar alterações", type="primary", use_container_width=True)
             if save_edit:
-                update_channel(profile_id, {"name": name.strip(), "handle": handle.strip(), "country": country.strip(), "language": language, "post_count": int(posts), "subscriber_count": int(followers), "following_count": int(following)})
+                update_channel(profile_id, {"name": name.strip(), "handle": handle.strip(), "bio": normalize_instagram_bio(bio), "country": country.strip(), "language": language, "post_count": _metric_input(posts), "subscriber_count": _metric_input(followers), "following_count": _metric_input(following)})
                 st.session_state.pop(edit_key, None)
                 st.success("Conta Instagram actualizada.")
                 st.rerun()
@@ -449,19 +460,20 @@ def render_social_networks(settings: dict[str, Any]) -> None:
                     form_cols = st.columns(2)
                     with form_cols[0]:
                         name = st.text_input("Nome", value=_clean(data.get("name")), key="social_instagram_result_name")
+                        bio = st.text_area("Bio", value=normalize_instagram_bio(data.get("bio")), key="social_instagram_result_bio")
                         country = st.selectbox("País", _country_options(), index=_country_index(data.get("country")), format_func=_country_label, key="social_instagram_result_country")
                         language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=_language_index(data.get("language")), format_func=language_label, key="social_instagram_result_language")
                     with form_cols[1]:
-                        posts = st.number_input("posts", min_value=0, value=int(data.get("post_count") or 0), key="social_instagram_result_posts")
-                        followers = st.number_input("Seguidores", min_value=0, value=int(data.get("subscriber_count") or 0), key="social_instagram_result_followers")
-                        following = st.number_input("seguindo", min_value=0, value=int(data.get("following_count") or 0), key="social_instagram_result_following")
+                        posts = st.number_input("posts", min_value=0, value=_metric_input(data.get("post_count")), placeholder="Não encontrado", key="social_instagram_result_posts")
+                        followers = st.number_input("Seguidores", min_value=0, value=_metric_input(data.get("subscriber_count")), placeholder="Não encontrado", key="social_instagram_result_followers")
+                        following = st.number_input("seguindo", min_value=0, value=_metric_input(data.get("following_count")), placeholder="Não encontrado", key="social_instagram_result_following")
                     character_options = [""] + [_clean(item.get("id")) for item in characters if _clean(item.get("id"))]
                     character_labels = {"": "Sem personagem associado"} | {_clean(item.get("id")): _clean(item.get("name")) or _clean(item.get("id")) for item in characters}
                     selected_character = st.selectbox("Personagem", character_options, format_func=lambda value: character_labels.get(value, value), key="social_instagram_result_character")
                     save_profile = st.form_submit_button("Cadastrar conta Instagram", type="primary", use_container_width=True)
                 if save_profile:
                     profile_data = dict(data)
-                    profile_data.update({"name": name, "post_count": int(posts), "subscriber_count": int(followers), "following_count": int(following)})
+                    profile_data.update({"name": name, "bio": normalize_instagram_bio(bio), "post_count": _metric_input(posts), "subscriber_count": _metric_input(followers), "following_count": _metric_input(following)})
                     _save_public_profile(profile_data, country=country, language=language, character_id=selected_character)
                     st.success("Conta Instagram cadastrada em Redes Sociais.")
                     for key in ("social_instagram_result", "social_instagram_ok", "social_instagram_message"):

package/hermes_ui/domain.py

@@ -36,6 +36,7 @@ def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = N
         "platform": "youtube",
         "social_network": "YouTube",
         "handle": "",
+        "bio": "",
         "description": "",
         "description_source": "",
         "niche": "",

package/integrations/instagram_public.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import re
 import json
+import shutil
+import subprocess
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from html import unescape
@@ -96,29 +98,52 @@ def _structured_metric_from_json(document: str, *keys: str) -> int | None:
 
 
 def _fetch_web_profile_user(username: str) -> dict[str, Any] | None:
-    try:
-        response = requests.get(
-            f'https://i.instagram.com/api/v1/users/web_profile_info/?username={username}',
-            headers={
-                'x-ig-app-id': '936619743392459',
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/131.0 Safari/537.36',
-                'Accept': '*/*',
-                'Accept-Language': 'en-US,en;q=0.9',
-            },
-            timeout=15,
-        )
-        if response.status_code >= 400:
-            return None
-        payload = response.json()
-    except (requests.RequestException, ValueError, AttributeError):
-        return None
-    user = ((payload.get('data') or {}).get('user') if isinstance(payload, dict) else None)
-    return user if isinstance(user, dict) else None
+    headers = {
+        'x-ig-app-id': '936619743392459',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/131.0 Safari/537.36',
+        'Accept': 'application/json, text/plain, */*',
+        'Accept-Language': 'en-US,en;q=0.9',
+    }
+    # The www host is the current public web endpoint. The legacy i host is
+    # retained as a fallback because Instagram rate-limits the two hosts
+    # independently and their availability can vary by region.
+    endpoints = (
+        f'https://www.instagram.com/api/v1/users/web_profile_info/?username={username}',
+        f'https://i.instagram.com/api/v1/users/web_profile_info/?username={username}',
+    )
+    for endpoint in endpoints:
+        try:
+            response = requests.get(endpoint, headers=headers, timeout=15)
+            if response.status_code >= 400:
+                continue
+            payload = response.json()
+        except (requests.RequestException, ValueError, AttributeError):
+            continue
+        user = ((payload.get('data') or {}).get('user') if isinstance(payload, dict) else None)
+        if isinstance(user, dict):
+            return user
+    curl = shutil.which('curl')
+    if curl:
+        try:
+            completed = subprocess.run(
+                [curl, '-L', '--max-time', '20', '-sS', '-A', headers['User-Agent'], '-H', f"x-ig-app-id: {headers['x-ig-app-id']}", endpoint],
+                capture_output=True,
+                text=True,
+                timeout=25,
+                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)
+            if isinstance(user, dict):
+                return user
+        except (OSError, subprocess.SubprocessError, ValueError):
+            pass
+    return None
 
 
 def _profile_data_from_api(user: Mapping[str, Any], reference: Mapping[str, str]) -> dict[str, Any]:
-    followers = _direct_profile_metric(user, 'edge_followed_by', 'followers', 'follower_count', 'followerCount')
-    following = _direct_profile_metric(user, 'edge_follow', 'follows', 'following', 'following_count', 'followingCount')
+    followers = _profile_metric(user, 'edge_followed_by', 'followers', 'follower_count', 'followerCount')
+    following = _profile_metric(user, 'edge_follow', 'follows', 'following', 'following_count', 'followingCount')
     followers = followers if followers is not None else _structured_metric_from_json(json.dumps(user), 'edge_followed_by', 'followers', 'follower_count', 'followerCount')
     following = following if following is not None else _structured_metric_from_json(json.dumps(user), 'edge_follow', 'follows', 'following', 'following_count', 'followingCount')
     media = ((user.get('edge_owner_to_timeline_media') or {}).get('count') if isinstance(user.get('edge_owner_to_timeline_media'), dict) else None)
@@ -138,18 +163,21 @@ def _profile_data_from_api(user: Mapping[str, Any], reference: Mapping[str, str]
     }
 
 
-def _direct_profile_metric(user: Mapping[str, Any], *keys: str) -> int | None:
-    """Read common profile counters before falling back to recursive JSON parsing."""
+def normalize_instagram_metric(value: Any) -> int | None:
+    """Normalize an Instagram counter without turning an unknown value into zero."""
+    if isinstance(value, Mapping):
+        value = value.get('count') or value.get('value')
+    if value in (None, ''):
+        return None
+    digits = re.sub(r'[^0-9]', '', str(value))
+    return int(digits) if digits else None
+
+
+def _profile_metric(user: Mapping[str, Any], *keys: str) -> int | None:
     for key in keys:
-        value = user.get(key)
-        if isinstance(value, Mapping):
-            value = value.get('count') or value.get('value')
-        if value in (None, ''):
-            continue
-        try:
-            return int(value)
-        except (TypeError, ValueError):
-            continue
+        value = normalize_instagram_metric(user.get(key))
+        if value is not None:
+            return value
     return None
 
 
@@ -158,15 +186,15 @@ def fetch_public_instagram_profile(source: str) -> IntegrationResult:
         reference = normalize_instagram_reference(source)
     except ValueError as exc:
         return IntegrationResult(False, str(exc), {})
+    api_user = _fetch_web_profile_user(reference['username'])
+    if api_user:
+        return IntegrationResult(True, 'Perfil Instagram encontrado publicamente.', _profile_data_from_api(api_user, reference))
     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=12)
     except requests.RequestException as exc:
         return IntegrationResult(False, f'Não foi possível consultar o perfil público do Instagram: {exc}', reference)
     if response.status_code >= 400:
         return IntegrationResult(False, f'O Instagram devolveu HTTP {response.status_code}. Confirme o @handle ou use o cadastro manual.', reference | {'status_code': response.status_code})
-    api_user = _fetch_web_profile_user(reference['username'])
-    if api_user:
-        return IntegrationResult(True, 'Perfil Instagram encontrado publicamente.', _profile_data_from_api(api_user, reference))
     title = _meta(response.text, 'og:title') or reference['username']
     description = _meta(response.text, 'og:description')
     avatar_url = _meta(response.text, 'og:image')
@@ -283,4 +311,4 @@ def fetch_public_instagram_posts(source: str, limit: int = 10) -> IntegrationRes
     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))]})
 
 
-__all__ = ['IntegrationResult', 'fetch_public_instagram_posts', 'fetch_public_instagram_profile', 'normalize_instagram_bio', 'normalize_instagram_reference']
+__all__ = ['IntegrationResult', 'fetch_public_instagram_posts', 'fetch_public_instagram_profile', 'normalize_instagram_bio', 'normalize_instagram_metric', 'normalize_instagram_reference']

package/package.json

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