Upload 59 files

Dockerfile

@@ -2,30 +2,9 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
-# Install system dependencies (including Playwright/Camoufox deps)
+# Install system dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
-    curl \
-    wget \
-    # Playwright/Camoufox browser dependencies
-    libnss3 \
-    libnspr4 \
-    libatk1.0-0 \
-    libatk-bridge2.0-0 \
-    libcups2 \
-    libdrm2 \
-    libdbus-1-3 \
-    libxkbcommon0 \
-    libxcomposite1 \
-    libxdamage1 \
-    libxfixes3 \
-    libxrandr2 \
-    libgbm1 \
-    libasound2 \
-    libpango-1.0-0 \
-    libcairo2 \
-    libatspi2.0-0 \
-    libgtk-3-0 \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy all files first
@@ -45,14 +24,8 @@ RUN pip install --no-cache-dir \
     numpy \
     sentence-transformers \
     e2b-desktop>=2.2.0 \
-    # Camoufox stealth browser
-    camoufox[geoip] \
-    playwright \
     && pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu
 
-# Download Camoufox browser
-RUN camoufox fetch
-
 # HuggingFace Spaces uses port 7860
 EXPOSE 7860
 

app/agents/browser_agent_stealth.py

@@ -1,297 +1,253 @@
 """Browser Agent with Camoufox - Stealth Firefox for anti-bot bypass.
 
+Runs Camoufox INSIDE the E2B sandbox (not on HF container).
+
 Camoufox is a modified Firefox that:
 - Generates unique device fingerprints
 - Hides automation markers
 - Passes bot detection (Cloudflare, etc)
-
-Requires: pip install camoufox[geoip] playwright
-Then: camoufox fetch (downloads the stealth browser)
 """
 
 import os
 import logging
+import shlex
 import time
 from typing import AsyncGenerator, Optional
 
 from app.config import get_settings
-from app.agents.graph.simple_agent import (
-    SimpleState,
-    think_and_act,
-    generate_final_response,
-)
 from app.agents.llm_client import generate_completion
 
 logger = logging.getLogger(__name__)
 
 
-class CamoufoxState(SimpleState):
-    """State for Camoufox-based agent (uses Playwright page instead of E2B desktop)."""
-    
-    def __init__(self, task: str, url: Optional[str], page, timeout: float = 300):
-        # We pass None for desktop, will use page directly
-        super().__init__(task, url, desktop=None, timeout=timeout)
-        self.page = page  # Playwright page
-
-
 async def run_browser_agent_stealth(
     task: str,
     url: Optional[str] = None,
 ) -> AsyncGenerator[dict, None]:
-    """Run browser agent with Camoufox stealth browser."""
+    """Run browser agent with Camoufox stealth browser inside E2B sandbox."""
     settings = get_settings()
     
-    yield {"type": "status", "message": "🦊 Initializing stealth browser..."}
-    
-    try:
-        from camoufox.async_api import AsyncCamoufox
-    except ImportError:
-        yield {"type": "error", "message": "Camoufox not installed. Run: pip install camoufox[geoip] && camoufox fetch"}
+    if not settings.e2b_api_key:
+        yield {"type": "error", "message": "E2B_API_KEY not configured"}
         return
     
-    browser = None
+    yield {"type": "status", "message": "🦊 Initializing stealth browser in sandbox..."}
+    
+    desktop = None
     
     try:
-        yield {"type": "status", "message": "🛡️ Starting anti-detect Firefox..."}
+        from e2b_desktop import Sandbox
         
-        async with AsyncCamoufox(headless=True) as browser:
-            page = await browser.new_page()
-            
-            # Initialize state
-            state = CamoufoxState(
-                task=task,
-                url=url,
-                page=page,
-                timeout=300
+        os.environ["E2B_API_KEY"] = settings.e2b_api_key
+        
+        yield {"type": "status", "message": "🖥️ Creating virtual desktop..."}
+        desktop = Sandbox.create(timeout=900)  # 15 min for install
+        
+        # Start streaming
+        stream_url = None
+        try:
+            desktop.stream.start(require_auth=True)
+            auth_key = desktop.stream.get_auth_key()
+            stream_url = desktop.stream.get_url(auth_key=auth_key)
+            yield {"type": "stream", "url": stream_url}
+            desktop.wait(2000)
+        except Exception as e:
+            logger.warning(f"Could not start stream: {e}")
+        
+        # Install Camoufox inside E2B sandbox
+        yield {"type": "status", "message": "📦 Installing Camoufox in sandbox..."}
+        
+        try:
+            # Install Python packages
+            desktop.commands.run(
+                "pip install camoufox playwright --quiet",
+                timeout=120
             )
+            desktop.wait(2000)
             
-            # Go to initial URL or search
-            start_url = url or "https://html.duckduckgo.com/html/"
-            yield {"type": "status", "message": f"🌐 Navigating to {start_url[:50]}..."}
-            
-            try:
-                await page.goto(start_url, timeout=30000)
-                await page.wait_for_timeout(2000)
-                
-                # Extract initial content
-                content = await _extract_page_content(page)
-                state.add_page(start_url, content)
-            except Exception as e:
-                logger.warning(f"Initial navigation failed: {e}")
-            
-            cycle = 0
-            max_cycles = 15
-            
-            # Main loop
-            while state.should_continue() and cycle < max_cycles:
-                cycle += 1
-                remaining = int(state.remaining())
-                
-                yield {"type": "status", "message": f"🤔 Analyzing... (cycle {cycle}, {remaining}s left)"}
-                
-                # Think and decide
-                action, params = await think_and_act_camoufox(state)
-                
-                # Execute action
-                if action == "complete":
-                    state.final_result = params.get("result", "")
-                    state.done = True
-                    break
-                
-                elif action == "search":
-                    query = params.get("query", task)
-                    search_url = f"https://html.duckduckgo.com/html/?q={query.replace(' ', '+')}"
-                    
-                    yield {"type": "status", "message": f"🔍 Searching: {query[:40]}..."}
-                    
-                    # Check cache
-                    if search_url in state.visited_urls:
-                        continue
-                    
-                    try:
-                        await page.goto(search_url, timeout=20000)
-                        await page.wait_for_timeout(2000)
-                        content = await _extract_page_content(page)
-                        state.add_page(search_url, content)
-                        state.action_history.append(f"search:{query[:30]}")
-                    except Exception as e:
-                        logger.warning(f"Search failed: {e}")
-                        state.action_history.append(f"search(fail):{query[:20]}")
-                
-                elif action == "navigate":
-                    nav_url = params.get("url", "")
-                    if not nav_url.startswith("http"):
-                        continue
-                    
-                    # Check if already visited
-                    if nav_url in state.visited_urls:
-                        continue
-                    
-                    yield {"type": "status", "message": f"🌐 Visiting: {nav_url[:40]}..."}
-                    
-                    try:
-                        await page.goto(nav_url, timeout=20000)
-                        await page.wait_for_timeout(2000)
-                        content = await _extract_page_content(page)
-                        
-                        # Check for blocks
-                        if _is_blocked(content):
-                            logger.warning(f"Blocked at {nav_url[:50]}")
-                            state.visited_urls.append(nav_url)
-                            state.content_cache[nav_url] = "[BLOCKED]"
-                            state.action_history.append(f"nav(blocked):{nav_url[:25]}")
-                        else:
-                            state.add_page(nav_url, content)
-                            state.action_history.append(f"nav:{nav_url[:30]}")
-                    except Exception as e:
-                        logger.warning(f"Navigation failed: {e}")
-                        state.visited_urls.append(nav_url)
-                        state.action_history.append(f"nav(fail):{nav_url[:25]}")
-                
-                elif action == "scroll":
-                    yield {"type": "status", "message": "📜 Scrolling..."}
-                    await page.evaluate("window.scrollBy(0, 500)")
-                    await page.wait_for_timeout(1000)
-                    
-                    # Re-extract
-                    content = await _extract_page_content(page)
-                    if state.visited_urls:
-                        state.content_cache[state.visited_urls[-1]] = content[:4000]
-                    state.action_history.append("scroll")
-            
-            # Generate final response if needed
-            if not state.final_result:
-                yield {"type": "status", "message": "✅ Generating response..."}
-                state.final_result = await generate_final_response(state)
+            # Download Camoufox browser
+            yield {"type": "status", "message": "🔽 Downloading stealth browser..."}
+            desktop.commands.run(
+                "camoufox fetch",
+                timeout=180
+            )
+            desktop.wait(2000)
             
-            # Return result
-            yield {
-                "type": "result",
-                "content": state.final_result,
-                "links": state.visited_urls[:10],
-                "success": bool(state.final_result)
-            }
+            # Install Playwright deps
+            desktop.commands.run(
+                "playwright install-deps firefox --quiet 2>/dev/null || true",
+                timeout=60
+            )
             
-            elapsed = int(state.elapsed())
-            yield {"type": "complete", "message": f"Completed in {elapsed}s, {cycle} cycles"}
+            logger.info("Camoufox installed in sandbox")
+        except Exception as e:
+            logger.error(f"Failed to install Camoufox: {e}")
+            yield {"type": "error", "message": f"Failed to install Camoufox: {e}"}
+            return
+        
+        # Now run Camoufox via Python script inside sandbox
+        yield {"type": "status", "message": "🛡️ Starting stealth Firefox..."}
+        
+        # Create Python script to run Camoufox
+        script = _create_camoufox_script(task, url)
+        
+        # Write script to sandbox
+        desktop.commands.run(f"cat > /tmp/scrape.py << 'SCRIPT_EOF'\n{script}\nSCRIPT_EOF", timeout=10)
+        
+        # Run the script
+        yield {"type": "status", "message": f"🔍 Researching: {task[:40]}..."}
+        
+        result = desktop.commands.run(
+            "python /tmp/scrape.py",
+            timeout=300
+        )
+        
+        output = result.stdout if hasattr(result, 'stdout') else ""
+        
+        if not output:
+            yield {"type": "error", "message": "No output from Camoufox script"}
+            return
+        
+        # Parse result
+        import json
+        try:
+            data = json.loads(output)
+            final_result = data.get("result", "")
+            visited_urls = data.get("urls", [])
+        except json.JSONDecodeError:
+            # Raw text output
+            final_result = output[:3000]
+            visited_urls = []
+        
+        # Generate response with LLM if needed
+        if len(final_result) > 500 and not final_result.startswith("Error"):
+            yield {"type": "status", "message": "✨ Synthesizing response..."}
             
-            logger.info(f"Stealth agent complete. Cycles: {cycle}, Time: {elapsed}s")
-    
-    except Exception as e:
-        logger.exception("Stealth browser agent error")
-        yield {"type": "error", "message": f"Error: {str(e)}"}
+            prompt = f"""Analise o conteúdo abaixo e responda à pergunta.
 
+PERGUNTA: {task}
 
-async def _extract_page_content(page) -> str:
-    """Extract text content from current page."""
-    try:
-        # Get body text
-        content = await page.evaluate("""
-            () => {
-                // Remove scripts and styles
-                const scripts = document.querySelectorAll('script, style, noscript');
-                scripts.forEach(s => s.remove());
-                
-                // Get text
-                return document.body.innerText || document.body.textContent || '';
-            }
-        """)
-        return content[:6000] if content else ""
-    except Exception as e:
-        logger.warning(f"Content extraction failed: {e}")
-        return ""
+CONTEÚDO COLETADO:
+{final_result[:4000]}
 
+Responda de forma clara e concisa. Use **negrito** para valores importantes."""
 
-def _is_blocked(content: str) -> bool:
-    """Check if content indicates a block."""
-    content_lower = content.lower()
-    
-    # Very specific patterns
-    block_patterns = [
-        "checking your browser before accessing",
-        "please wait while we verify",
-        "cloudflare ray id",
-        "enable javascript and cookies",
-        "attention required! | cloudflare",
-        "checking if the site connection is secure",
-        "please turn javascript on",
-        "access denied",
-        "you have been blocked",
-    ]
-    
-    # Short content with block pattern = definitely blocked
-    if len(content) < 500:
-        return any(p in content_lower for p in block_patterns)
-    
-    return False
+            response = await generate_completion(
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=1000
+            )
+            final_result = response.strip() if response else final_result
+        
+        # Yield result
+        yield {"type": "stream_end", "message": "Stream ended"}
+        
+        yield {
+            "type": "result",
+            "content": final_result,
+            "links": visited_urls[:10],
+            "success": bool(final_result)
+        }
+        
+        yield {"type": "complete", "message": f"Completed with Camoufox stealth browser"}
+        
+    except ImportError as e:
+        yield {"type": "error", "message": "e2b-desktop not installed"}
+    except Exception as e:
+        logger.exception("Stealth browser agent error")
+        yield {"type": "error", "message": f"Error: {str(e)}"}
+    finally:
+        if desktop:
+            try:
+                desktop.stream.stop()
+            except Exception:
+                pass
+            try:
+                desktop.kill()
+            except Exception:
+                pass
 
 
-async def think_and_act_camoufox(state: CamoufoxState):
-    """Think and decide action for Camoufox agent."""
-    import json
+def _create_camoufox_script(task: str, url: Optional[str] = None) -> str:
+    """Create Python script to run Camoufox inside E2B sandbox."""
     
-    content = state.get_recent_content() or "(No content yet)"
-    history = ", ".join(state.action_history[-5:]) if state.action_history else "(starting)"
-    visited = "\n".join([f"  - {u[:70]}" for u in state.visited_urls[-10:]]) if state.visited_urls else "(none)"
+    # Escape task for Python string
+    task_escaped = task.replace("'", "\\'").replace('"', '\\"')
+    start_url = url or f"https://html.duckduckgo.com/html/?q={task.replace(' ', '+')}"
     
-    prompt = f"""You are a web research agent using a stealth browser. Analyze and decide next action.
-
-TASK: {state.task}
-
-ALREADY VISITED (DO NOT visit again):
-{visited}
-
-CURRENT PAGE CONTENT:
-{content}
-
-HISTORY: {history}
-TIME REMAINING: {int(state.remaining())}s
-
-Return JSON with ONE action:
-- Search: {{"action": "search", "query": "search terms"}}
-- Navigate to NEW URL: {{"action": "navigate", "url": "https://..."}}
-- Scroll for more: {{"action": "scroll"}}
-- Answer ready: {{"action": "complete", "result": "Your answer with **bold** for important values."}}
-
-RULES:
-- DO NOT navigate to URLs in ALREADY VISITED list
-- Only use URLs from the content above
-- Use **bold** for prices, numbers, names
-- Be efficient
-
-Return ONLY valid JSON:"""
-
-    try:
-        response = await generate_completion(
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=800
-        )
+    script = f'''
+import json
+import sys
+
+try:
+    from camoufox.sync_api import Camoufox
+except ImportError:
+    print(json.dumps({{"error": "Camoufox not installed"}}))
+    sys.exit(1)
+
+visited_urls = []
+all_content = []
+
+try:
+    with Camoufox(headless=True) as browser:
+        page = browser.new_page()
+        
+        # Go to search
+        start_url = "{start_url}"
+        page.goto(start_url, timeout=30000)
+        page.wait_for_timeout(2000)
+        
+        visited_urls.append(start_url)
         
-        response = response.strip()
-        if response.startswith("```"):
-            response = response.split("```")[1]
-            if response.startswith("json"):
-                response = response[4:]
+        # Extract content
+        content = page.evaluate("""
+            () => {{
+                const scripts = document.querySelectorAll('script, style, noscript');
+                scripts.forEach(s => s.remove());
+                return document.body.innerText || '';
+            }}
+        """)
         
-        decision = json.loads(response)
-        action = decision.get("action", "search")
+        all_content.append(content[:3000])
+        
+        # Try to find and visit first relevant link
+        links = page.evaluate("""
+            () => {{
+                const links = Array.from(document.querySelectorAll('a[href^="http"]'));
+                return links
+                    .map(a => a.href)
+                    .filter(h => !h.includes('duckduckgo') && !h.includes('google'))
+                    .slice(0, 3);
+            }}
+        """)
         
-        # Safety: prevent revisiting
-        if action == "navigate":
-            url = decision.get("url", "").rstrip("/")
-            visited_normalized = [u.rstrip("/") for u in state.visited_urls]
-            if url in visited_normalized:
-                if state.content_cache:
-                    good = [c for c in state.content_cache.values() if c and c not in ["[BLOCKED]"]]
-                    if good:
-                        return "complete", {"result": state.get_recent_content()[:800]}
-                return "search", {"query": f"{state.task} site:wikipedia.org"}
+        # Visit first link
+        if links and len(links) > 0:
+            try:
+                page.goto(links[0], timeout=20000)
+                page.wait_for_timeout(2000)
+                visited_urls.append(links[0])
+                
+                content2 = page.evaluate("""
+                    () => {{
+                        const scripts = document.querySelectorAll('script, style, noscript');
+                        scripts.forEach(s => s.remove());
+                        return document.body.innerText || '';
+                    }}
+                """)
+                all_content.append(content2[:3000])
+            except Exception as e:
+                pass
         
-        logger.info(f"Camoufox decision: {action}")
-        return action, decision
+        result = "\\n\\n---\\n\\n".join(all_content)
         
-    except Exception as e:
-        logger.error(f"Think failed: {e}")
-        if state.content_cache:
-            return "complete", {"result": state.get_recent_content()[:500]}
-        return "search", {"query": state.task}
+        print(json.dumps({{
+            "result": result[:6000],
+            "urls": visited_urls
+        }}))
+
+except Exception as e:
+    print(json.dumps({{"error": str(e)}}))
+    sys.exit(1)
+'''
+    
+    return script

pyproject.toml

@@ -30,10 +30,6 @@ dev = [
     "pytest-asyncio>=0.24.0",
     "pytest-cov>=6.0.0",
 ]
-stealth = [
-    "camoufox[geoip]>=0.4.0",
-    "playwright>=1.40.0",
-]
 
 [build-system]
 requires = ["hatchling"]