@danhachuel/thunderbolt 0.6.56 → 0.6.58

package/app/social_networks_ui.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
 
 import io
-import logging
 import re
 import uuid
 import zipfile
 import unicodedata
-import hashlib
 from typing import Any, Callable, Mapping
 
 import requests
@@ -17,19 +15,10 @@ 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 (
-    extract_public_instagram_country,
-    fetch_public_instagram_posts,
-    fetch_public_instagram_profile,
-    normalize_instagram_bio,
-    normalize_instagram_metric,
-)
+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
 
 
-LOGGER = logging.getLogger(__name__)
-
-
 def _clean(value: Any) -> str:
     return str(value or "").strip()
 
@@ -78,35 +67,11 @@ 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",
 }
 
 
@@ -124,17 +89,11 @@ 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_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
+    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 ""
 
 
 def _language_index(value: Any) -> int:
@@ -165,41 +124,10 @@ def _instagram_profile_storage_id(profile: Mapping[str, Any]) -> str:
     return re.sub(r"[^A-Za-z0-9_.-]+", "_", value) or "unknown"
 
 
-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"):
-        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:
-    base_id = _instagram_profile_storage_id(profile)
-    signature = "|".join(_clean(profile.get(key)) for key in ("bio", "bio_raw", "following_count", "subscriber_count", "post_count", "country"))
-    digest = hashlib.sha1(signature.encode("utf-8")).hexdigest()[:10]
-    return f"{base_id}_{digest}"
-
-
 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 []
-    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
+    return [dict(post) for post in value if isinstance(post, Mapping) and _clean(post.get("id") or post.get("url"))]
 
 
 def _stored_instagram_posts(profile: Mapping[str, Any]) -> list[dict[str, Any]]:
@@ -248,8 +176,8 @@ def _instagram_posts_archive(posts: list[dict[str, Any]]) -> bytes:
                     elif "webp" in content_type:
                         extension = ".webp"
                     bundle.writestr(f"post-{index:02d}{extension}", response.content)
-                except requests.RequestException as exc:
-                    LOGGER.warning("Não foi possível descarregar a imagem do post Instagram %s: %s", url, exc)
+                except requests.RequestException:
+                    pass
             manifest.append(f"{index}. {_clean(post.get('url'))}\n{_clean(post.get('caption'))}\n")
         bundle.writestr("posts.txt", "\n".join(manifest))
     return archive.getvalue()
@@ -270,14 +198,13 @@ def _render_instagram_posts(profile: Mapping[str, Any]) -> None:
         if load_clicked or refresh_clicked:
             target = max(10, len(posts)) if refresh_clicked else 10
             posts_ok, posts_message, loaded_posts = _load_instagram_posts(profile, limit=target)
-            # 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 = _normalise_instagram_posts(loaded_posts)
+                posts = loaded_posts
                 _persist_instagram_posts(profile, posts)
                 st.success(f"{len(posts)} posts carregados.")
+                st.rerun()
             else:
-                st.error(posts_message)
+                st.warning(posts_message)
         posts = st.session_state.get(state_key, posts)
         if not posts:
             st.info("Clique em Carregar últimos 10 para consultar os posts públicos desta conta.")
@@ -296,10 +223,9 @@ 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:
-                posts = _normalise_instagram_posts(loaded_posts)
-                _persist_instagram_posts(profile, posts)
-            else:
-                st.error(posts_message)
+                _persist_instagram_posts(profile, loaded_posts)
+                st.rerun()
+            st.warning(posts_message)
 
 
 def _api_card_defaults(kind: str) -> tuple[str, list[str], Callable[[Mapping[str, Any]], dict[str, Any]]]:
@@ -446,8 +372,7 @@ def _characters(settings: Mapping[str, Any]) -> tuple[list[dict[str, Any]], Any
         repository = get_repository(settings)
         items = [item for item in repository.list_influencers() if _clean(item.get("id")) != STANDALONE_CONTENT_INFLUENCER_ID]
         return items, repository
-    except Exception as exc:
-        LOGGER.warning("Não foi possível carregar as personagens: %s", exc, exc_info=True)
+    except (InfluencerBackendError, Exception):
         return [], None
 
 
@@ -559,39 +484,19 @@ def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, A
             refresh_col, edit_col = st.columns(2)
             with refresh_col:
                 if st.button("↻", help="Actualizar posts, seguidores e seguindo", key=f"refresh_instagram_{profile_id}"):
-                    try:
-                        refreshed_ok, refreshed_message, refreshed = _refresh_instagram_profile(profile)
-                    except Exception as exc:
-                        st.error(f"Falha ao actualizar o perfil Instagram: {exc}")
-                        refreshed_ok, refreshed_message, refreshed = False, str(exc), {}
+                    refreshed_ok, refreshed_message, refreshed = _refresh_instagram_profile(profile)
                     if refreshed_ok:
                         current_posts = _stored_instagram_posts(profile)
-                        try:
-                            posts_ok, posts_message, refreshed_posts = _load_instagram_posts(refreshed, limit=max(10, len(current_posts)))
-                        except Exception as exc:
-                            posts_ok, posts_message, refreshed_posts = False, str(exc), []
+                        posts_ok, _, refreshed_posts = _load_instagram_posts(refreshed, limit=max(10, len(current_posts)))
                         if posts_ok:
                             _persist_instagram_posts(profile, refreshed_posts)
-                        else:
-                            st.warning(f"Perfil actualizado, mas os posts não foram actualizados: {posts_message}")
-                        # Debug temporário removido após validação; manter para reactivar se necessário:
-                        # st.write({"profile_ok": refreshed_ok, "profile_message": refreshed_message, "profile_data": refreshed})
-                        # st.write({"posts_ok": posts_ok, "posts_message": posts_message, "posts_count": len(refreshed_posts)})
-                        try:
-                            updated = update_channel(profile_id, {**refreshed, "id": profile_id, "country": _profile_country(refreshed) or _profile_country(profile), "language": profile.get("language", ""), "character_id": profile.get("character_id", "")})
-                        except (OSError, PermissionError) as exc:
-                            st.error(f"Não foi possível guardar os dados no Windows: {exc}")
-                            return
-                        except Exception as exc:
-                            st.error(f"Falha ao guardar os dados da conta Instagram: {exc}")
-                            return
+                        updated = update_channel(profile_id, {**refreshed, "id": profile_id, "country": _profile_country(refreshed) or _profile_country(profile), "language": profile.get("language", ""), "character_id": profile.get("character_id", "")})
                         if updated is None:
-                            st.error("A conta Instagram já não existe no armazenamento local ou não foi possível escrever o ficheiro.")
+                            st.error("A conta Instagram já não existe no armazenamento local.")
                             return
                         st.success("Métricas Instagram actualizadas.")
                         st.rerun()
-                    else:
-                        st.error(f"Não foi possível actualizar o perfil Instagram: {refreshed_message}")
+                    st.warning(refreshed_message)
             with edit_col:
                 if st.button("Editar", key=f"edit_instagram_button_{profile_id}", use_container_width=True):
                     for field in ("name", "handle", "bio", "country", "language", "posts", "followers", "following"):
@@ -678,20 +583,15 @@ def render_social_networks(settings: dict[str, Any]) -> None:
         if search_clicked:
             result = fetch_public_instagram_profile(source)
             result_data = dict(result.data) if isinstance(result.data, dict) else {}
-            if result_data:
-                _clear_instagram_result_widget_state(result_data)
             st.session_state["social_instagram_result"] = result_data
             st.session_state["social_instagram_ok"] = result.ok
             st.session_state["social_instagram_message"] = result.message
         if st.session_state.get("social_instagram_message"):
-            if st.session_state.get("social_instagram_ok"):
-                st.success(st.session_state["social_instagram_message"])
-            else:
-                st.error(st.session_state["social_instagram_message"])
+            (st.success if st.session_state.get("social_instagram_ok") else st.warning)(st.session_state["social_instagram_message"])
         data = st.session_state.get("social_instagram_result", {}) if st.session_state.get("social_instagram_ok") else {}
         if data:
             characters, _ = _characters(settings)
-            result_widget_id = _instagram_result_widget_id(data)
+            result_widget_id = _instagram_profile_storage_id(data)
             with st.container(border=True):
                 st.subheader("Conta Instagram encontrada")
                 preview_cols = st.columns([0.8, 2.2, 1.2, 1.2, 1.2])

package/integrations/instagram_public.py

@@ -2,108 +2,23 @@ from __future__ import annotations
 
 import re
 import json
-import logging
 import os
 import platform
-import sys
 import shutil
 import subprocess
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from html import unescape
-from pathlib import Path
 from typing import Any, Mapping
 from urllib.parse import urlparse
 
 import requests
 
-try:
-    import streamlit as st
-except ImportError:  # pragma: no cover - Streamlit is a runtime dependency
-    st = None
-
-
-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/'
 ABOUT_ACCOUNT_BLOKS_VERSION = '8ca96ca267e30c02cf90888d91eeff09627f0e3fd2bd9df472278c9a6c022cbb'
 
 
-def _load_dotenv_compat() -> None:
-    """Load .env when python-dotenv exists, otherwise parse simple KEY=VALUE lines."""
-    try:
-        from dotenv import load_dotenv
-        load_dotenv()
-        return
-    except ImportError:
-        LOGGER.debug('python-dotenv não está instalado; será usado o parser .env compatível.')
-    env_path = Path(__file__).resolve().parents[1] / '.env'
-    if not env_path.is_file():
-        return
-    try:
-        for raw_line in env_path.read_text(encoding='utf-8').splitlines():
-            line = raw_line.strip()
-            if not line or line.startswith('#') or '=' not in line:
-                continue
-            key, value = line.split('=', 1)
-            value = value.strip().strip('"').strip("'")
-            os.environ.setdefault(key.strip(), value)
-    except OSError as exc:
-        LOGGER.warning('Não foi possível ler %s: %s', env_path, exc)
-
-
-def _streamlit_message(level: str, message: str, key: str) -> None:
-    """Show a runtime diagnostic once when Streamlit is available."""
-    if st is None:
-        return
-    try:
-        shown_key = f'_instagram_debug_{key}'
-        if st.session_state.get(shown_key):
-            return
-        st.session_state[shown_key] = True
-        getattr(st, level)(message)
-    except Exception as exc:  # Streamlit may be imported outside an active app context.
-        LOGGER.debug('Não foi possível mostrar diagnóstico Streamlit: %s', exc)
-
-
-def _ensure_windows_playwright() -> None:
-    """Ensure Chromium exists on Windows before using the Playwright fallback."""
-    global _WINDOWS_PLAYWRIGHT_CHECKED
-    if os.name != 'nt' or _WINDOWS_PLAYWRIGHT_CHECKED:
-        return
-    _WINDOWS_PLAYWRIGHT_CHECKED = True
-    _load_dotenv_compat()
-    try:
-        completed = subprocess.run(
-            [sys.executable, '-m', 'playwright', 'install', 'chromium'],
-            capture_output=True,
-            text=True,
-            encoding='utf-8',
-            errors='replace',
-            timeout=180,
-            check=False,
-        )
-        if completed.returncode != 0:
-            detail = (completed.stderr or completed.stdout or 'sem detalhes').strip()[-1000:]
-            message = f'Não foi possível instalar o Chromium do Playwright no Windows: {detail}'
-            LOGGER.warning(message)
-            _streamlit_message('error', message + ' Execute: python -m playwright install chromium', 'playwright_install_error')
-        else:
-            LOGGER.info('Chromium do Playwright verificado/instalado no Windows.')
-    except (OSError, subprocess.SubprocessError) as exc:
-        message = f'Falha ao executar a instalação do Chromium no Windows: {exc}'
-        LOGGER.warning(message)
-        _streamlit_message('error', message + ' Execute: python -m playwright install chromium', 'playwright_install_exception')
-
-
-_load_dotenv_compat()
-if os.name == 'nt':
-    _ensure_windows_playwright()
-
-
 def _instagram_cookies() -> dict[str, str]:
     cookies = {}
     sessionid = os.getenv('INSTAGRAM_SESSIONID') or os.getenv('IG_SESSIONID')
@@ -125,149 +40,34 @@ def _instagram_headers() -> dict[str, str]:
     }
 
 
-def _instagram_playwright_headless() -> bool:
-    """Use headed mode for Windows diagnostics unless explicitly overridden."""
-    value = os.getenv('INSTAGRAM_PLAYWRIGHT_HEADLESS', 'false').strip().casefold()
-    return value not in {'0', 'false', 'no', 'off'}
-
-
-def _save_instagram_debug_html(username: str, document: str) -> None:
-    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:
-        LOGGER.warning('Não foi possível salvar o HTML de diagnóstico Instagram: %s', exc)
-
-
-def _instagram_instaloader():
-    """Load the anonymous fallback, installing it once when the requirement is missing."""
-    global _INSTALOADER_INSTALL_ATTEMPTED
+def _fetch_instagram_html_with_playwright(url: str, username: str) -> str:
+    """Windows-only browser fallback; the existing Linux HTML parser remains authoritative."""
     try:
-        import instaloader
-        return instaloader
-    except ImportError:
-        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()
+        from playwright.sync_api import TimeoutError as PlaywrightTimeoutError, sync_playwright
+        with sync_playwright() as playwright:
+            browser = playwright.chromium.launch(headless=True)
+            try:
+                context = browser.new_context(
+                    user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/131.0 Safari/537.36',
+                    extra_http_headers={'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7'},
+                )
+                page = context.new_page()
+                response = page.goto(url, wait_until='domcontentloaded', timeout=30000)
+                status = response.status if response else None
+                print(f'Playwright usado no Windows para @{username}; status HTML={status}')
+                page.wait_for_timeout(5000)
                 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
-
-
-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:
-        return None
-    try:
-        loader = instaloader.Instaloader(
-            quiet=True,
-            request_timeout=30,
-            max_connection_attempts=1,
-            download_pictures=False,
-            download_videos=False,
-            download_video_thumbnails=False,
-            save_metadata=False,
-        )
-        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, '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',
-        }
-    except Exception as exc:
-        LOGGER.warning('Fallback instaloader falhou para @%s: %s', username, exc, exc_info=True)
-        return None
-
-
-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:
-        return []
-    posts: list[dict[str, Any]] = []
-    try:
-        loader = instaloader.Instaloader(
-            quiet=True,
-            request_timeout=30,
-            max_connection_attempts=1,
-            download_pictures=False,
-            download_videos=False,
-            download_video_thumbnails=False,
-            save_metadata=False,
-        )
-        profile = instaloader.Profile.from_username(loader.context, username)
-        for post in profile.get_posts():
-            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': image_url,
-                'display_url': image_url,
-                'caption': str(getattr(post, 'caption', '') or '').strip(),
-                'published_at': timestamp,
-                'timestamp': timestamp,
-                'is_video': bool(getattr(post, 'is_video', False)),
-            })
-            if len(posts) >= max(1, int(limit)):
-                break
-        LOGGER.info('Fallback instaloader carregou %s posts para @%s', len(posts), username)
+                    page.wait_for_load_state('networkidle', timeout=10000)
+                except (PlaywrightTimeoutError, TimeoutError):
+                    pass
+                html_content = page.content()
+                print(f'HTML Instagram recebido no Windows para @{username}: {len(html_content)} bytes')
+                return html_content
+            finally:
+                browser.close()
     except Exception as exc:
-        LOGGER.warning('Fallback instaloader falhou nos posts de @%s: %s', username, exc, exc_info=True)
-    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)
+        print(f'Playwright falhou no Windows para @{username}: {exc}')
+        return ''
 
 
 @dataclass
@@ -278,9 +78,8 @@ class IntegrationResult:
 
 
 def normalize_instagram_bio(value: Any) -> str:
-    """Keep the complete public biography exactly as returned by Instagram."""
-    bio = str(value or '').strip()
-    return bio
+    """Preserve the complete biography returned by Instagram."""
+    return str(value or '').strip()
 
 
 def normalize_instagram_reference(source: str) -> dict[str, str]:
@@ -350,230 +149,101 @@ def _structured_metric_from_json(document: str, *keys: str) -> int | None:
     return None
 
 
-def _profile_quality(user: Mapping[str, Any]) -> int:
-    groups = (
-        ('biography', 'bio', 'description'),
-        ('edge_follow', 'following', 'following_count', 'followingCount', 'follows'),
-        ('edge_followed_by', 'followers', 'follower_count', 'followers_count', 'followerCount'),
-        ('edge_owner_to_timeline_media', 'posts', 'post_count', 'media_count'),
-        ('username', 'user_name', 'handle'),
-    )
-    return sum(any(user.get(key) not in (None, '', {}, []) for key in group) for group in groups)
-
-
-def _merge_profile(base: dict[str, Any] | None, candidate: Mapping[str, Any]) -> dict[str, Any]:
-    merged = dict(base or {})
-    for key, value in candidate.items():
-        if value not in (None, '', [], {}):
-            if isinstance(value, Mapping) and isinstance(merged.get(key), Mapping):
-                merged[key] = {**merged[key], **value}
-            else:
-                merged[key] = value
-    return merged
-
-
-def _extract_profile_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,
-        (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,
-    ]
-    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]:
-    """Extract JSON assigned to window._sharedData from the rendered profile HTML."""
-    decoder = json.JSONDecoder()
-    documents: list[Any] = []
-    patterns = (
-        r'window\s*\.\s*_sharedData\s*=\s*',
-        r'window\s*\[\s*["\']_sharedData["\']\s*\]\s*=\s*',
-    )
-    for pattern in patterns:
-        for match in re.finditer(pattern, document, flags=re.IGNORECASE):
-            start = document.find('{', match.end())
-            if start < 0:
+def _extract_posts_from_html(document: str, limit: int = 10) -> list[dict[str, Any]]:
+    posts: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for payload in _embedded_json_documents(document):
+        for node in _walk_json(payload):
+            if not isinstance(node, dict):
                 continue
-            try:
-                parsed, _ = decoder.raw_decode(document[start:])
-            except json.JSONDecodeError:
+            post = _post_from_node(node)
+            if not post or post['id'] in seen:
                 continue
-            documents.append(parsed)
-    return documents
+            seen.add(post['id'])
+            posts.append(post)
+            if len(posts) >= max(1, int(limit)):
+                return posts
+    return posts
 
 
-def _profile_users_from_document(document: str) -> list[Mapping[str, Any]]:
-    """Return users found in legacy _sharedData and current embedded profile payloads."""
-    users: list[Mapping[str, Any]] = []
-    documents = _shared_data_documents(document) + _embedded_json_documents(document)
-    for payload in documents:
-        direct = _extract_profile_user(payload)
-        if isinstance(direct, Mapping):
-            users.append(direct)
-        for node in _walk_json(payload):
-            if not isinstance(node, Mapping):
-                continue
-            candidate = node.get('user')
-            if isinstance(candidate, Mapping) and any(key in candidate for key in ('biography', 'edge_follow', 'edge_followed_by', 'username')):
-                users.append(candidate)
-    unique: list[Mapping[str, Any]] = []
-    seen: set[int] = set()
-    for user in users:
-        marker = id(user)
-        if marker not in seen:
-            seen.add(marker)
-            unique.append(user)
-    return unique
-
-
-def _fetch_profile_with_playwright(username: str, headers: Mapping[str, str] | None = None, cookies: Mapping[str, str] | None = None) -> dict[str, Any] | None:
-    """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
-    try:
-        from playwright.sync_api import TimeoutError as PlaywrightTimeoutError, sync_playwright
-        with sync_playwright() as playwright:
-            browser = playwright.chromium.launch(headless=_instagram_playwright_headless())
-            try:
-                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:
-                    context.add_cookies([{'name': name, 'value': value, 'domain': '.instagram.com', 'path': '/'} for name, value in cookies.items()])
-                page = context.new_page()
+def _extract_profile_user_from_html(document: str, username: str) -> dict[str, Any]:
+    description = _meta(document, 'og:description')
+    title = _meta(document, 'og:title') or username
+    avatar_url = _meta(document, 'og:image')
 
-                def capture_profile_response(response: Any) -> None:
-                    nonlocal captured_user
-                    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 = _extract_profile_user(payload)
-                        if isinstance(user, Mapping):
-                            captured_user = _merge_profile(captured_user, user)
-                            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.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=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 = None
-                status = None
-                try:
-                    response = page.goto(url, wait_until='domcontentloaded', timeout=30000)
-                    status = response.status if response else None
-                except Exception as exc:
-                    LOGGER.warning('Instagram Playwright navegação falhou URL=%s: %s', url, exc)
-                LOGGER.info('Instagram Playwright profile URL=%s status=%s', url, status)
+    def metric(patterns: tuple[str, ...]) -> int | None:
+        for pattern in patterns:
+            found = re.search(pattern, description, flags=re.IGNORECASE)
+            if found:
                 try:
-                    page.wait_for_timeout(5000)
-                except Exception:
+                    return int(re.sub(r'[^0-9]', '', found.group(1)))
+                except ValueError:
                     pass
-                try:
-                    page.wait_for_load_state('networkidle', timeout=10000)
-                except (PlaywrightTimeoutError, TimeoutError):
-                    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:
-        LOGGER.warning('Falha no Playwright do perfil Instagram: %s', exc, exc_info=True)
-        _streamlit_message('error', f'Playwright não conseguiu consultar o perfil Instagram: {exc}', 'profile_playwright_error')
-    return captured_user
+        return None
+
+    followers = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:followers|seguidores)',)) or _structured_metric(document, 'edge_followed_by', 'followers', 'follower_count') or _structured_metric_from_json(document, 'edge_followed_by', 'followers', 'follower_count', 'followerCount')
+    following = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:following|seguindo)',)) or _structured_metric(document, 'edge_follow', 'follows', 'following', 'following_count', 'followingCount') or _structured_metric_from_json(document, 'edge_follow', 'follows', 'following', 'following_count', 'followingCount')
+    post_count = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:posts|publicações|publications)',)) or _structured_metric(document, 'edge_owner_to_timeline_media', 'posts', 'post_count')
+    country = ''
+    for payload in _embedded_json_documents(document):
+        country = extract_public_instagram_country(payload)
+        if country:
+            break
+    posts = _extract_posts_from_html(document, 10)
+    user: dict[str, Any] = {
+        'username': username,
+        'full_name': title.split('(')[0].strip() or username,
+        'biography': description,
+        'edge_followed_by': {'count': followers} if followers is not None else {},
+        'edge_follow': {'count': following} if following is not None else {},
+        'edge_owner_to_timeline_media': {'count': post_count, 'edges': [{'node': post} for post in posts]},
+        'country': country,
+        'profile_pic_url': avatar_url,
+        '_html_posts': posts,
+    }
+    return user if any((description, followers, following, post_count, country, posts)) else {}
 
 
 def _fetch_web_profile_user(username: str) -> dict[str, Any] | None:
-    _ensure_windows_playwright()
-    cookies = _instagram_cookies()
     headers = _instagram_headers()
     headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/131.0 Safari/537.36'
-    if platform.system() == 'Windows':
-        LOGGER.debug('Windows detectado: perfil Instagram exclusivamente via Playwright.')
-        playwright_user = _fetch_profile_with_playwright(username, headers, cookies)
-        if playwright_user:
-            return playwright_user
-        LOGGER.warning('Fallback para instaloader activado no perfil @%s.', 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
-
+    # 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}',
     )
+    def profile_quality(user: Mapping[str, Any]) -> int:
+        return sum(bool(user.get(key)) for key in ('biography', 'edge_follow', 'edge_followed_by', 'edge_owner_to_timeline_media', 'username'))
+
+    def merge_profile(base: dict[str, Any] | None, candidate: Mapping[str, Any]) -> dict[str, Any]:
+        merged = dict(base or {})
+        for key, value in candidate.items():
+            if value not in (None, '', [], {}):
+                if isinstance(value, Mapping) and isinstance(merged.get(key), Mapping):
+                    merged[key] = {**merged[key], **value}
+                else:
+                    merged[key] = value
+        return merged
 
-    request_headers = [
-        headers,
-        {**headers, 'User-Agent': 'Instagram 390.0.0.0.50 Android', 'Accept': 'application/json, text/plain, */*'},
-        {**headers, 'Referer': f'https://www.instagram.com/{username}/', 'Origin': 'https://www.instagram.com', 'X-Requested-With': 'XMLHttpRequest'},
-    ]
     best_user: dict[str, Any] | None = None
-    for request_header in request_headers:
-        for endpoint in endpoints:
-            try:
-                response = requests.get(endpoint, headers=request_header, cookies=cookies or None, timeout=15)
-                LOGGER.debug('Instagram profile URL=%s status=%s content_type=%s', endpoint, response.status_code, response.headers.get('content-type', ''))
-                if response.status_code >= 400:
-                    continue
-                payload = response.json()
-                LOGGER.debug('Instagram profile URL=%s response=JSON', endpoint)
-            except (requests.RequestException, ValueError, AttributeError, StopIteration):
-                LOGGER.warning('Falha na requisição JSON do perfil Instagram URL=%s', endpoint, exc_info=True)
-                if best_user:
-                    return best_user
+    for endpoint in endpoints:
+        try:
+            response = requests.get(endpoint, headers=headers, timeout=15)
+            if response.status_code >= 400:
                 continue
-            user = _extract_profile_user(payload)
-            if isinstance(user, dict):
-                best_user = _merge_profile(best_user, user)
-                if _profile_quality(best_user) >= 4:
-                    return best_user
+            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):
+            best_user = merge_profile(best_user, user)
+            if profile_quality(best_user) >= 4:
+                return best_user
 
     curl = shutil.which('curl')
     if curl:
-        LOGGER.debug('Fallback curl disponível em %s', curl)
         for endpoint in endpoints:
             try:
                 completed = subprocess.run(
@@ -586,20 +256,21 @@ 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
-                LOGGER.debug('Instagram curl URL=%s returncode=%s stdout_bytes=%s stderr=%s', endpoint, completed.returncode, len(completed.stdout or ''), (completed.stderr or '').strip()[-500:])
-                user = _extract_profile_user(payload)
+                user = ((payload.get('data') or {}).get('user') if isinstance(payload, dict) else None)
                 if isinstance(user, dict):
-                    best_user = _merge_profile(best_user, user)
-                    if _profile_quality(best_user) >= 4:
+                    best_user = merge_profile(best_user, user)
+                    if profile_quality(best_user) >= 4:
                         return best_user
             except (OSError, subprocess.SubprocessError, ValueError):
-                LOGGER.warning('Falha no fallback curl do perfil Instagram URL=%s', endpoint, exc_info=True)
                 continue
-    else:
-        LOGGER.warning('curl não está disponível no PATH; a tentar Playwright.')
-        _streamlit_message('warning', 'curl não foi encontrado no PATH do Windows; será tentado o fallback Playwright.', 'curl_missing')
-
-    return _fetch_profile_with_playwright(username, headers, cookies) or best_user
+    if platform.system() == 'Windows':
+        html_content = _fetch_instagram_html_with_playwright(f'https://www.instagram.com/{username}/', username)
+        if html_content:
+            html_user = _extract_profile_user_from_html(html_content, username)
+            if html_user:
+                print(f'Perfil Instagram extraído do HTML no Windows para @{username}')
+                return html_user
+    return best_user
 
 
 def _country_from_bloks(value: Any) -> str:
@@ -649,72 +320,25 @@ def _fetch_instagram_about_country(user_id: Any) -> str:
     }
     try:
         response = requests.post(ABOUT_ACCOUNT_URL, data=payload, headers=_instagram_headers(), cookies=cookies, timeout=20)
-        LOGGER.debug('Instagram about-account URL=%s status=%s content_type=%s', ABOUT_ACCOUNT_URL, response.status_code, response.headers.get('content-type', ''))
         if response.status_code >= 400:
             return ''
-        country = _country_from_bloks(response.json())
-        LOGGER.debug('Instagram about-account country_found=%s', bool(country))
-        return country
-    except (requests.RequestException, ValueError, TypeError) as exc:
-        LOGGER.warning('Falha ao consultar país público do Instagram: %s', exc, exc_info=True)
+        return _country_from_bloks(response.json())
+    except (requests.RequestException, ValueError, TypeError):
         return ''
 
 
-def _country_from_bio_fallback(bio: str) -> str:
-    patterns = (
-        r'\b(?:from|based in|located in|living in)\s+([A-Za-zÀ-ÿ][A-Za-zÀ-ÿ .-]{1,60})',
-        r'\b(?:de|baseado em|morando em|localizado em)\s+([A-Za-zÀ-ÿ][A-Za-zÀ-ÿ .-]{1,60})',
-    )
-    for pattern in patterns:
-        match = re.search(pattern, bio or '', flags=re.IGNORECASE)
-        if match:
-            return match.group(1).strip(' .,!;:')
-    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')
-    following = normalize_instagram_metric(following_node) if isinstance(following_node, Mapping) else None
-    following = following if following is not None else _profile_metric(user, 'follows', 'following', 'following_count', 'followingCount')
+    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_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()
-    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 '—')
+    media = ((user.get('edge_owner_to_timeline_media') or {}).get('count') if isinstance(user.get('edge_owner_to_timeline_media'), dict) else None)
+    biography = str(user.get('biography') or '').strip()
+    country = extract_public_instagram_country(user) or _fetch_instagram_about_country(user.get('id') or user.get('pk'))
     return {
         'id': f"instagram_{reference['username']}",
         **reference,
-        'name': str(user.get('full_name') or user.get('name') or user.get('username') or reference['username']).strip(),
+        'name': str(user.get('full_name') or user.get('username') or reference['username']).strip(),
         'bio': normalize_instagram_bio(biography),
         'bio_raw': biography,
         'country': country,
@@ -726,7 +350,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': [dict(node) for node in _profile_post_nodes(user)],
+        '_api_posts': (((user.get('edge_owner_to_timeline_media') or {}).get('edges') or []) if isinstance(user.get('edge_owner_to_timeline_media'), dict) else []),
     }
 
 
@@ -741,14 +365,10 @@ 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',
-}
-PUBLIC_TRANSPARENCY_KEYS = {
-    'about', 'about_account', 'about_this_account', 'about_this_account_data',
-    'account_transparency', 'transparency', 'account_info', 'profile_context',
+    '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', 'account_transparency', 'transparency', 'account_info'}
 
 
 def _country_value(value: Any) -> str:
@@ -792,25 +412,17 @@ def _profile_metric(user: Mapping[str, Any], *keys: str) -> int | None:
 
 
 def fetch_public_instagram_profile(source: str) -> IntegrationResult:
-    LOGGER.debug('fetch_public_instagram_profile source=%s', source)
     try:
         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:
-        data = _profile_data_from_api(api_user, reference)
-        if api_user.get('_instagram_source') == 'instaloader':
-            return IntegrationResult(True, 'Perfil encontrado via fallback instaloader. O país pode não estar disponível.', data)
-        return IntegrationResult(True, 'Perfil Instagram encontrado publicamente.', data)
-    if platform.system() == 'Windows':
-        return IntegrationResult(False, 'Não foi possível obter os dados do Instagram. Verifique sua conexão ou tente novamente mais tarde.', reference)
+        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:
-        LOGGER.warning('Falha HTTP no perfil Instagram URL=%s: %s', reference['url'], exc, exc_info=True)
         return IntegrationResult(False, f'Não foi possível consultar o perfil público do Instagram: {exc}', reference)
-    LOGGER.debug('Instagram HTML profile URL=%s status=%s content_type=%s response=HTML', reference['url'], response.status_code, response.headers.get('content-type', ''))
     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})
     title = _meta(response.text, 'og:title') or reference['username']
@@ -835,8 +447,6 @@ def fetch_public_instagram_profile(source: str) -> IntegrationResult:
         embedded_country = extract_public_instagram_country(document)
         if embedded_country:
             break
-    embedded_country = embedded_country or _country_from_bio_fallback(description)
-    LOGGER.debug('Instagram HTML profile extracted bio=%s followers=%s following=%s posts=%s country=%s', bool(description), followers, following, posts, embedded_country or '—')
     data = {'id': f"instagram_{reference['username']}", **reference, 'name': title.split('(')[0].strip() or reference['username'], 'bio': normalize_instagram_bio(description), 'bio_raw': description, 'country': embedded_country, 'avatar_url': avatar_url, 'subscriber_count': followers, 'following_count': following, 'post_count': posts, 'public_lookup': True, 'metrics_source': 'instagram_public_page', 'last_public_lookup_at': datetime.now(timezone.utc).isoformat()}
     return IntegrationResult(True, 'Perfil Instagram encontrado publicamente.', data)
 
@@ -898,104 +508,35 @@ def _post_from_node(node: dict[str, Any]) -> dict[str, Any] | None:
     }
 
 
-def _fetch_posts_with_playwright(reference: Mapping[str, str], limit: int, cookies: Mapping[str, str] | None = None) -> list[dict[str, Any]]:
-    # CORREÇÃO WINDOWS: posts são extraídos exclusivamente da resposta API capturada pelo Playwright.
-    posts: list[dict[str, Any]] = []
-    seen: set[str] = set()
-    cookies = cookies or _instagram_cookies()
-    try:
-        from playwright.sync_api import TimeoutError as PlaywrightTimeoutError, sync_playwright
-        with sync_playwright() as playwright:
-            browser = playwright.chromium.launch(headless=_instagram_playwright_headless())
-            try:
-                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:
-                    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:
-                    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 = _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)
-                    except (ValueError, TypeError, AttributeError) as exc:
-                        LOGGER.debug('Não foi possível interpretar posts web_profile_info: %s', exc)
-
-                page.on('response', capture_profile_posts)
-                try:
-                    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=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):
-                    LOGGER.debug('Instagram Playwright networkidle excedido; usando posts API já capturados.')
-                LOGGER.debug('Instagram Playwright API posts extracted=%s limit=%s', len(posts), limit)
-                return posts[:max(1, int(limit))]
-            finally:
-                browser.close()
-    except Exception as exc:
-        LOGGER.warning('Falha no Playwright dos posts Instagram: %s', exc, exc_info=True)
-        _streamlit_message('error', f'Playwright não conseguiu consultar os posts Instagram: {exc}', 'posts_playwright_error')
-    return posts
-
-
 def fetch_public_instagram_posts(source: str, limit: int = 10) -> IntegrationResult:
-    LOGGER.debug('fetch_public_instagram_posts source=%s limit=%s', source, limit)
-    _ensure_windows_playwright()
     try:
         reference = normalize_instagram_reference(source)
     except ValueError as exc:
         return IntegrationResult(False, str(exc), {})
-    if platform.system() == 'Windows':
-        LOGGER.debug('Windows detectado: posts Instagram exclusivamente via Playwright.')
-        posts = _fetch_posts_with_playwright(reference, limit, _instagram_cookies())
-        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 obter os dados do Instagram. Verifique sua conexão ou tente novamente mais tarde.', 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 node in _profile_post_nodes(api_user):
-            post = _post_from_node(dict(node))
-            if post:
-                api_posts.append(post)
+        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)
         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))]})
         if api_user.get('is_private'):
             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))]})
+    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 []
+        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))]})
     try:
-        response = requests.get(reference['url'], headers={'User-Agent': 'Mozilla/5.0', 'Accept-Language': 'pt-BR,pt;q=0.9,en;q=0.8'}, cookies=_instagram_cookies() or None, timeout=15)
+        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:
-        LOGGER.warning('Falha HTTP nos posts Instagram URL=%s: %s', reference['url'], exc, exc_info=True)
         return IntegrationResult(False, f'Não foi possível consultar os posts públicos do Instagram: {exc}', reference)
-    LOGGER.debug('Instagram HTML posts URL=%s status=%s content_type=%s response=HTML', reference['url'], response.status_code, response.headers.get('content-type', ''))
     if response.status_code >= 400:
         return IntegrationResult(False, f'O Instagram devolveu HTTP {response.status_code} ao consultar os posts.', reference | {'status_code': response.status_code})
     posts: list[dict[str, Any]] = []
@@ -1011,10 +552,7 @@ def fetch_public_instagram_posts(source: str, limit: int = 10) -> IntegrationRes
                 break
         if len(posts) >= max(1, int(limit)):
             break
-    if not posts:
-        posts = _fetch_posts_with_playwright(reference, limit, _instagram_cookies())
-    LOGGER.debug('Instagram posts extracted=%s limit=%s', len(posts), limit)
-    return IntegrationResult(bool(posts), 'Posts públicos encontrados.' if posts else 'Não foi possível obter os dados do Instagram. Verifique sua conexão ou tente novamente mais tarde.', 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[:max(1, int(limit))]})
 
 
-__all__ = ['IntegrationResult', 'extract_public_instagram_country', 'fetch_posts_instaloader', 'fetch_profile_instaloader', 'fetch_public_instagram_posts', 'fetch_public_instagram_profile', 'normalize_instagram_bio', 'normalize_instagram_metric', 'normalize_instagram_reference']
+__all__ = ['IntegrationResult', 'extract_public_instagram_country', '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.56",
+  "version": "0.6.58",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",

package/requirements.txt

@@ -26,6 +26,5 @@ kagglehub>=0.3,<1
 supabase>=2.4,<3
 bilibili-api-python>=17.4,<18
 playwright>=1.45,<2
-instaloader>=4.14,<5
 composio>=0.21,<1
 justokenmax @ https://github.com/Kalmantic/jusTokenMax/archive/refs/heads/main.zip#subdirectory=python