Update app.py

app.py

@@ -1,218 +1,189 @@
-# app.py
+# app.py (Refactored for Gradio State compatibility)
 
 import gradio as gr
-import os
-os.system("playwright install")
 from playwright.sync_api import sync_playwright, Error as PlaywrightError
 from bs4 import BeautifulSoup
 import urllib.parse
 import datetime
 import atexit
 import re
+import os
 from itertools import cycle
+import uuid # For generating unique tab IDs
 
-# --- NEW: Credential Revolver Class ---
-class CredentialRevolver:
-    """Manages a rotating list of proxies."""
-    def __init__(self, proxy_string: str):
-        self.proxies = self._parse_proxies(proxy_string)
-        if self.proxies:
-            self.proxy_cycler = cycle(self.proxies)
-            print(f"✅ CredentialRevolver initialized with {len(self.proxies)} proxies.")
-        else:
-            self.proxy_cycler = None
-            print("⚠️ CredentialRevolver initialized with no proxies. Using direct connection.")
-
-    def _parse_proxies(self, proxy_string: str):
-        """Parses a multi-line string of proxies into a list of dicts."""
-        proxies = []
-        for line in proxy_string.strip().splitlines():
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                # Format: http://user:pass@host:port
-                parsed = urllib.parse.urlparse(f"//{line}") # Add // to help parsing
-                server = f"{parsed.scheme or 'http'}://{parsed.hostname}:{parsed.port}"
-                proxy_dict = {
-                    "server": server,
-                    "username": parsed.username,
-                    "password": parsed.password,
-                }
-                proxies.append(proxy_dict)
-            except Exception as e:
-                print(f"Could not parse proxy line: '{line}'. Error: {e}")
-        return proxies
-
-    def get_next(self):
-        """Returns the next proxy configuration in a round-robin fashion."""
-        if self.proxy_cycler:
-            return next(self.proxy_cycler)
-        return None # No proxy
-
-    def count(self):
-        return len(self.proxies)
-
-# --- GLOBAL PLAYWRIGHT AND REVOLVER SETUP ---
 try:
     p = sync_playwright().start()
     browser = p.firefox.launch(headless=True, timeout=60000)
     print("✅ Playwright browser launched successfully.")
 except Exception as e:
-    print(f"❌ Could not launch Playwright browser: {e}"); exit()
+    print(f"❌ Could not launch Playwright browser. Original error: {e}")
+    exit()
 
-# Load proxies from Hugging Face Secrets (environment variable)
-proxy_list_str = os.getenv("PROXY_LIST", "")
-revolver = CredentialRevolver(proxy_list_str)
+# This dictionary is the key to the solution. It maps a tab's unique ID
+# to its live, non-copyable Playwright Page and Context object.
+LIVE_CONTEXTS = {}  # { tab_id: { "context": PlaywrightContext, "page": PlaywrightPage } }
 
 def cleanup():
-    print("🧹 Cleaning up: Closing Playwright browser..."); browser.close(); p.stop()
+    """Ensures all browser resources are closed when the app shuts down."""
+    print(f"🧹 Cleaning up: Closing {len(LIVE_CONTEXTS)} browser contexts...")
+    for tab_id, resources in LIVE_CONTEXTS.items():
+        if not resources["context"].is_closed():
+            resources["context"].close()
+    browser.close()
+    p.stop()
 atexit.register(cleanup)
 
 
-# --- Core Browser Logic (Upgraded with Proxy Contexts) ---
-
-class Tab:
-    """Represents a single browser tab, now tied to a BrowserContext."""
-    def __init__(self, context, page, proxy_used):
-        self.context = context # The isolated browser context (has the proxy)
-        self.page = page       # The Playwright page object within the context
-        self.proxy_used = proxy_used # Info for logging
-        self.title = "New Tab"
+class TabState:
+    """A plain data class representing a tab's state. Fully copyable."""
+    def __init__(self, tab_id, proxy_used="Direct Connection"):
+        self.id = tab_id
         self.url = "about:blank"
+        self.title = "New Tab"
         self.parsed_text = "Welcome! Navigate to a URL or search to get started."
         self.links = []
+        self.proxy_used = proxy_used
 
-    def close(self):
-        """Closes the underlying BrowserContext, which also closes the page."""
-        if not self.context.is_closed():
-            self.context.close()
-
-class RealBrowser:
-    """Manages multiple tabs, each potentially with its own proxy."""
+class BrowserState:
+    """A plain data class representing the browser's overall state."""
     def __init__(self):
-        self.tabs = []
-        self.active_tab_index = -1
-        self.new_tab() # Start with one tab
+        self.tabs = []  # A list of TabState objects
+        self.active_tab_id = None
+        # Add bookmarks, history etc. here if needed
+    
+    def get_active_tab(self) -> TabState | None:
+        if not self.active_tab_id: return None
+        return next((t for t in self.tabs if t.id == self.active_tab_id), None)
 
-    def _get_active_tab(self):
-        if self.active_tab_index == -1 or self.active_tab_index >= len(self.tabs): return None
-        return self.tabs[self.active_tab_index]
-        
-    def _fetch_and_parse(self, tab, url):
-        # (This function remains largely the same as the previous version)
-        log = f"▶️ Navigating to {url}..."
-        try:
-            tab.page.goto(url, wait_until='domcontentloaded', timeout=30000)
-            tab.url = tab.page.url
-            tab.title = tab.page.title() or "No Title"
-            log += f"\n✅ Arrived at: {tab.url}"
-            log += f"\n📄 Title: {tab.title}"
 
-            html_content = tab.page.content()
-            soup = BeautifulSoup(html_content, 'lxml')
-            for script in soup(["script", "style", "nav", "footer"]): script.extract()
-            tab.parsed_text = soup.get_text(separator='\n', strip=True)
+class CredentialRevolver: # (This class is unchanged)
+    def __init__(self, proxy_string: str):
+        self.proxies = self._parse_proxies(proxy_string)
+        if self.proxies: self.proxy_cycler = cycle(self.proxies)
+        else: self.proxy_cycler = None
+    def _parse_proxies(self, proxy_string: str):
+        proxies = [];
+        for line in proxy_string.strip().splitlines():
+            try: parsed = urllib.parse.urlparse(f"//{line.strip()}"); server = f"{parsed.scheme or 'http'}://{parsed.hostname}:{parsed.port}"; proxies.append({"server": server, "username": parsed.username, "password": parsed.password})
+            except: pass
+        return proxies
+    def get_next(self): return next(self.proxy_cycler) if self.proxy_cycler else None
+    def count(self): return len(self.proxies)
 
-            tab.links = []
-            for link in soup.find_all('a', href=True):
-                href = link['href']
-                absolute_url = urllib.parse.urljoin(tab.url, href)
-                if absolute_url.startswith('http') and not re.match(r'javascript:|mailto:', absolute_url):
-                    link_text = link.get_text(strip=True) or "[No Link Text]"
-                    tab.links.append({'text': link_text, 'url': absolute_url})
-            log += f"\n🔗 Found {len(tab.links)} links."
-        except PlaywrightError as e:
-            error_message = str(e); tab.title = "Error"; tab.url = url
-            tab.parsed_text = f"❌ Failed to load page.\n\nError: {error_message}"
-            tab.links = []; log += f"\n❌ {error_message}"
-        return log
+proxy_list_str = os.getenv("PROXY_LIST", "")
+revolver = CredentialRevolver(proxy_list_str)
+
+def _fetch_and_update_tab_state(tab_state: TabState, url: str):
+    """
+    The core function. It uses the tab_state's ID to find the LIVE page,
+    navigates it, and then updates the copyable tab_state object.
+    """
+    log = f"▶️ Navigating to {url}..."
+    live_page = LIVE_CONTEXTS[tab_state.id]["page"]
+
+    try:
+        live_page.goto(url, wait_until='domcontentloaded', timeout=30000)
+        tab_state.url = live_page.url
+        tab_state.title = live_page.title() or "No Title"
+        log += f"\n✅ Arrived at: {tab_state.url}"
+
+        html_content = live_page.content()
+        soup = BeautifulSoup(html_content, 'lxml')
+        for script in soup(["script", "style", "nav", "footer"]): script.extract()
+        tab_state.parsed_text = soup.get_text(separator='\n', strip=True)
+
+        tab_state.links = []
+        for link in soup.find_all('a', href=True):
+            href = link['href']
+            absolute_url = urllib.parse.urljoin(tab_state.url, href)
+            if absolute_url.startswith('http') and not re.match(r'javascript:|mailto:', absolute_url):
+                link_text = link.get_text(strip=True) or "[No Link Text]"
+                tab_state.links.append({'text': link_text, 'url': absolute_url})
+        log += f"\n🔗 Found {len(tab_state.links)} links."
+    except PlaywrightError as e:
+        error_message = str(e); tab_state.title = "Error"; tab_state.url = url
+        tab_state.parsed_text = f"❌ Failed to load page.\n\nError: {error_message}"
+        tab_state.links = []; log += f"\n❌ {error_message}"
+    
+    return log
 
-    def go(self, term_or_url):
-        tab = self._get_active_tab()
-        if not tab: return "No active tab."
-        parsed_url = urllib.parse.urlparse(term_or_url)
-        url = term_or_url if (parsed_url.scheme and parsed_url.netloc) else f"https://duckduckgo.com/html/?q={urllib.parse.quote_plus(term_or_url)}"
-        return self._fetch_and_parse(tab, url)
+def handle_action(browser_state: BrowserState, action: str, value=None):
+    """Main event handler. It modifies the browser_state and interacts with LIVE_CONTEXTS."""
+    log = ""
+    active_tab_state = browser_state.get_active_tab()
 
-    def new_tab(self):
-        """CRITICAL CHANGE: Creates a new tab with the next available proxy."""
+    if action == "new_tab":
+        tab_id = str(uuid.uuid4())
         proxy_config = revolver.get_next()
-        log = ""
         
+        context = browser.new_context(proxy=proxy_config)
+        page = context.new_page()
+        LIVE_CONTEXTS[tab_id] = {"context": context, "page": page}
+
+        new_tab = TabState(tab_id, proxy_used=proxy_config['server'] if proxy_config else "Direct")
+        browser_state.tabs.append(new_tab)
+        browser_state.active_tab_id = tab_id
+        
+        # Now navigate the new tab
+        log = _fetch_and_update_tab_state(new_tab, "https://www.whatsmyip.org/")
+    
+    elif action == "go" and active_tab_state:
+        url = value if (urllib.parse.urlparse(value).scheme and urllib.parse.urlparse(value).netloc) else f"https://duckduckgo.com/html/?q={urllib.parse.quote_plus(value)}"
+        log = _fetch_and_update_tab_state(active_tab_state, url)
+        
+    elif action == "click" and active_tab_state:
         try:
-            # Create a new context with the proxy settings
-            context = browser.new_context(proxy=proxy_config)
-            page = context.new_page()
+            link_index = int(value)
+            if 0 <= link_index < len(active_tab_state.links):
+                link_url = active_tab_state.links[link_index]['url']
+                log = _fetch_and_update_tab_state(active_tab_state, link_url)
+            else: log = "Invalid link number."
+        except: log = "Please enter a valid number to click."
+        
+    elif action == "close_tab" and active_tab_state:
+        if len(browser_state.tabs) <= 1:
+            log = "Cannot close the last tab."
+        else:
+            tab_to_close_id = browser_state.active_tab_id
             
-            proxy_info = proxy_config['server'] if proxy_config else "Direct Connection"
-            log += f"✨ New tab opened.\n🔒 Using proxy: {proxy_info}"
+            # Find and remove tab from state
+            tab_index = browser_state.tabs.index(active_tab_state)
+            browser_state.tabs.pop(tab_index)
             
-            tab = Tab(context, page, proxy_info)
-            self.tabs.append(tab)
-            self.active_tab_index = len(self.tabs) - 1
+            # Set new active tab
+            new_index = tab_index - 1 if tab_index > 0 else 0
+            browser_state.active_tab_id = browser_state.tabs[new_index].id
             
-            # Navigate to a default page
-            log += "\n" + self.go("https://www.whatsmyip.org/")
-        except Exception as e:
-            log += f"\n❌ Failed to create new tab/context: {e}"
-            if 'context' in locals() and not context.is_closed():
-                context.close()
-        return log
-
-    def close_tab(self):
-        if len(self.tabs) <= 1: return "Cannot close the last tab."
-        
-        tab_to_close = self.tabs.pop(self.active_tab_index)
-        tab_to_close.close() # This now closes the context and the page
-
-        if self.active_tab_index >= len(self.tabs):
-            self.active_tab_index = len(self.tabs) - 1
-        return f"💣 Tab closed. Switched to Tab {self.active_tab_index}."
-
-    # Other methods (back, forward, refresh, switch_tab) remain the same
-    # as they operate on the tab's page object, which is now correctly context-aware.
-    def back(self):
-        tab = self._get_active_tab()
-        if tab and tab.page.can_go_back():
-            tab.page.go_back(wait_until='domcontentloaded'); return self._fetch_and_parse(tab, tab.page.url)
-        return "Cannot go back."
-
-    def forward(self):
-        tab = self._get_active_tab()
-        if tab and tab.page.can_go_forward():
-            tab.page.go_forward(wait_until='domcontentloaded'); return self._fetch_and_parse(tab, tab.page.url)
-        return "Cannot go forward."
-        
-    def refresh(self):
-        tab = self._get_active_tab()
-        if tab:
-            tab.page.reload(wait_until='domcontentloaded'); return self._fetch_and_parse(tab, tab.page.url)
-        return "No active tab."
-
-    def switch_tab(self, tab_label):
+            # Close and remove live resources
+            resources = LIVE_CONTEXTS.pop(tab_to_close_id)
+            if not resources['context'].is_closed():
+                resources['context'].close()
+            log = f"💣 Tab closed."
+            
+    elif action == "switch_tab":
         try:
-            index = int(tab_label.split(":")[0].replace("Tab", "").strip())
-            if 0 <= index < len(self.tabs): self.active_tab_index = index; return f"Switched to Tab {index}."
-            return "Invalid tab index."
-        except: return "Invalid tab format."
+            # The value from the radio button is the tab_id itself
+            browser_state.active_tab_id = value
+            log = f"Switched to tab."
+        except: log = "Invalid tab format."
+    
+    # Return the modified state object. Gradio will handle copying it for the UI update.
+    return browser_state, log
+
 
-# --- Gradio UI and Event Handlers (mostly unchanged, but with proxy info) ---
-def update_ui_components(browser_state: RealBrowser):
-    active_tab = browser_state._get_active_tab()
+def update_ui_components(browser_state: BrowserState):
+    """Generates all UI component values from the plain browser_state object."""
+    active_tab = browser_state.get_active_tab()
     if not active_tab:
-        # Handle case where all tabs are closed
         return {
             page_content: gr.Markdown("No active tabs. Please create a new one."),
-            url_textbox: "",
-            links_display: "",
+            url_textbox: "", links_display: "",
             tab_selector: gr.Radio(choices=[], label="Active Tabs"),
         }
         
-    # Add proxy info to the tab selector for clarity
-    tab_choices = [f"Tab {i}: {tab.title[:30]}... (via {tab.proxy_used.split('//')[1].split('@')[-1] if tab.proxy_used != 'Direct Connection' else 'Direct'})" for i, tab in enumerate(browser_state.tabs)]
-    active_tab_label = tab_choices[browser_state.active_tab_index]
-
+    # Use the tab ID as the value for the radio button
+    tab_choices = [(f"Tab {i}: {t.title[:25]}... (via {t.proxy_used})", t.id) for i, t in enumerate(browser_state.tabs)]
+    
     links_md = "### 🔗 Links on Page\n"
     if active_tab.links:
         for i, link in enumerate(active_tab.links[:25]): links_md += f"{i}. [{link['text'][:80]}]({link['url']})\n"
@@ -222,40 +193,21 @@ def update_ui_components(browser_state: RealBrowser):
         page_content: gr.Markdown(f"# {active_tab.title}\n**URL:** {active_tab.url}\n\n---\n\n{active_tab.parsed_text[:2000]}..."),
         url_textbox: gr.Textbox(value=active_tab.url),
         links_display: gr.Markdown(links_md),
-        tab_selector: gr.Radio(choices=tab_choices, value=active_tab_label, label="Active Tabs"),
+        tab_selector: gr.Radio(choices=tab_choices, value=active_tab.id, label="Active Tabs"),
     }
 
-# The handle_action function remains the same as it's a generic dispatcher
-def handle_action(browser_state, action, value=None):
-    # ... (same as previous version)
-    if action == "go": log = browser_state.go(value)
-    elif action == "click":
-        tab = browser_state._get_active_tab()
-        try:
-            link_index = int(value)
-            if tab and 0 <= link_index < len(tab.links):
-                log = browser_state.go(tab.links[link_index]['url'])
-            else: log = "Invalid link number."
-        except: log = "Please enter a valid number to click."
-    elif action == "back": log = browser_state.back()
-    elif action == "forward": log = browser_state.forward()
-    elif action == "refresh": log = browser_state.refresh()
-    elif action == "new_tab": log = browser_state.new_tab()
-    elif action == "close_tab": log = browser_state.close_tab()
-    elif action == "switch_tab": log = browser_state.switch_tab(value)
-    else: log = "Unknown action."
-    
-    return {**update_ui_components(browser_state), log_display: gr.Textbox(log)}
-
-# The Gradio Blocks layout remains the same
+# --- Gradio UI Layout ---
 with gr.Blocks(theme=gr.themes.Soft(), title="Real Browser Demo") as demo:
-    # ... (same as previous version)
-    browser_state = gr.State(RealBrowser())
-    gr.Markdown("# 🛰️ Real Browser Demo (with Proxy Revolver)")
-    gr.Markdown(f"Type a URL or search term. This demo runs a real headless browser with **{revolver.count()} proxies loaded**.")
+    # Initialize the state with our new, copyable BrowserState class
+    browser_state = gr.State(BrowserState())
+
+    gr.Markdown("# 🛰️ Real Browser Demo (with Proxies & State Fix)")
+    gr.Markdown(f"This demo runs a real headless browser. **{revolver.count()} proxies loaded**.")
+    # (The rest of the UI layout is the same)
+    # ...
+    # --- Gradio Interface Layout ---
     with gr.Row():
         with gr.Column(scale=3):
-            with gr.Row(): back_btn = gr.Button("◀ Back"); forward_btn = gr.Button("▶ Forward"); refresh_btn = gr.Button("🔄 Refresh")
             url_textbox = gr.Textbox(label="URL or Search Term", interactive=True)
             go_btn = gr.Button("Go", variant="primary")
             with gr.Accordion("Page Content (Text Only)", open=True): page_content = gr.Markdown("Loading...")
@@ -266,17 +218,30 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Real Browser Demo") as demo:
             with gr.Accordion("Clickable Links", open=True):
                 links_display = gr.Markdown("...")
                 with gr.Row(): click_num_box = gr.Number(label="Link #", scale=1, minimum=0, step=1); click_btn = gr.Button("Click Link", scale=2)
-    
+
     all_outputs = [page_content, url_textbox, links_display, tab_selector, log_display]
-    demo.load(lambda s: {**update_ui_components(s), log_display: f"🚀 Browser Initialized! {revolver.count()} proxies loaded. A new tab has been opened to check the IP."}, inputs=[browser_state], outputs=all_outputs)
-    go_btn.click(lambda s, v: handle_action(s, "go", v), [browser_state, url_textbox], all_outputs, show_progress="full")
-    url_textbox.submit(lambda s, v: handle_action(s, "go", v), [browser_state, url_textbox], all_outputs, show_progress="full")
-    click_btn.click(lambda s, v: handle_action(s, "click", v), [browser_state, click_num_box], all_outputs, show_progress="full")
-    back_btn.click(lambda s: handle_action(s, "back"), [browser_state], all_outputs, show_progress="full")
-    forward_btn.click(lambda s: handle_action(s, "forward"), [browser_state], all_outputs, show_progress="full")
-    refresh_btn.click(lambda s: handle_action(s, "refresh"), [browser_state], all_outputs, show_progress="full")
-    new_tab_btn.click(lambda s: handle_action(s, "new_tab"), [browser_state], all_outputs, show_progress="full")
-    close_tab_btn.click(lambda s: handle_action(s, "close_tab"), [browser_state], all_outputs)
-    tab_selector.input(lambda s, v: handle_action(s, "switch_tab", v), [browser_state, tab_selector], all_outputs)
+
+    def master_handler(current_state, action, value):
+        new_state, log = handle_action(current_state, action, value)
+        # The update_ui_components function now only needs the state
+        ui_updates = update_ui_components(new_state)
+        ui_updates[log_display] = log
+        # IMPORTANT: Return the new_state object to update gr.State
+        return new_state, ui_updates
+
+    # Initial load: create the first tab
+    demo.load(
+        lambda s: master_handler(s, "new_tab", None)[1], # Just return the UI updates
+        inputs=[browser_state],
+        outputs=list(all_outputs)
+    )
+
+    # Event listeners now call the master_handler
+    go_btn.click(lambda s, v: master_handler(s, "go", v), [browser_state, url_textbox], [browser_state, *all_outputs], show_progress="full")
+    url_textbox.submit(lambda s, v: master_handler(s, "go", v), [browser_state, url_textbox], [browser_state, *all_outputs], show_progress="full")
+    click_btn.click(lambda s, v: master_handler(s, "click", v), [browser_state, click_num_box], [browser_state, *all_outputs], show_progress="full")
+    new_tab_btn.click(lambda s: master_handler(s, "new_tab", None), [browser_state], [browser_state, *all_outputs], show_progress="full")
+    close_tab_btn.click(lambda s: master_handler(s, "close_tab", None), [browser_state], [browser_state, *all_outputs])
+    tab_selector.input(lambda s, v: master_handler(s, "switch_tab", v), [browser_state, tab_selector], [browser_state, *all_outputs])
 
 demo.launch()