@danhachuel/thunderbolt 0.6.53 → 0.6.55

package/app/social_networks_ui.py

@@ -17,7 +17,13 @@ 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, normalize_instagram_metric
+from integrations.instagram_public import (
+    extract_public_instagram_country,
+    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
 
 
@@ -72,11 +78,35 @@ def _country_key(value: Any) -> str:
 COUNTRY_ALIASES = {
     "brazil": "Brasil",
     "brasil": "Brasil",
+    "br": "Brasil",
     "usa": "Estados Unidos",
     "us": "Estados Unidos",
     "united states": "Estados Unidos",
     "united states of america": "Estados Unidos",
+    "pt": "Portugal",
     "portugal": "Portugal",
+    "uk": "Reino Unido",
+    "gb": "Reino Unido",
+    "united kingdom": "Reino Unido",
+    "england": "Reino Unido",
+    "germany": "Alemanha",
+    "de": "Alemanha",
+    "france": "França",
+    "fr": "França",
+    "italy": "Itália",
+    "it": "Itália",
+    "spain": "Espanha",
+    "es": "Espanha",
+    "canada": "Canadá",
+    "ca": "Canadá",
+    "australia": "Austrália",
+    "au": "Austrália",
+    "japan": "Japão",
+    "jp": "Japão",
+    "mexico": "México",
+    "mx": "México",
+    "argentina": "Argentina",
+    "ar": "Argentina",
 }
 
 
@@ -94,11 +124,17 @@ def _normalise_country(value: Any) -> str:
 
 
 def _profile_country(profile: Mapping[str, Any]) -> str:
-    for key in ("country", "country_name", "country_of_registration", "account_country", "account_based_in"):
-        country = _normalise_country(profile.get(key))
-        if country:
-            return country
-    return ""
+    for key in ("country", "country_name", "country_of_registration", "account_country", "account_based_in", "country_code"):
+        raw_value = profile.get(key)
+        candidates = [raw_value]
+        if isinstance(raw_value, Mapping):
+            candidates.extend(raw_value.get(child) for child in ("name", "label", "display_name", "country", "country_name", "code"))
+        for candidate in candidates:
+            country = _normalise_country(candidate)
+            if country:
+                return country
+    extracted = _normalise_country(extract_public_instagram_country(profile))
+    return extracted
 
 
 def _language_index(value: Any) -> int:
@@ -130,9 +166,13 @@ def _instagram_profile_storage_id(profile: Mapping[str, Any]) -> str:
 
 
 def _clear_instagram_result_widget_state(profile: Mapping[str, Any]) -> None:
+    """Clear every previous widget key for this profile before rebuilding the form."""
     widget_id = _instagram_profile_storage_id(profile)
     for field in ("name", "bio", "country", "language", "posts", "followers", "following", "character"):
-        st.session_state.pop(f"social_instagram_result_{field}_{widget_id}", None)
+        prefix = f"social_instagram_result_{field}_{widget_id}"
+        for key in list(st.session_state.keys()):
+            if str(key).startswith(prefix):
+                st.session_state.pop(key, None)
 
 
 def _instagram_result_widget_id(profile: Mapping[str, Any]) -> str:
@@ -143,9 +183,23 @@ def _instagram_result_widget_id(profile: Mapping[str, Any]) -> str:
 
 
 def _normalise_instagram_posts(value: Any) -> list[dict[str, Any]]:
+    if isinstance(value, Mapping):
+        value = value.get("posts") or value.get("items") or value.get("edges") or []
     if not isinstance(value, list):
         return []
-    return [dict(post) for post in value if isinstance(post, Mapping) and _clean(post.get("id") or post.get("url"))]
+    normalised: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for item in value:
+        post = item.get("node") if isinstance(item, Mapping) and isinstance(item.get("node"), Mapping) else item
+        if not isinstance(post, Mapping):
+            continue
+        data = dict(post)
+        identifier = _clean(data.get("id") or data.get("shortcode") or data.get("url"))
+        if not identifier or identifier in seen:
+            continue
+        seen.add(identifier)
+        normalised.append(data)
+    return normalised
 
 
 def _stored_instagram_posts(profile: Mapping[str, Any]) -> list[dict[str, Any]]:
@@ -219,10 +273,9 @@ def _render_instagram_posts(profile: Mapping[str, Any]) -> None:
             # DEBUG WINDOWS INSTAGRAM: manter até a validação final do carregamento público.
             st.write({"instagram_posts_ok": posts_ok, "instagram_posts_message": posts_message, "instagram_posts_count": len(loaded_posts)})
             if posts_ok:
-                posts = loaded_posts
+                posts = _normalise_instagram_posts(loaded_posts)
                 _persist_instagram_posts(profile, posts)
                 st.success(f"{len(posts)} posts carregados.")
-                st.rerun()
             else:
                 st.warning(posts_message)
         posts = st.session_state.get(state_key, posts)
@@ -243,9 +296,10 @@ def _render_instagram_posts(profile: Mapping[str, Any]) -> None:
         if st.button("Mostrar + 10", key=f"more_instagram_posts_{profile_id}", use_container_width=True):
             posts_ok, posts_message, loaded_posts = _load_instagram_posts(profile, limit=len(posts) + 10)
             if posts_ok:
-                _persist_instagram_posts(profile, loaded_posts)
-                st.rerun()
-            st.warning(posts_message)
+                posts = _normalise_instagram_posts(loaded_posts)
+                _persist_instagram_posts(profile, posts)
+            else:
+                st.warning(posts_message)
 
 
 def _api_card_defaults(kind: str) -> tuple[str, list[str], Callable[[Mapping[str, Any]], dict[str, Any]]]:

package/integrations/instagram_public.py

@@ -25,6 +25,7 @@ except ImportError:  # pragma: no cover - Streamlit is a runtime dependency
 
 LOGGER = logging.getLogger(__name__)
 _WINDOWS_PLAYWRIGHT_CHECKED = False
+_INSTALOADER_INSTALL_ATTEMPTED = False
 
 
 ABOUT_ACCOUNT_URL = 'https://i.instagram.com/api/v1/bloks/apps/com.instagram.interactions.about_this_account/'
@@ -131,8 +132,10 @@ def _instagram_playwright_headless() -> bool:
 
 
 def _save_instagram_debug_html(username: str, document: str) -> None:
-    path = Path(os.getenv('INSTAGRAM_DEBUG_PROFILE_HTML', str(Path(__file__).resolve().parents[1] / 'debug_profile.html')))
+    storage_dir = Path(__file__).resolve().parents[1] / 'storage'
+    path = Path(os.getenv('INSTAGRAM_DEBUG_PROFILE_HTML', str(storage_dir / 'debug_instagram.html')))
     try:
+        path.parent.mkdir(parents=True, exist_ok=True)
         path.write_text(document, encoding='utf-8')
         LOGGER.info('HTML salvo em %s', path)
     except OSError as exc:
@@ -140,16 +143,38 @@ def _save_instagram_debug_html(username: str, document: str) -> None:
 
 
 def _instagram_instaloader():
-    """Load the optional anonymous fallback without mutating the user's environment."""
+    """Load the anonymous fallback, installing it once when the requirement is missing."""
+    global _INSTALOADER_INSTALL_ATTEMPTED
     try:
         import instaloader
+        return instaloader
     except ImportError:
-        LOGGER.warning('Fallback instaloader indisponível; instale com: python -m pip install instaloader')
+        if _INSTALOADER_INSTALL_ATTEMPTED:
+            LOGGER.warning('Fallback instaloader indisponível; instale com: python -m pip install instaloader')
+            return None
+        _INSTALOADER_INSTALL_ATTEMPTED = True
+        try:
+            LOGGER.info('Instaloader ausente; a tentar instalar a dependência automaticamente.')
+            completed = subprocess.run(
+                [sys.executable, '-m', 'pip', 'install', 'instaloader>=4.14,<5'],
+                capture_output=True, text=True, encoding='utf-8', errors='replace', timeout=180, check=False,
+            )
+            if completed.returncode == 0:
+                import importlib
+                importlib.invalidate_caches()
+                try:
+                    import instaloader
+                    return instaloader
+                except ImportError:
+                    LOGGER.warning('Instaloader foi instalado, mas não ficou disponível neste interpretador.')
+            LOGGER.warning('Instalação automática do instaloader falhou: %s', (completed.stderr or completed.stdout)[-1000:])
+        except (OSError, subprocess.SubprocessError) as exc:
+            LOGGER.warning('Não foi possível instalar instaloader automaticamente: %s', exc)
+        _streamlit_message('error', 'O fallback instaloader não está disponível. Instale com: python -m pip install instaloader', 'instaloader_missing')
         return None
-    return instaloader
 
 
-def fetch_profile_instaloader(username: str) -> dict[str, Any] | None:
+def _fetch_profile_instaloader(username: str) -> dict[str, Any] | None:
     """Fetch a public profile anonymously through Instaloader when Playwright fails."""
     instaloader = _instagram_instaloader()
     if instaloader is None:
@@ -157,6 +182,8 @@ def fetch_profile_instaloader(username: str) -> dict[str, Any] | None:
     try:
         loader = instaloader.Instaloader(
             quiet=True,
+            request_timeout=30,
+            max_connection_attempts=1,
             download_pictures=False,
             download_videos=False,
             download_video_thumbnails=False,
@@ -164,14 +191,23 @@ def fetch_profile_instaloader(username: str) -> dict[str, Any] | None:
         )
         profile = instaloader.Profile.from_username(loader.context, username)
         LOGGER.info('Fallback instaloader activado para o perfil @%s', username)
+        country = next(
+            (
+                str(getattr(profile, attribute, '') or '').strip()
+                for attribute in ('country', 'country_name', 'country_of_registration', 'account_country', 'account_based_in')
+                if str(getattr(profile, attribute, '') or '').strip()
+            ),
+            '',
+        )
         return {
             'id': str(getattr(profile, 'userid', '') or ''),
             'username': str(getattr(profile, 'username', '') or username),
             'full_name': str(getattr(profile, 'full_name', '') or ''),
             'biography': str(getattr(profile, 'biography', '') or ''),
-            'follower_count': getattr(profile, 'followers', None),
-            'following_count': getattr(profile, 'followees', None),
+            'follower_count': getattr(profile, 'follower_count', getattr(profile, 'followers', None)),
+            'following_count': getattr(profile, 'following_count', getattr(profile, 'followees', None)),
             'edge_owner_to_timeline_media': {'count': getattr(profile, 'mediacount', None)},
+            'country': country,
             'is_private': bool(getattr(profile, 'is_private', False)),
             '_instagram_source': 'instaloader',
         }
@@ -180,7 +216,7 @@ def fetch_profile_instaloader(username: str) -> dict[str, Any] | None:
         return None
 
 
-def fetch_posts_instaloader(username: str, limit: int = 10) -> list[dict[str, Any]]:
+def _fetch_posts_instaloader(username: str, limit: int = 10) -> list[dict[str, Any]]:
     """Fetch public posts anonymously through Instaloader when Playwright fails."""
     instaloader = _instagram_instaloader()
     if instaloader is None:
@@ -189,6 +225,8 @@ def fetch_posts_instaloader(username: str, limit: int = 10) -> list[dict[str, An
     try:
         loader = instaloader.Instaloader(
             quiet=True,
+            request_timeout=30,
+            max_connection_attempts=1,
             download_pictures=False,
             download_videos=False,
             download_video_thumbnails=False,
@@ -199,13 +237,21 @@ def fetch_posts_instaloader(username: str, limit: int = 10) -> list[dict[str, An
             shortcode = str(getattr(post, 'shortcode', '') or '')
             if not shortcode:
                 continue
+            image_url = str(getattr(post, 'url', '') or '')
+            timestamp = getattr(post, 'date_utc', '') or ''
+            if hasattr(timestamp, 'isoformat'):
+                timestamp = timestamp.isoformat()
+            else:
+                timestamp = str(timestamp)
             posts.append({
                 'id': str(getattr(post, 'mediaid', '') or shortcode),
                 'shortcode': shortcode,
                 'url': f'https://www.instagram.com/p/{shortcode}/',
-                'image_url': str(getattr(post, 'url', '') or ''),
+                'image_url': image_url,
+                'display_url': image_url,
                 'caption': str(getattr(post, 'caption', '') or '').strip(),
-                'published_at': getattr(post, 'date_utc', '') or '',
+                'published_at': timestamp,
+                'timestamp': timestamp,
                 'is_video': bool(getattr(post, 'is_video', False)),
             })
             if len(posts) >= max(1, int(limit)):
@@ -216,6 +262,14 @@ def fetch_posts_instaloader(username: str, limit: int = 10) -> list[dict[str, An
     return posts
 
 
+def fetch_profile_instaloader(username: str) -> dict[str, Any] | None:
+    return _fetch_profile_instaloader(username)
+
+
+def fetch_posts_instaloader(username: str, limit: int = 10) -> list[dict[str, Any]]:
+    return _fetch_posts_instaloader(username, limit)
+
+
 @dataclass
 class IntegrationResult:
     ok: bool
@@ -326,8 +380,17 @@ def _extract_profile_user(payload: Any) -> Mapping[str, Any] | None:
         (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,
+        (payload.get('xdt_api__v1__users__web_profile_info') or {}).get('user') if isinstance(payload.get('xdt_api__v1__users__web_profile_info'), Mapping) else None,
     ]
-    return next((candidate for candidate in candidates if isinstance(candidate, Mapping)), None)
+    direct = next((candidate for candidate in candidates if isinstance(candidate, Mapping)), None)
+    if direct is not None:
+        return direct
+    for node in _walk_json(payload):
+        if not isinstance(node, Mapping) or not node.get('username'):
+            continue
+        if any(key in node for key in ('biography', 'edge_follow', 'edge_followed_by', 'follower_count', 'following_count', 'full_name')):
+            return node
+    return None
 
 
 def _shared_data_documents(document: str) -> list[Any]:
@@ -376,7 +439,7 @@ def _profile_users_from_document(document: str) -> list[Mapping[str, Any]]:
 
 
 def _fetch_profile_with_playwright(username: str, headers: Mapping[str, str] | None = None, cookies: Mapping[str, str] | None = None) -> dict[str, Any] | None:
-    """Fetch the structured profile JSON requested by the public Instagram page."""
+    """Fetch a public profile using browser state, API responses and embedded HTML data."""
     headers = headers or _instagram_headers()
     cookies = cookies or _instagram_cookies()
     captured_user: dict[str, Any] | None = None
@@ -385,47 +448,72 @@ def _fetch_profile_with_playwright(username: str, headers: Mapping[str, str] | N
         with sync_playwright() as playwright:
             browser = playwright.chromium.launch(headless=_instagram_playwright_headless())
             try:
-                page = browser.new_page(
-                    user_agent=headers['User-Agent'],
-                    extra_http_headers={'x-ig-app-id': headers['x-ig-app-id'], 'Accept-Language': 'en-US,en;q=0.9', 'Accept': 'application/json, text/plain, */*', 'Origin': 'https://www.instagram.com', 'Referer': 'https://www.instagram.com/'},
-                )
+                headers_for_context = {'x-ig-app-id': headers['x-ig-app-id'], 'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7', 'Accept': 'application/json, text/plain, */*', 'Origin': 'https://www.instagram.com', 'Referer': 'https://www.instagram.com/'}
+                state_path = Path(__file__).resolve().parents[1] / 'storage' / 'instagram_storage_state.json'
+                context_kwargs = {'user_agent': headers['User-Agent'], 'extra_http_headers': headers_for_context}
+                if state_path.is_file():
+                    context_kwargs['storage_state'] = str(state_path)
+                context = browser.new_context(**context_kwargs)
                 if cookies:
-                    page.context.add_cookies([{'name': name, 'value': value, 'domain': '.instagram.com', 'path': '/'} for name, value in cookies.items()])
+                    context.add_cookies([{'name': name, 'value': value, 'domain': '.instagram.com', 'path': '/'} for name, value in cookies.items()])
+                page = context.new_page()
 
                 def capture_profile_response(response: Any) -> None:
                     nonlocal captured_user
-                    if '/api/v1/users/web_profile_info/' not in response.url:
+                    response_url = str(getattr(response, 'url', '') or '')
+                    if not any(marker in response_url for marker in ('/api/v1/users/web_profile_info/', '/graphql/query')):
                         return
+                    status = getattr(response, 'status', None)
+                    LOGGER.info('Instagram Playwright API response URL=%s status=%s', response_url, status)
                     try:
                         payload = response.json()
-                        user = ((payload.get('data') or {}).get('user') if isinstance(payload, Mapping) else None)
+                        user = _extract_profile_user(payload)
                         if isinstance(user, Mapping):
                             captured_user = _merge_profile(captured_user, user)
-                            LOGGER.debug('Instagram Playwright API profile captured user=%s', username)
+                            LOGGER.info('Instagram Playwright perfil capturado URL=%s status=%s quality=%s', response_url, status, _profile_quality(captured_user))
                     except (ValueError, TypeError, AttributeError) as exc:
-                        LOGGER.debug('Não foi possível interpretar resposta web_profile_info: %s', exc)
+                        LOGGER.warning('Não foi possível interpretar resposta Instagram URL=%s status=%s: %s', response_url, status, exc)
+
 
                 page.on('response', capture_profile_response)
                 try:
-                    page.goto('https://www.instagram.com/', wait_until='domcontentloaded', timeout=10000)
-                    LOGGER.debug('Instagram Playwright página inicial carregada para cookies.')
+                    page.goto('https://www.instagram.com/', wait_until='domcontentloaded', timeout=30000)
+                    state_path.parent.mkdir(parents=True, exist_ok=True)
+                    context.storage_state(path=str(state_path))
+                    LOGGER.debug('Instagram Playwright página inicial carregada; storage_state salvo em %s.', state_path)
                 except Exception as exc:
                     LOGGER.debug('Instagram Playwright não carregou a página inicial: %s', exc)
                 url = f'https://www.instagram.com/{username}/'
-                response = page.goto(url, wait_until='domcontentloaded', timeout=10000)
-                LOGGER.debug('Instagram Playwright profile URL=%s status=%s', url, response.status if response else None)
-                if response is None or response.status >= 400:
-                    LOGGER.warning('Instagram Playwright perfil HTTP status=%s URL=%s', response.status if response else None, url)
-                    return captured_user
+                response = None
+                status = None
                 try:
-                    _save_instagram_debug_html(username, page.content())
+                    response = page.goto(url, wait_until='domcontentloaded', timeout=30000)
+                    status = response.status if response else None
                 except Exception as exc:
-                    LOGGER.debug('Não foi possível guardar HTML de diagnóstico: %s', exc)
+                    LOGGER.warning('Instagram Playwright navegação falhou URL=%s: %s', url, exc)
+                LOGGER.info('Instagram Playwright profile URL=%s status=%s', url, status)
+                try:
+                    page.wait_for_timeout(5000)
+                except Exception:
+                    pass
                 try:
                     page.wait_for_load_state('networkidle', timeout=10000)
                 except (PlaywrightTimeoutError, TimeoutError):
-                    LOGGER.debug('Instagram Playwright networkidle excedido; usando resposta API já capturada.')
-                LOGGER.info('Instagram Playwright API profile captured=%s quality=%s URL=%s', bool(captured_user), _profile_quality(captured_user or {}), url)
+                    LOGGER.debug('Instagram Playwright networkidle excedido; usando dados já capturados.')
+                try:
+                    document = page.content()
+                    _save_instagram_debug_html(username, document)
+                    for user in _profile_users_from_document(document):
+                        if isinstance(user, Mapping):
+                            candidate = _merge_profile(captured_user, user)
+                            if _profile_quality(candidate) >= _profile_quality(captured_user or {}):
+                                captured_user = candidate
+                except Exception as exc:
+                    LOGGER.warning('Não foi possível guardar/analisar HTML de diagnóstico URL=%s: %s', url, exc)
+                if response is None or status is None or status >= 400:
+                    LOGGER.warning('Instagram Playwright perfil HTTP status=%s URL=%s', status, url)
+                    return captured_user
+                LOGGER.info('Instagram Playwright perfil final captured=%s quality=%s URL=%s', bool(captured_user), _profile_quality(captured_user or {}), url)
             finally:
                 browser.close()
     except Exception as exc:
@@ -445,7 +533,12 @@ def _fetch_web_profile_user(username: str) -> dict[str, Any] | None:
         if playwright_user:
             return playwright_user
         LOGGER.warning('Fallback para instaloader activado no perfil @%s.', username)
-        return fetch_profile_instaloader(username)
+        fallback_user = fetch_profile_instaloader(username)
+        if fallback_user:
+            _streamlit_message('info', 'Dados obtidos via fallback (instaloader). O país pode não estar disponível.', 'profile_instaloader_fallback')
+        else:
+            _streamlit_message('error', 'Não foi possível obter os dados do Instagram. Verifique sua conexão ou tente novamente mais tarde.', 'profile_instagram_failed')
+        return fallback_user
 
     endpoints = (
         f'https://www.instagram.com/api/v1/users/web_profile_info/?username={username}',
@@ -579,6 +672,30 @@ def _country_from_bio_fallback(bio: str) -> str:
     return ''
 
 
+def _profile_post_nodes(user: Mapping[str, Any]) -> list[Mapping[str, Any]]:
+    """Return post nodes from both legacy GraphQL edges and current items payloads."""
+    containers: list[Any] = [
+        user.get('edge_owner_to_timeline_media'),
+        user.get('timeline_media'),
+        user.get('media'),
+        user,
+    ]
+    nodes: list[Mapping[str, Any]] = []
+    for container in containers:
+        if not isinstance(container, Mapping):
+            continue
+        raw_items = container.get('edges') or container.get('items') or container.get('data') or []
+        if isinstance(raw_items, Mapping):
+            raw_items = raw_items.get('items') or raw_items.get('edges') or []
+        if not isinstance(raw_items, list):
+            continue
+        for item in raw_items:
+            node = item.get('node') if isinstance(item, Mapping) and isinstance(item.get('node'), Mapping) else item
+            if isinstance(node, Mapping):
+                nodes.append(node)
+    return nodes
+
+
 def _profile_data_from_api(user: Mapping[str, Any], reference: Mapping[str, str]) -> dict[str, Any]:
     followers = _profile_metric(user, 'edge_followed_by', 'followers', 'follower_count', 'followerCount')
     following_node = user.get('edge_follow')
@@ -586,10 +703,12 @@ def _profile_data_from_api(user: Mapping[str, Any], reference: Mapping[str, str]
     following = following if following is not None else _profile_metric(user, '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)
+    media_node = user.get('edge_owner_to_timeline_media') or user.get('media')
+    media = (media_node.get('count') if isinstance(media_node, Mapping) else None)
     media = media if media is not None else _profile_metric(user, 'posts', 'post_count', 'media_count')
     biography = str(user.get('biography') or user.get('bio') or user.get('description') or '').strip()
-    country = extract_public_instagram_country(user) or _fetch_instagram_about_country(user.get('id') or user.get('pk'))
+    direct_country = _country_value(user.get('country') or user.get('country_code'))
+    country = direct_country or extract_public_instagram_country(user) or _fetch_instagram_about_country(user.get('id') or user.get('pk'))
     country = country or _country_from_bio_fallback(biography)
     LOGGER.debug('Instagram profile extracted keys=%s edge_follow=%r bio=%s followers=%s following=%s posts=%s country=%s', sorted(str(key) for key in user.keys()), following_node, bool(biography), followers, following, media, country or '—')
     return {
@@ -607,7 +726,7 @@ def _profile_data_from_api(user: Mapping[str, Any], reference: Mapping[str, str]
         'public_lookup': True,
         'metrics_source': 'instagram_web_profile_info',
         'last_public_lookup_at': datetime.now(timezone.utc).isoformat(),
-        '_api_posts': (((user.get('edge_owner_to_timeline_media') or {}).get('edges') or []) if isinstance(user.get('edge_owner_to_timeline_media'), dict) else (user.get('posts') if isinstance(user.get('posts'), list) else [])),
+        '_api_posts': [dict(node) for node in _profile_post_nodes(user)],
     }
 
 
@@ -622,10 +741,14 @@ def normalize_instagram_metric(value: Any) -> int | None:
 
 
 PUBLIC_COUNTRY_KEYS = {
-    'about_this_account_country', 'account_based_in', 'account_country', 'country_name',
-    'country_of_origin', 'country_of_registration', 'location_country', 'transparency_country',
+    'about_this_account_country', 'account_based_in', 'account_country',
+    'country_name', 'country_of_origin', 'country_of_registration', 'location_country',
+    'transparency_country',
+}
+PUBLIC_TRANSPARENCY_KEYS = {
+    'about', 'about_account', 'about_this_account', 'about_this_account_data',
+    'account_transparency', 'transparency', 'account_info', 'profile_context',
 }
-PUBLIC_TRANSPARENCY_KEYS = {'about', 'about_account', 'account_transparency', 'transparency', 'account_info'}
 
 
 def _country_value(value: Any) -> str:
@@ -785,26 +908,26 @@ def _fetch_posts_with_playwright(reference: Mapping[str, str], limit: int, cooki
         with sync_playwright() as playwright:
             browser = playwright.chromium.launch(headless=_instagram_playwright_headless())
             try:
-                page = browser.new_page(
-                    user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/131.0 Safari/537.36',
-                    extra_http_headers={'x-ig-app-id': '936619743392459', 'Accept-Language': 'en-US,en;q=0.9', 'Accept': 'application/json, text/plain, */*', 'Origin': 'https://www.instagram.com', 'Referer': 'https://www.instagram.com/'},
-                )
+                state_path = Path(__file__).resolve().parents[1] / 'storage' / 'instagram_storage_state.json'
+                headers_for_context = {'x-ig-app-id': '936619743392459', 'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7', 'Accept': 'application/json, text/plain, */*', 'Origin': 'https://www.instagram.com', 'Referer': 'https://www.instagram.com/'}
+                context_kwargs = {'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/131.0 Safari/537.36', 'extra_http_headers': headers_for_context}
+                if state_path.is_file():
+                    context_kwargs['storage_state'] = str(state_path)
+                context = browser.new_context(**context_kwargs)
                 if cookies:
-                    page.context.add_cookies([{'name': name, 'value': value, 'domain': '.instagram.com', 'path': '/'} for name, value in cookies.items()])
+                    context.add_cookies([{'name': name, 'value': value, 'domain': '.instagram.com', 'path': '/'} for name, value in cookies.items()])
+                page = context.new_page()
 
                 def capture_profile_posts(response: Any) -> None:
-                    if '/api/v1/users/web_profile_info/' not in response.url:
+                    response_url = str(getattr(response, 'url', '') or '')
+                    if not any(marker in response_url for marker in ('/api/v1/users/web_profile_info/', '/graphql/query')):
                         return
+                    LOGGER.info('Instagram Playwright posts response URL=%s status=%s', response_url, getattr(response, 'status', None))
                     try:
                         payload = response.json()
-                        user = ((payload.get('data') or {}).get('user') if isinstance(payload, Mapping) else None)
-                        media = user.get('edge_owner_to_timeline_media') if isinstance(user, Mapping) else None
-                        edges = media.get('edges') if isinstance(media, Mapping) else []
-                        for edge in edges or []:
-                            node = edge.get('node') if isinstance(edge, Mapping) else None
-                            if not isinstance(node, dict):
-                                continue
-                            post = _post_from_node(node)
+                        user = _extract_profile_user(payload)
+                        for node in _profile_post_nodes(user) if isinstance(user, Mapping) else []:
+                            post = _post_from_node(dict(node))
                             if post and post['id'] not in seen:
                                 seen.add(post['id'])
                                 posts.append(post)
@@ -813,13 +936,16 @@ def _fetch_posts_with_playwright(reference: Mapping[str, str], limit: int, cooki
 
                 page.on('response', capture_profile_posts)
                 try:
-                    page.goto('https://www.instagram.com/', wait_until='domcontentloaded', timeout=10000)
+                    page.goto('https://www.instagram.com/', wait_until='domcontentloaded', timeout=30000)
+                    state_path.parent.mkdir(parents=True, exist_ok=True)
+                    context.storage_state(path=str(state_path))
                 except Exception as exc:
                     LOGGER.debug('Instagram Playwright não carregou a página inicial para posts: %s', exc)
-                response = page.goto(reference['url'], wait_until='domcontentloaded', timeout=10000)
+                response = page.goto(reference['url'], wait_until='domcontentloaded', timeout=30000)
                 LOGGER.debug('Instagram Playwright posts URL=%s status=%s', reference['url'], response.status if response else None)
                 if response is None or response.status >= 400:
                     return []
+                page.wait_for_timeout(5000)
                 try:
                     page.wait_for_load_state('networkidle', timeout=10000)
                 except (PlaywrightTimeoutError, TimeoutError):
@@ -847,16 +973,18 @@ def fetch_public_instagram_posts(source: str, limit: int = 10) -> IntegrationRes
         if not posts:
             LOGGER.warning('Fallback para instaloader activado nos posts de @%s.', reference['username'])
             posts = fetch_posts_instaloader(reference['username'], limit)
+            if posts:
+                _streamlit_message('info', 'Dados obtidos via fallback (instaloader). O país pode não estar disponível.', 'posts_instaloader_fallback')
+            else:
+                _streamlit_message('error', 'Não foi possível obter os dados do Instagram. Verifique sua conexão ou tente novamente mais tarde.', 'posts_instagram_failed')
         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))]})
     api_user = _fetch_web_profile_user(reference['username'])
     if api_user:
         api_posts: list[dict[str, Any]] = []
-        for edge in ((api_user.get('edge_owner_to_timeline_media') or {}).get('edges') or []):
-            node = edge.get('node') if isinstance(edge, dict) else None
-            if isinstance(node, dict):
-                post = _post_from_node(node)
-                if post:
-                    api_posts.append(post)
+        for node in _profile_post_nodes(api_user):
+            post = _post_from_node(dict(node))
+            if post:
+                api_posts.append(post)
         if api_posts:
             LOGGER.debug('Instagram API posts extracted=%s response=JSON', len(api_posts))
             return IntegrationResult(True, 'Posts públicos encontrados.', reference | {'posts': api_posts[:max(1, int(limit))]})

package/package.json

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