Update app.py

app.py

@@ -43,7 +43,6 @@ logger = logging.getLogger(__name__)
 # ============================================================
 API_TOKEN = os.environ.get("API_TOKEN", "").strip()
 
-# Log para debug - verificar se o token foi carregado
 if API_TOKEN:
     logger.info(f"[AUTH] API_TOKEN configurado ({len(API_TOKEN)} caracteres)")
     logger.info(f"[AUTH] Primeiros 4 chars: {API_TOKEN[:4]}...")
@@ -55,7 +54,7 @@ security = HTTPBearer(auto_error=False)
 async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
     """Verifica o token de autenticação"""
     if not API_TOKEN:
-        return True  # Sem token configurado = sem autenticação
+        return True
     
     if not credentials:
         raise HTTPException(status_code=401, detail="Token não fornecido")
@@ -73,10 +72,9 @@ class SessionManager:
     def __init__(self):
         self.sessions: Dict[str, dict] = {}
         self.max_sessions = 5
-        self.session_timeout = 1800  # 30 minutos
+        self.session_timeout = 1800
 
     def create_session(self, url: str) -> dict:
-        """Cria nova sessão Selenium"""
         self._cleanup_expired()
 
         if len(self.sessions) >= self.max_sessions:
@@ -93,7 +91,6 @@ class SessionManager:
         chrome_options.add_argument('--window-size=1920,1080')
         chrome_options.add_argument('--disable-extensions')
         chrome_options.add_argument('--disable-plugins')
-        chrome_options.add_argument('--disable-images')
         chrome_options.add_argument('--disable-blink-features=AutomationControlled')
         chrome_options.add_argument('--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36')
         chrome_options.binary_location = '/usr/bin/google-chrome'
@@ -104,12 +101,9 @@ class SessionManager:
             driver = webdriver.Chrome(service=service, options=chrome_options)
             driver.set_page_load_timeout(60)
             driver.implicitly_wait(10)
-
-            # Habilitar logs do console
             driver.execute_cdp_cmd('Runtime.enable', {})
             driver.execute_cdp_cmd('Log.enable', {})
             driver.execute_cdp_cmd('Network.enable', {})
-
         except Exception as e:
             logger.error(f"[SESSION] Erro ao criar driver: {e}")
             raise HTTPException(status_code=500, detail=f"Erro ao iniciar navegador: {str(e)}")
@@ -144,21 +138,16 @@ class SessionManager:
         }
 
     def get_session(self, session_id: str) -> dict:
-        """Recupera sessão ativa"""
         if session_id not in self.sessions:
             raise HTTPException(status_code=404, detail="Sessão não encontrada")
-
         session = self.sessions[session_id]
-
         if time.time() - session['last_used'] > self.session_timeout:
             self.close_session(session_id)
             raise HTTPException(status_code=410, detail="Sessão expirada")
-
         session['last_used'] = time.time()
         return session
 
     def close_session(self, session_id: str):
-        """Fecha sessão"""
         if session_id in self.sessions:
             try:
                 self.sessions[session_id]['driver'].quit()
@@ -168,7 +157,6 @@ class SessionManager:
             logger.info(f"[SESSION] Fechada: {session_id[:8]}...")
 
     def _cleanup_expired(self):
-        """Remove sessões expiradas"""
         expired = [
             sid for sid, s in self.sessions.items()
             if time.time() - s['last_used'] > self.session_timeout
@@ -177,7 +165,6 @@ class SessionManager:
             self.close_session(sid)
 
     def close_all(self):
-        """Fecha todas as sessões"""
         for sid in list(self.sessions.keys()):
             self.close_session(sid)
 
@@ -190,7 +177,6 @@ session_manager = SessionManager()
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Gerencia ciclo de vida da aplicação"""
     logger.info("=" * 50)
     logger.info("[SERVER] Site Backup & Error Checker v1.3.0")
     logger.info(f"[SERVER] Auth: {'ATIVO (token configurado)' if API_TOKEN else 'DESATIVADO'}")
@@ -208,7 +194,6 @@ app = FastAPI(
     lifespan=lifespan
 )
 
-# CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -246,19 +231,6 @@ class NavigateRequest(BaseModel):
     session_id: str
     url: str
 
-class InteractClickRequest(BaseModel):
-    session_id: str
-    x: int
-    y: int
-
-class InteractTypeRequest(BaseModel):
-    session_id: str
-    text: str
-
-class InteractKeyRequest(BaseModel):
-    session_id: str
-    key: str
-
 class SearchSiteRequest(BaseModel):
     session_id: str
     term: str
@@ -271,7 +243,6 @@ class SearchSiteRequest(BaseModel):
 @app.get("/")
 @app.head("/")
 async def root():
-    """Status do servidor"""
     return {
         "status": "online",
         "service": "Site Backup & Error Checker",
@@ -282,7 +253,6 @@ async def root():
 @app.get("/health")
 @app.head("/health")
 async def health():
-    """Health check"""
     return {
         "status": "healthy",
         "timestamp": time.time(),
@@ -296,16 +266,13 @@ async def health():
 
 @app.post("/auth/verify")
 async def auth_verify(auth=Depends(verify_token)):
-    """Verifica se o token é válido"""
     return {"valid": True, "message": "Token válido"}
 
 @app.post("/open")
 async def open_site(request: OpenSiteRequest, auth=Depends(verify_token)):
-    """Abre um site no Selenium"""
     url = request.url.strip()
     if not url.startswith(('http://', 'https://')):
         url = 'https://' + url
-
     try:
         result = session_manager.create_session(url)
         return result
@@ -317,17 +284,14 @@ async def open_site(request: OpenSiteRequest, auth=Depends(verify_token)):
 
 @app.post("/session/status")
 async def session_status(request: SessionRequest, auth=Depends(verify_token)):
-    """Status da sessão"""
     session = session_manager.get_session(request.session_id)
     driver = session['driver']
-
     try:
         current_url = driver.current_url
         title = driver.title
     except:
         current_url = session['url']
         title = session['title']
-
     return {
         "session_id": request.session_id,
         "url": current_url,
@@ -339,10 +303,8 @@ async def session_status(request: SessionRequest, auth=Depends(verify_token)):
 
 @app.post("/screenshot")
 async def take_screenshot(request: SessionRequest, auth=Depends(verify_token)):
-    """Captura screenshot da página"""
     session = session_manager.get_session(request.session_id)
     driver = session['driver']
-
     try:
         screenshot = driver.get_screenshot_as_png()
         return StreamingResponse(
@@ -356,23 +318,18 @@ async def take_screenshot(request: SessionRequest, auth=Depends(verify_token)):
 
 @app.post("/backup")
 async def backup_site(request: BackupRequest, auth=Depends(verify_token)):
-    """Faz backup completo do site"""
     session = session_manager.get_session(request.session_id)
     driver = session['driver']
     url = session['url']
-
     try:
         session['status'] = 'backing_up'
         backup = SiteBackup(driver, url)
         zip_buffer = backup.generate_backup_zip()
         session['status'] = 'active'
-
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         folder = request.folder_name or "backup"
         filename = f"{folder}_{timestamp}.zip"
-
         errors_count = len(backup.errors) if hasattr(backup, 'errors') else 0
-
         return StreamingResponse(
             io.BytesIO(zip_buffer.getvalue()),
             media_type="application/zip",
@@ -388,22 +345,18 @@ async def backup_site(request: BackupRequest, auth=Depends(verify_token)):
 
 @app.post("/check-errors")
 async def check_errors(request: ErrorCheckRequest, auth=Depends(verify_token)):
-    """Verifica erros e retorna TXT"""
     session = session_manager.get_session(request.session_id)
     driver = session['driver']
     url = session['url']
-
     try:
         session['status'] = 'checking_errors'
         checker = SiteErrorChecker(driver, url)
         checker.run_all_checks()
         report = checker.generate_report_txt()
         session['status'] = 'active'
-
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         folder = request.folder_name or "erros"
         filename = f"{folder}_{timestamp}.txt"
-
         return StreamingResponse(
             io.BytesIO(report.encode('utf-8')),
             media_type="text/plain; charset=utf-8",
@@ -420,18 +373,15 @@ async def check_errors(request: ErrorCheckRequest, auth=Depends(verify_token)):
 
 @app.post("/check-errors-json")
 async def check_errors_json(request: ErrorCheckRequest, auth=Depends(verify_token)):
-    """Verifica erros e retorna JSON"""
     session = session_manager.get_session(request.session_id)
     driver = session['driver']
     url = session['url']
-
     try:
         session['status'] = 'checking_errors'
         checker = SiteErrorChecker(driver, url)
         checker.run_all_checks()
         report = checker.generate_report_json()
         session['status'] = 'active'
-
         return JSONResponse(
             content=report,
             headers={
@@ -446,13 +396,11 @@ async def check_errors_json(request: ErrorCheckRequest, auth=Depends(verify_toke
 
 @app.post("/close")
 async def close_session(request: SessionRequest, auth=Depends(verify_token)):
-    """Fecha sessão"""
     session_manager.close_session(request.session_id)
     return {"status": "closed", "message": "Sessão encerrada com sucesso"}
 
 @app.get("/sessions")
 async def list_sessions(auth=Depends(verify_token)):
-    """Lista sessões ativas"""
     sessions_list = []
     for sid, s in session_manager.sessions.items():
         sessions_list.append({
@@ -467,24 +415,19 @@ async def list_sessions(auth=Depends(verify_token)):
 
 @app.post("/navigate")
 async def navigate(request: NavigateRequest, auth=Depends(verify_token)):
-    """Navega para outra URL na mesma sessão"""
     session = session_manager.get_session(request.session_id)
     driver = session['driver']
-
     url = request.url.strip()
     if not url.startswith(('http://', 'https://')):
         url = 'https://' + url
-
     try:
         driver.get(url)
         WebDriverWait(driver, 30).until(
             lambda d: d.execute_script("return document.readyState") == "complete"
         )
-
         session['url'] = driver.current_url
         session['title'] = driver.title or "Sem título"
         session['last_used'] = time.time()
-
         return {
             "status": "navigated",
             "url": session['url'],
@@ -495,298 +438,168 @@ async def navigate(request: NavigateRequest, auth=Depends(verify_token)):
         raise HTTPException(status_code=500, detail=str(e))
 
 # ============================================================
-# ROTAS DE INTERAÇÃO REMOTA (LOGIN)
+# ROTAS DE LOGIN / COOKIES
 # ============================================================
 
-@app.post("/interact/screenshot")
-async def interact_screenshot(request: SessionRequest, auth=Depends(verify_token)):
-    """Captura screenshot para interação remota"""
-    session = session_manager.get_session(request.session_id)
-    driver = session['driver']
-
-    try:
-        # Pegar tamanho real do viewport
-        viewport = driver.execute_script("""
-            return {
-                width: window.innerWidth,
-                height: window.innerHeight,
-                scrollX: window.scrollX,
-                scrollY: window.scrollY,
-                pageWidth: document.documentElement.scrollWidth,
-                pageHeight: document.documentElement.scrollHeight
-            };
-        """)
-
-        screenshot = driver.get_screenshot_as_png()
-        screenshot_b64 = base64.b64encode(screenshot).decode('utf-8')
-
-        return {
-            "screenshot": screenshot_b64,
-            "viewport": viewport,
-            "url": driver.current_url,
-            "title": driver.title
-        }
-    except Exception as e:
-        logger.error(f"[INTERACT-SCREENSHOT] Erro: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+@app.post("/inject-cookies")
+async def inject_cookies(request: dict, auth=Depends(verify_token)):
+    """Injeta cookies no Selenium para manter sessão de login"""
+    session_id = request.get("session_id")
+    cookies = request.get("cookies", [])
 
+    if not session_id:
+        raise HTTPException(status_code=400, detail="session_id é obrigatório")
+    if not cookies:
+        raise HTTPException(status_code=400, detail="Nenhum cookie fornecido")
 
-@app.post("/interact/click")
-async def interact_click(request: InteractClickRequest, auth=Depends(verify_token)):
-    """Clica em coordenada específica na página usando ActionChains"""
-    session = session_manager.get_session(request.session_id)
+    session = session_manager.get_session(session_id)
     driver = session['driver']
 
     try:
-        x = request.x
-        y = request.y
+        injected = 0
+        errors = []
 
-        # Método 1: ActionChains com offset desde o body
-        try:
-            body = driver.find_element(By.TAG_NAME, 'body')
-            actions = ActionChains(driver)
-            actions.move_to_element_with_offset(body, x - body.size['width'] // 2, y - body.size['height'] // 2)
-            actions.click()
-            actions.perform()
-        except Exception:
-            # Método 2: JavaScript com elementFromPoint + click + focus
-            driver.execute_script("""
-                var x = arguments[0];
-                var y = arguments[1];
-                
-                // Scroll para a posição se necessário
-                var vpHeight = window.innerHeight;
-                if (y > vpHeight) {
-                    window.scrollTo(0, y - vpHeight / 2);
-                    y = vpHeight / 2;
-                }
-                
-                var element = document.elementFromPoint(x, y);
-                if (element) {
-                    // Simular eventos de mouse reais
-                    var events = ['mousedown', 'mouseup', 'click'];
-                    events.forEach(function(eventType) {
-                        var event = new MouseEvent(eventType, {
-                            view: window,
-                            bubbles: true,
-                            cancelable: true,
-                            clientX: x,
-                            clientY: y
-                        });
-                        element.dispatchEvent(event);
-                    });
-                    
-                    // Focar no elemento
-                    if (element.focus) element.focus();
-                    
-                    // Se for input/textarea, colocar cursor no final
-                    if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
-                        element.selectionStart = element.selectionEnd = element.value.length;
-                    }
+        for cookie in cookies:
+            try:
+                selenium_cookie = {
+                    "name": cookie.get("name", ""),
+                    "value": cookie.get("value", ""),
+                    "path": cookie.get("path", "/"),
                 }
-            """, x, y)
 
-        time.sleep(0.8)
+                domain = cookie.get("domain", "")
+                if domain:
+                    selenium_cookie["domain"] = domain
 
-        screenshot = driver.get_screenshot_as_png()
-        screenshot_b64 = base64.b64encode(screenshot).decode('utf-8')
+                if cookie.get("secure"):
+                    selenium_cookie["secure"] = True
 
-        # Verificar qual elemento está focado
-        focused = driver.execute_script("""
-            var el = document.activeElement;
-            if (el) {
-                return {
-                    tag: el.tagName,
-                    type: el.type || '',
-                    id: el.id || '',
-                    name: el.name || '',
-                    isInput: (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.isContentEditable)
-                };
-            }
-            return null;
-        """)
+                if cookie.get("httpOnly"):
+                    selenium_cookie["httpOnly"] = True
 
-        return {
-            "status": "clicked",
-            "x": request.x,
-            "y": request.y,
-            "focused_element": focused,
-            "screenshot": screenshot_b64,
-            "url": driver.current_url,
-            "title": driver.title
-        }
-    except Exception as e:
-        logger.error(f"[INTERACT-CLICK] Erro: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+                same_site = cookie.get("sameSite", "")
+                if same_site and same_site != "unspecified":
+                    selenium_cookie["sameSite"] = same_site
 
+                if cookie.get("expirationDate"):
+                    selenium_cookie["expiry"] = int(cookie["expirationDate"])
 
-@app.post("/interact/type")
-async def interact_type(request: InteractTypeRequest, auth=Depends(verify_token)):
-    """Digita texto no elemento focado usando ActionChains"""
-    session = session_manager.get_session(request.session_id)
-    driver = session['driver']
+                driver.add_cookie(selenium_cookie)
+                injected += 1
 
-    try:
-        text = request.text
+            except Exception as e:
+                errors.append(f"Cookie '{cookie.get('name', '?')}': {str(e)}")
 
-        # Método 1: ActionChains (simula digitação real tecla por tecla)
-        try:
-            actions = ActionChains(driver)
-            actions.send_keys(text)
-            actions.perform()
-        except Exception:
-            # Método 2: JavaScript direto
-            driver.execute_script("""
-                var text = arguments[0];
-                var el = document.activeElement;
-                if (el && (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.isContentEditable)) {
-                    if (el.isContentEditable) {
-                        el.textContent += text;
-                    } else {
-                        var start = el.selectionStart || el.value.length;
-                        var end = el.selectionEnd || el.value.length;
-                        var before = el.value.substring(0, start);
-                        var after = el.value.substring(end);
-                        el.value = before + text + after;
-                        el.selectionStart = el.selectionEnd = start + text.length;
-                    }
-                    el.dispatchEvent(new Event('input', { bubbles: true }));
-                    el.dispatchEvent(new Event('change', { bubbles: true }));
-                    // KeyUp para frameworks reativos
-                    text.split('').forEach(function(char) {
-                        el.dispatchEvent(new KeyboardEvent('keydown', { key: char, bubbles: true }));
-                        el.dispatchEvent(new KeyboardEvent('keypress', { key: char, bubbles: true }));
-                        el.dispatchEvent(new KeyboardEvent('keyup', { key: char, bubbles: true }));
-                    });
-                }
-            """, text)
+        # Recarregar página com os cookies
+        driver.refresh()
+        WebDriverWait(driver, 30).until(
+            lambda d: d.execute_script("return document.readyState") == "complete"
+        )
+        time.sleep(2)
 
-        time.sleep(0.3)
+        session['url'] = driver.current_url
+        session['title'] = driver.title or "Sem título"
+        session['last_used'] = time.time()
 
         screenshot = driver.get_screenshot_as_png()
         screenshot_b64 = base64.b64encode(screenshot).decode('utf-8')
 
+        logger.info(f"[COOKIES] Injetados {injected}/{len(cookies)} cookies na sessão {session_id[:8]}...")
+
         return {
-            "status": "typed",
-            "text": text,
-            "screenshot": screenshot_b64,
-            "url": driver.current_url,
-            "title": driver.title
+            "status": "success",
+            "injected": injected,
+            "total": len(cookies),
+            "errors": errors,
+            "url": session['url'],
+            "title": session['title'],
+            "screenshot": screenshot_b64
         }
+
     except Exception as e:
-        logger.error(f"[INTERACT-TYPE] Erro: {e}")
+        logger.error(f"[COOKIES] Erro: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/interact/key")
-async def interact_key(request: InteractKeyRequest, auth=Depends(verify_token)):
-    """Pressiona tecla especial usando ActionChains"""
+@app.post("/get-current-state")
+async def get_current_state(request: SessionRequest, auth=Depends(verify_token)):
+    """Retorna estado atual da página (URL, título, screenshot)"""
     session = session_manager.get_session(request.session_id)
     driver = session['driver']
 
-    key_map = {
-        'enter': Keys.ENTER,
-        'tab': Keys.TAB,
-        'escape': Keys.ESCAPE,
-        'backspace': Keys.BACKSPACE,
-        'delete': Keys.DELETE,
-        'space': Keys.SPACE,
-        'up': Keys.UP,
-        'down': Keys.DOWN,
-        'left': Keys.LEFT,
-        'right': Keys.RIGHT
-    }
-
     try:
-        key = key_map.get(request.key.lower())
-        if not key:
-            raise HTTPException(status_code=400, detail=f"Tecla não suportada: {request.key}")
-
-        actions = ActionChains(driver)
-        actions.send_keys(key)
-        actions.perform()
-
-        time.sleep(0.8)
-
         screenshot = driver.get_screenshot_as_png()
         screenshot_b64 = base64.b64encode(screenshot).decode('utf-8')
 
-        return {
-            "status": "key_pressed",
-            "key": request.key,
-            "screenshot": screenshot_b64,
-            "url": driver.current_url,
-            "title": driver.title
-        }
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"[INTERACT-KEY] Erro: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/interact/scroll")
-async def interact_scroll(request: SessionRequest, auth=Depends(verify_token)):
-    """Rola a página para baixo"""
-    session = session_manager.get_session(request.session_id)
-    driver = session['driver']
-
-    try:
-        driver.execute_script("window.scrollBy(0, 300);")
-        time.sleep(0.3)
+        login_indicators = driver.execute_script("""
+            var indicators = {
+                has_logout_btn: false,
+                has_dashboard: false,
+                has_profile: false,
+                has_login_form: false,
+                page_text_preview: ''
+            };
+            
+            var allText = document.body.innerText.toLowerCase();
+            indicators.has_logout_btn = /logout|sair|log\\s?out|sign\\s?out|desconectar/i.test(allText);
+            indicators.has_dashboard = /dashboard|painel|meu\\s?perfil|minha\\s?conta|bem.vindo|welcome/i.test(allText);
+            indicators.has_profile = document.querySelector('[class*="profile"], [class*="avatar"], [class*="user-menu"], [class*="account"]') !== null;
+            indicators.has_login_form = document.querySelector('input[type="password"]') !== null;
+            indicators.page_text_preview = allText.substring(0, 300);
+            
+            return indicators;
+        """)
 
-        screenshot = driver.get_screenshot_as_png()
-        screenshot_b64 = base64.b64encode(screenshot).decode('utf-8')
+        probably_logged = (
+            (login_indicators.get('has_logout_btn') or login_indicators.get('has_dashboard') or login_indicators.get('has_profile'))
+            and not login_indicators.get('has_login_form')
+        )
 
         return {
-            "status": "scrolled",
-            "screenshot": screenshot_b64,
             "url": driver.current_url,
-            "title": driver.title
+            "title": driver.title,
+            "screenshot": screenshot_b64,
+            "probably_logged_in": probably_logged,
+            "indicators": login_indicators
         }
+
     except Exception as e:
-        logger.error(f"[INTERACT-SCROLL] Erro: {e}")
+        logger.error(f"[STATE] Erro: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/interact/clear-and-type")
-async def interact_clear_and_type(request: InteractTypeRequest, auth=Depends(verify_token)):
-    """Limpa o campo focado e digita novo texto"""
+@app.post("/refresh-page")
+async def refresh_page(request: SessionRequest, auth=Depends(verify_token)):
+    """Recarrega a página atual"""
     session = session_manager.get_session(request.session_id)
     driver = session['driver']
 
     try:
-        # Limpar com Ctrl+A + Delete
-        actions = ActionChains(driver)
-        actions.key_down(Keys.CONTROL).send_keys('a').key_up(Keys.CONTROL)
-        actions.send_keys(Keys.DELETE)
-        actions.perform()
-
-        time.sleep(0.2)
-
-        # Digitar novo texto
-        actions = ActionChains(driver)
-        actions.send_keys(request.text)
-        actions.perform()
+        driver.refresh()
+        WebDriverWait(driver, 30).until(
+            lambda d: d.execute_script("return document.readyState") == "complete"
+        )
+        time.sleep(1)
 
-        time.sleep(0.3)
+        session['url'] = driver.current_url
+        session['title'] = driver.title or "Sem título"
+        session['last_used'] = time.time()
 
         screenshot = driver.get_screenshot_as_png()
         screenshot_b64 = base64.b64encode(screenshot).decode('utf-8')
 
         return {
-            "status": "cleared_and_typed",
-            "text": request.text,
-            "screenshot": screenshot_b64,
-            "url": driver.current_url,
-            "title": driver.title
+            "status": "refreshed",
+            "url": session['url'],
+            "title": session['title'],
+            "screenshot": screenshot_b64
         }
+
     except Exception as e:
-        logger.error(f"[INTERACT-CLEAR-TYPE] Erro: {e}")
+        logger.error(f"[REFRESH] Erro: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-
 # ============================================================
 # ROTAS DE BUSCA NO SITE
 # ============================================================
@@ -807,28 +620,23 @@ async def search_site(request: SearchSiteRequest, auth=Depends(verify_token)):
         if any(kw in term for kw in ['api', 'endpoint', 'fetch', 'ajax', 'request', 'requisição', 'requisicao']):
             apis = driver.execute_script("""
                 var results = [];
-                // Scripts inline com fetch/axios/XMLHttpRequest
                 var scripts = document.querySelectorAll('script');
                 scripts.forEach(function(s) {
                     var text = s.textContent || s.innerText || '';
-                    // Buscar URLs de API
                     var urlPattern = /(?:fetch|axios\\.(?:get|post|put|delete)|XMLHttpRequest)\\s*\\(\\s*['\"`]([^'\"`]+)['\"`]/g;
                     var match;
                     while ((match = urlPattern.exec(text)) !== null) {
                         results.push({type: 'API Endpoint (fetch/axios)', value: match[1], details: 'Encontrado em script inline'});
                     }
-                    // Buscar URLs com /api/
                     var apiPattern = /['\"`]((?:https?:\\/\\/[^'\"`]*\\/api\\/[^'\"`]*)|(?:\\/api\\/[^'\"`]*))['\"`]/g;
                     while ((match = apiPattern.exec(text)) !== null) {
                         results.push({type: 'API URL', value: match[1], details: 'URL contendo /api/'});
                     }
                 });
-                // Links com /api/
                 var links = document.querySelectorAll('a[href*="/api/"]');
                 links.forEach(function(l) {
                     results.push({type: 'Link para API', value: l.href, details: l.textContent.trim().substring(0, 100)});
                 });
-                // Data attributes com URLs
                 var allElements = document.querySelectorAll('[data-api], [data-url], [data-endpoint]');
                 allElements.forEach(function(el) {
                     var api = el.getAttribute('data-api') || el.getAttribute('data-url') || el.getAttribute('data-endpoint');
@@ -877,7 +685,6 @@ async def search_site(request: SearchSiteRequest, auth=Depends(verify_token)):
                         });
                     }
                 });
-                // Background images
                 var allEls = document.querySelectorAll('*');
                 for (var i = 0; i < Math.min(allEls.length, 500); i++) {
                     var bg = window.getComputedStyle(allEls[i]).backgroundImage;
@@ -984,7 +791,6 @@ async def search_site(request: SearchSiteRequest, auth=Depends(verify_token)):
                 links.forEach(function(l) {
                     results.push({type: 'Fonte Externa', value: l.href, details: 'Rel: ' + l.rel});
                 });
-                // Verificar @font-face
                 for (var i = 0; i < document.styleSheets.length; i++) {
                     try {
                         var rules = document.styleSheets[i].cssRules || [];
@@ -1007,7 +813,6 @@ async def search_site(request: SearchSiteRequest, auth=Depends(verify_token)):
         if any(kw in term for kw in ['cookie', 'cookies', 'storage', 'localstorage', 'sessionstorage', 'armazenamento']):
             storage = driver.execute_script("""
                 var results = [];
-                // Cookies
                 var cookies = document.cookie.split(';');
                 cookies.forEach(function(c) {
                     c = c.trim();
@@ -1016,13 +821,11 @@ async def search_site(request: SearchSiteRequest, auth=Depends(verify_token)):
                         results.push({type: 'Cookie', value: parts[0], details: 'Valor: ' + (parts.slice(1).join('=') || '[vazio]')});
                     }
                 });
-                // LocalStorage
                 for (var i = 0; i < localStorage.length; i++) {
                     var key = localStorage.key(i);
                     var val = localStorage.getItem(key);
                     results.push({type: 'LocalStorage', value: key, details: 'Valor: ' + (val ? val.substring(0, 100) : '[vazio]')});
                 }
-                // SessionStorage
                 for (var i = 0; i < sessionStorage.length; i++) {
                     var key = sessionStorage.key(i);
                     var val = sessionStorage.getItem(key);
@@ -1039,7 +842,6 @@ async def search_site(request: SearchSiteRequest, auth=Depends(verify_token)):
             generic = driver.execute_script("""
                 var term = arguments[0];
                 var results = [];
-                // Buscar no HTML
                 var body = document.body.innerHTML;
                 var regex = new RegExp('([^<>]{0,50}' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&') + '[^<>]{0,50})', 'gi');
                 var matches = body.match(regex);
@@ -1049,7 +851,6 @@ async def search_site(request: SearchSiteRequest, auth=Depends(verify_token)):
                         results.push({type: 'Texto encontrado', value: m.trim(), details: 'Encontrado no conteúdo da página'});
                     });
                 }
-                // Buscar em atributos
                 var allEls = document.querySelectorAll('*');
                 for (var i = 0; i < Math.min(allEls.length, 1000); i++) {
                     var attrs = allEls[i].attributes;
@@ -1084,27 +885,33 @@ async def search_site(request: SearchSiteRequest, auth=Depends(verify_token)):
 @app.post("/search-site-txt")
 async def search_site_txt(request: SearchSiteRequest, auth=Depends(verify_token)):
     """Busca no site e retorna relatório TXT"""
-    # Reutilizar a lógica de busca
     session = session_manager.get_session(request.session_id)
     driver = session['driver']
 
     term = request.term.strip().lower()
 
     try:
-        # Chamar a mesma lógica
         fake_request = SearchSiteRequest(
             session_id=request.session_id,
             term=request.term,
             folder_name=request.folder_name
         )
 
-        # Executar busca diretamente
         search_data = await search_site(fake_request)
 
-        # Gerar relatório
+        findings = []
+        if isinstance(search_data, dict):
+            findings = search_data.get('findings', [])
+        elif hasattr(search_data, 'body'):
+            try:
+                body_data = json.loads(search_data.body.decode())
+                findings = body_data.get('findings', [])
+            except:
+                findings = []
+
         report = generate_search_report(
             term=request.term,
-            findings=search_data.get('findings', []) if isinstance(search_data, dict) else search_data.body.decode() if hasattr(search_data, 'body') else [],
+            findings=findings,
             url=driver.current_url,
             title=driver.title
         )
@@ -1158,7 +965,6 @@ def generate_search_report(term: str, findings: list, url: str, title: str) -> s
         report.append("  - O termo pode estar escrito de forma diferente")
         report.append("")
     else:
-        # Agrupar por categoria
         grouped = {}
         for f in findings:
             cat = f.get("category", "geral")
@@ -1182,7 +988,6 @@ def generate_search_report(term: str, findings: list, url: str, title: str) -> s
                 
                 report.append("")
                 
-                # Explicação didática por tipo
                 item_type = item.get("type", "").lower()
                 
                 if "api" in item_type or "endpoint" in item_type or "api" in cat.lower():