Add free proxy rotation system for ChatGPT and Copilot

Features:
- FreeProxyManager class that fetches proxies from multiple sources
- Proxy testing to ensure IPs are active and working
- Proxy rotation with one-click IP switching
- Endpoints:
* POST /qaz/proxy/fetch - Fetch and test new proxies
* POST /qaz/proxy/rotate - Rotate to new working proxy
* GET /qaz/proxy/status - Check proxy status
* POST /qaz/proxy/test - Test current proxy
* POST /qaz/portal/{provider}/restart-with-proxy - Restart portal with proxy
- UI controls in portal interface:
* 🔄 Fetch New IPs - Get fresh proxies
* 🎲 Rotate IP - Switch to different proxy
* ✅ Test Current IP - Verify proxy is working
* 🚀 Restart with Proxy - Apply proxy to portal
- Shows proxy country and response time
- Works specifically for ChatGPT and Copilot to bypass IP restrictions

This helps avoid blocks by rotating through free proxies from different countries!

admin_router.py

@@ -662,3 +662,135 @@ async def get_all_portal_status():
         }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+
+# --- Proxy Management for Browser Portals ---
+
+@router.post("/proxy/fetch")
+async def fetch_new_proxies():
+    """Fetch new free proxies and test them."""
+    try:
+        from proxy_manager import get_proxy_manager
+        
+        proxy_mgr = get_proxy_manager()
+        
+        # Fetch new proxies
+        proxies = await proxy_mgr.fetch_proxies(limit=30)
+        
+        # Test first few to find a working one
+        working_proxy = await proxy_mgr.get_working_proxy(max_attempts=5)
+        
+        stats = proxy_mgr.get_proxy_stats()
+        
+        return {
+            "status": "success",
+            "message": f"Fetched {len(proxies)} proxies",
+            "working_proxy": str(working_proxy) if working_proxy else None,
+            "stats": stats
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/proxy/rotate")
+async def rotate_proxy():
+    """Rotate to a new working proxy."""
+    try:
+        from proxy_manager import get_proxy_manager
+        
+        proxy_mgr = get_proxy_manager()
+        
+        # Rotate to new proxy
+        new_proxy = await proxy_mgr.rotate_proxy()
+        
+        if new_proxy:
+            return {
+                "status": "success",
+                "proxy": str(new_proxy),
+                "country": new_proxy.country,
+                "response_time": f"{new_proxy.response_time:.2f}s"
+            }
+        else:
+            raise HTTPException(status_code=503, detail="No working proxy available")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/proxy/status")
+async def get_proxy_status():
+    """Get current proxy status."""
+    try:
+        from proxy_manager import get_proxy_manager
+        
+        proxy_mgr = get_proxy_manager()
+        
+        stats = proxy_mgr.get_proxy_stats()
+        current = proxy_mgr.get_current_proxy()
+        
+        return {
+            "current_proxy": str(current) if current else None,
+            **stats
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/proxy/test")
+async def test_current_proxy():
+    """Test if current proxy is working."""
+    try:
+        from proxy_manager import get_proxy_manager
+        
+        proxy_mgr = get_proxy_manager()
+        current = proxy_mgr.get_current_proxy()
+        
+        if not current:
+            raise HTTPException(status_code=400, detail="No proxy currently set")
+        
+        is_working = await proxy_mgr.test_proxy(current)
+        
+        return {
+            "status": "success",
+            "proxy": str(current),
+            "is_working": is_working,
+            "response_time": f"{current.response_time:.2f}s" if is_working else None
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/portal/{provider}/restart-with-proxy")
+async def restart_portal_with_proxy(provider: str):
+    """Restart portal with current proxy."""
+    try:
+        from browser_portal import get_portal_manager, PortalProvider
+        from proxy_manager import get_proxy_manager
+        
+        prov = PortalProvider(provider.lower())
+        portal = get_portal_manager().get_portal(prov)
+        proxy_mgr = get_proxy_manager()
+        
+        # Get current proxy
+        current_proxy = proxy_mgr.get_current_proxy()
+        if not current_proxy:
+            # Fetch and test a new one
+            current_proxy = await proxy_mgr.get_working_proxy()
+            if not current_proxy:
+                raise HTTPException(status_code=503, detail="No working proxy available")
+        
+        # Close existing portal
+        await portal.close()
+        
+        # Reinitialize with proxy
+        await portal.initialize(headless=True, proxy=current_proxy)
+        
+        return {
+            "status": "success",
+            "provider": provider,
+            "proxy": str(current_proxy),
+            "message": f"{provider} portal restarted with proxy {current_proxy.ip}"
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

browser_portal.py

@@ -104,13 +104,16 @@ class BrowserPortal:
         self.last_activity = None
         self.is_logged_in = False
         
-    async def initialize(self, headless: bool = True):
-        """Initialize the browser with enhanced stealth."""
+    async def initialize(self, headless: bool = True, proxy: Optional[Any] = None):
+        """Initialize the browser with enhanced stealth and optional proxy."""
         if self.is_initialized:
             return
             
         try:
             logger.info(f"🚀 Portal [{self.provider.value}]: Launching browser...")
+            if proxy:
+                logger.info(f"Using proxy: {proxy}")
+            
             self.playwright = await async_playwright().start()
             
             # Enhanced stealth args
@@ -125,10 +128,17 @@ class BrowserPortal:
                 "--force-color-profile=srgb",
             ]
             
-            self.browser = await self.playwright.chromium.launch(
-                headless=headless,
-                args=args,
-            )
+            # Build browser launch options
+            launch_options = {
+                "headless": headless,
+                "args": args,
+            }
+            
+            # Add proxy if provided
+            if proxy:
+                launch_options["proxy"] = proxy.to_playwright_format()
+            
+            self.browser = await self.playwright.chromium.launch(**launch_options)
             
             self.context = await self.browser.new_context(
                 viewport=self.config.viewport,

proxy_manager.py

@@ -0,0 +1,217 @@
+"""
+Free Proxy Manager for Browser Portals
+--------------------------------------
+Fetches and manages free proxy servers for ChatGPT and Copilot.
+Automatically tests proxies to ensure they're active.
+"""
+
+import asyncio
+import aiohttp
+import random
+import logging
+from typing import Optional, List, Dict
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+
+logger = logging.getLogger("kai_api.proxy_manager")
+
+@dataclass
+class Proxy:
+    """Represents a proxy server."""
+    ip: str
+    port: int
+    country: str
+    protocol: str = "http"
+    last_tested: Optional[datetime] = None
+    is_working: bool = False
+    response_time: float = 0.0
+    
+    def __str__(self):
+        return f"{self.protocol}://{self.ip}:{self.port}"
+    
+    def to_playwright_format(self) -> Dict:
+        """Convert to Playwright proxy format."""
+        return {
+            "server": f"{self.protocol}://{self.ip}:{self.port}",
+        }
+
+
+class FreeProxyManager:
+    """Manages free proxy servers for browser portals."""
+    
+    def __init__(self):
+        self.proxies: List[Proxy] = []
+        self.current_proxy: Optional[Proxy] = None
+        self.proxy_history: List[Proxy] = []
+        self.max_history = 10
+        
+    async def fetch_proxies(self, limit: int = 20) -> List[Proxy]:
+        """Fetch free proxies from multiple sources."""
+        proxies = []
+        
+        # Source 1: proxylist.geonode.com
+        try:
+            url = f"https://proxylist.geonode.com/api/proxy-list?limit={limit}&page=1&sort_by=lastChecked&sort_type=desc&protocols=http%2Chttps"
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, timeout=10) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        for item in data.get('data', []):
+                            proxy = Proxy(
+                                ip=item['ip'],
+                                port=int(item['port']),
+                                country=item.get('country', 'Unknown'),
+                                protocol=item.get('protocols', ['http'])[0] if isinstance(item.get('protocols'), list) else 'http'
+                            )
+                            proxies.append(proxy)
+                            logger.info(f"Fetched proxy: {proxy}")
+        except Exception as e:
+            logger.warning(f"Failed to fetch from geonode: {e}")
+        
+        # Source 2: proxy-list.download
+        try:
+            url = "https://www.proxy-list.download/api/v1/get?type=http"
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, timeout=10) as response:
+                    if response.status == 200:
+                        text = await response.text()
+                        lines = text.strip().split('\n')
+                        for line in lines[:limit]:
+                            if ':' in line:
+                                ip, port = line.strip().split(':')
+                                proxy = Proxy(
+                                    ip=ip,
+                                    port=int(port),
+                                    country='Unknown',
+                                    protocol='http'
+                                )
+                                if proxy not in proxies:
+                                    proxies.append(proxy)
+        except Exception as e:
+            logger.warning(f"Failed to fetch from proxy-list: {e}")
+        
+        # Source 3: free-proxy-list.net (simple API)
+        try:
+            # This is a fallback - scrape a few common free proxies
+            fallback_proxies = [
+                ("20.235.104.105", 3128, "US"),
+                ("159.89.49.172", 3128, "US"),
+                ("20.210.113.32", 8123, "US"),
+                ("103.152.232.142", 8080, "ID"),
+                ("43.135.166.179", 8080, "SG"),
+                ("47.74.152.190", 8888, "JP"),
+                ("52.196.1.179", 8080, "JP"),
+                ("13.231.21.152", 3128, "JP"),
+                ("54.179.34.32", 3128, "SG"),
+                ("18.141.176.104", 3128, "SG"),
+            ]
+            
+            for ip, port, country in fallback_proxies:
+                proxy = Proxy(ip=ip, port=port, country=country, protocol='http')
+                if proxy not in proxies:
+                    proxies.append(proxy)
+                    
+        except Exception as e:
+            logger.warning(f"Fallback proxy error: {e}")
+        
+        logger.info(f"Total proxies fetched: {len(proxies)}")
+        return proxies
+    
+    async def test_proxy(self, proxy: Proxy, test_url: str = "https://httpbin.org/ip") -> bool:
+        """Test if a proxy is working."""
+        try:
+            timeout = aiohttp.ClientTimeout(total=10)
+            
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                start_time = asyncio.get_event_loop().time()
+                
+                async with session.get(
+                    test_url, 
+                    proxy=f"http://{proxy.ip}:{proxy.port}",
+                    ssl=False
+                ) as response:
+                    elapsed = asyncio.get_event_loop().time() - start_time
+                    
+                    if response.status == 200:
+                        proxy.is_working = True
+                        proxy.response_time = elapsed
+                        proxy.last_tested = datetime.now()
+                        logger.info(f"✅ Proxy working: {proxy} ({elapsed:.2f}s)")
+                        return True
+                    else:
+                        proxy.is_working = False
+                        logger.warning(f"❌ Proxy failed with status {response.status}: {proxy}")
+                        return False
+                        
+        except Exception as e:
+            proxy.is_working = False
+            logger.warning(f"❌ Proxy test failed: {proxy} - {str(e)}")
+            return False
+    
+    async def get_working_proxy(self, max_attempts: int = 5) -> Optional[Proxy]:
+        """Get a working proxy, testing multiple if needed."""
+        # First, try to use current proxy if it exists and is working
+        if self.current_proxy and self.current_proxy.is_working:
+            # Retest it to make sure it's still working
+            if await self.test_proxy(self.current_proxy):
+                return self.current_proxy
+        
+        # Fetch new proxies if we don't have enough
+        if len(self.proxies) < 5:
+            logger.info("Fetching new proxies...")
+            self.proxies = await self.fetch_proxies(limit=30)
+        
+        # Test proxies until we find a working one
+        random.shuffle(self.proxies)  # Randomize to distribute load
+        
+        for i, proxy in enumerate(self.proxies[:max_attempts]):
+            logger.info(f"Testing proxy {i+1}/{max_attempts}: {proxy}")
+            
+            if await self.test_proxy(proxy):
+                # Save current to history
+                if self.current_proxy:
+                    self.proxy_history.insert(0, self.current_proxy)
+                    if len(self.proxy_history) > self.max_history:
+                        self.proxy_history.pop()
+                
+                self.current_proxy = proxy
+                return proxy
+        
+        logger.error("No working proxy found!")
+        return None
+    
+    async def rotate_proxy(self) -> Optional[Proxy]:
+        """Rotate to a new working proxy."""
+        logger.info("Rotating to new proxy...")
+        
+        # Mark current as not working
+        if self.current_proxy:
+            self.current_proxy.is_working = False
+        
+        # Get a new working proxy
+        return await self.get_working_proxy()
+    
+    def get_current_proxy(self) -> Optional[Proxy]:
+        """Get the current active proxy."""
+        return self.current_proxy
+    
+    def get_proxy_stats(self) -> Dict:
+        """Get statistics about proxies."""
+        working = sum(1 for p in self.proxies if p.is_working)
+        return {
+            "total_proxies": len(self.proxies),
+            "working_proxies": working,
+            "current_proxy": str(self.current_proxy) if self.current_proxy else None,
+            "proxy_history": [str(p) for p in self.proxy_history[:5]]
+        }
+
+
+# Global proxy manager instance
+_proxy_manager: Optional[FreeProxyManager] = None
+
+def get_proxy_manager() -> FreeProxyManager:
+    """Get the global proxy manager instance."""
+    global _proxy_manager
+    if _proxy_manager is None:
+        _proxy_manager = FreeProxyManager()
+    return _proxy_manager

static/qaz.html

@@ -1150,8 +1150,166 @@
                 </div>
                 <div id="portal-response" style="display: none; margin-top: 15px; padding: 15px; background: var(--surface); border-radius: 6px; border: 1px solid var(--border); white-space: pre-wrap; font-family: monospace; font-size: 13px; max-height: 200px; overflow-y: auto;"></div>
             </div>
+            
+            <!-- 🌐 Proxy Rotation Controls -->
+            <div style="background: linear-gradient(135deg, rgba(139, 92, 246, 0.1), rgba(59, 130, 246, 0.1)); border: 2px solid var(--accent); border-radius: 8px; padding: 15px; margin-top: 20px;">
+                <h4 style="color: var(--accent); margin-bottom: 10px; display: flex; align-items: center;">
+                    🌐 Proxy Rotation for ChatGPT & Copilot
+                    <span id="proxy-status-badge" style="font-size: 11px; background: var(--surface); padding: 2px 8px; border-radius: 4px; margin-left: 10px; color: var(--text-muted);">No Proxy</span>
+                </h4>
+                <p style="color: var(--text-muted); font-size: 12px; margin-bottom: 12px;">
+                    Rotate IPs to bypass restrictions. Free proxies from multiple countries.
+                </p>
+                
+                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 8px; margin-bottom: 12px;">
+                    <button onclick="fetchNewProxies()" style="background: var(--accent); color: white; border: none; padding: 10px; border-radius: 6px; font-weight: 600; cursor: pointer; font-size: 12px;">
+                        🔄 Fetch New IPs
+                    </button>
+                    <button onclick="rotateProxy()" style="background: var(--warning); color: black; border: none; padding: 10px; border-radius: 6px; font-weight: 600; cursor: pointer; font-size: 12px;">
+                        🎲 Rotate IP
+                    </button>
+                    <button onclick="testProxy()" style="background: var(--success); color: white; border: none; padding: 10px; border-radius: 6px; font-weight: 600; cursor: pointer; font-size: 12px;">
+                        ✅ Test Current IP
+                    </button>
+                    <button onclick="restartWithProxy()" style="background: var(--surface); color: var(--text); border: 1px solid var(--border); padding: 10px; border-radius: 6px; font-weight: 600; cursor: pointer; font-size: 12px;">
+                        🚀 Restart with Proxy
+                    </button>
+                </div>
+                
+                <div id="proxy-info" style="background: var(--bg); border: 1px solid var(--border); border-radius: 6px; padding: 10px; font-family: monospace; font-size: 12px; display: none;">
+                    <div><strong>Current IP:</strong> <span id="current-proxy-display">None</span></div>
+                    <div><strong>Country:</strong> <span id="proxy-country-display">-</span></div>
+                    <div><strong>Response Time:</strong> <span id="proxy-response-display">-</span></div>
+                </div>
+                
+                <div id="proxy-message" style="margin-top: 8px; font-size: 12px; color: var(--text-muted);"></div>
+            </div>
         </div>
     </div>
+    
+    <script>
+        // 🌐 Proxy Management Functions
+        async function fetchNewProxies() {
+            const btn = event.target;
+            const originalText = btn.textContent;
+            btn.textContent = 'Fetching...';
+            btn.disabled = true;
+            
+            try {
+                const res = await fetch('/qaz/proxy/fetch', { method: 'POST' });
+                const data = await res.json();
+                
+                if (data.status === 'success') {
+                    updateProxyDisplay(data.working_proxy, data.stats);
+                    showProxyMessage(`✅ Fetched ${data.stats.total_proxies} proxies. Working: ${data.stats.working_proxies}`);
+                } else {
+                    throw new Error(data.message);
+                }
+            } catch (e) {
+                showProxyMessage('❌ Error: ' + e.message);
+            } finally {
+                btn.textContent = originalText;
+                btn.disabled = false;
+            }
+        }
+        
+        async function rotateProxy() {
+            const btn = event.target;
+            const originalText = btn.textContent;
+            btn.textContent = 'Rotating...';
+            btn.disabled = true;
+            
+            try {
+                const res = await fetch('/qaz/proxy/rotate', { method: 'POST' });
+                const data = await res.json();
+                
+                if (data.status === 'success') {
+                    document.getElementById('proxy-status-badge').textContent = 'Active';
+                    document.getElementById('proxy-status-badge').style.color = 'var(--success)';
+                    document.getElementById('current-proxy-display').textContent = data.proxy;
+                    document.getElementById('proxy-country-display').textContent = data.country;
+                    document.getElementById('proxy-response-display').textContent = data.response_time;
+                    document.getElementById('proxy-info').style.display = 'block';
+                    showProxyMessage(`✅ Rotated to new IP: ${data.country} (${data.response_time})`);
+                } else {
+                    throw new Error(data.message);
+                }
+            } catch (e) {
+                showProxyMessage('❌ Error: ' + e.message);
+            } finally {
+                btn.textContent = originalText;
+                btn.disabled = false;
+            }
+        }
+        
+        async function testProxy() {
+            const btn = event.target;
+            const originalText = btn.textContent;
+            btn.textContent = 'Testing...';
+            btn.disabled = true;
+            
+            try {
+                const res = await fetch('/qaz/proxy/test', { method: 'POST' });
+                const data = await res.json();
+                
+                if (data.is_working) {
+                    showProxyMessage(`✅ Proxy working! Response time: ${data.response_time}`);
+                } else {
+                    showProxyMessage('❌ Proxy not working. Try rotating.');
+                }
+            } catch (e) {
+                showProxyMessage('❌ Error: ' + e.message);
+            } finally {
+                btn.textContent = originalText;
+                btn.disabled = false;
+            }
+        }
+        
+        async function restartWithProxy() {
+            if (!currentProvider) {
+                alert('Please select a provider first');
+                return;
+            }
+            
+            const btn = event.target;
+            const originalText = btn.textContent;
+            btn.textContent = 'Restarting...';
+            btn.disabled = true;
+            
+            try {
+                const res = await fetch(`/qaz/portal/${currentProvider}/restart-with-proxy`, { method: 'POST' });
+                const data = await res.json();
+                
+                if (data.status === 'success') {
+                    showProxyMessage(`✅ ${data.message}`);
+                    setTimeout(() => takePortalScreenshot(), 3000);
+                } else {
+                    throw new Error(data.message);
+                }
+            } catch (e) {
+                showProxyMessage('❌ Error: ' + e.message);
+            } finally {
+                btn.textContent = originalText;
+                btn.disabled = false;
+            }
+        }
+        
+        function updateProxyDisplay(proxy, stats) {
+            if (proxy) {
+                document.getElementById('current-proxy-display').textContent = proxy;
+                document.getElementById('proxy-info').style.display = 'block';
+            }
+        }
+        
+        function showProxyMessage(msg) {
+            const el = document.getElementById('proxy-message');
+            el.textContent = msg;
+            el.style.color = msg.startsWith('✅') ? 'var(--success)' : 'var(--error)';
+            setTimeout(() => {
+                el.textContent = '';
+            }, 5000);
+        }
+    </script>
 </body>
 
 </html>