TEMP: Added debug logging for body selector timeout

app.py

@@ -1,7 +1,7 @@
 import gevent.monkey
-gevent.monkey.patch_all(asyncio=True)
-# app.py
-import asyncio
+gevent.monkey.patch_all(asyncio=True) # Keep this at the very top
+
+import asyncio # Keep this
 from flask import Flask, request, jsonify
 from proxy_lite import Runner, RunnerConfig
 import os
@@ -19,23 +19,20 @@ async def initialize_runner():
     if _runner is None:
         logger.info("Initializing Proxy-lite Runner...")
         
-        # Retrieve Hugging Face API token from environment variables
         hf_api_token = os.environ.get("HF_API_TOKEN")
         if not hf_api_token:
             logger.error("HF_API_TOKEN environment variable not set. Cannot initialize Runner.")
             raise ValueError("HF_API_TOKEN environment variable not set. Please set it as a Space secret.")
 
-        # Define RunnerConfig
         config = RunnerConfig.from_dict({
             "environment": {
                 "name": "webbrowser",
                 "homepage": "https://dwd000006jia1mae.lightning.force.com/lightning/setup/AccountForecastSettings/home",
-                "headless": True, # Keep headless for production environments
-                "launch_args": ["--no-sandbox", "--disable-setuid-sandbox"] ,
-                # "environment_timeout": 1800.0, # <-- THIS LINE WAS IN THE WRONG PLACE IN app.py
-                "screenshot_delay": 3.0, # Increased delay for full page render before screenshot
-                "include_html": True, # Include full HTML for richer observations
-                "include_poi_text": True, # Keep including points of interest text
+                "headless": True,
+                "launch_args": ["--no-sandbox", "--disable-setuid-sandbox"],
+                "screenshot_delay": 3.0,
+                "include_html": True,
+                "include_poi_text": True,
             },
             "solver": {
                 "name": "simple",
@@ -49,50 +46,34 @@ async def initialize_runner():
                     }
                 }
             },
-            # --- MOVE environment_timeout HERE, AS A TOP-LEVEL KEY ---
-            "environment_timeout": 1800.0, 
-            # You can also set other top-level RunnerConfig fields here if desired,
-            # e.g., "action_timeout": 1800.0, "max_steps": 150, "task_timeout": 18000.0,
-            # Ensure these match your desired values and not the defaults from RunnerConfig.
-            # Based on your logs, action_timeout and task_timeout seem to be default, so let's add them:
-            "action_timeout": 1800.0, # As per your earlier runner.py __main__ block
-            "task_timeout": 18000.0,  # As per your earlier runner.py __main__ block
-            "max_steps": 150,         # As per your earlier runner.py __main__ block
-            "logger_level": "DEBUG", # Set this to DEBUG for more detailed logging during troubleshooting
-            # --- END OF MOVED KEY ---
+            "environment_timeout": 1800.0,
+            "action_timeout": 1800.0,
+            "task_timeout": 18000.0,
+            "max_steps": 150,
+            "logger_level": "DEBUG",
         })
 
-        # --- ADDED DEBUG LOGGING HERE ---
         logger.info(f"DEBUG: app.py - Initializing Runner with environment_timeout: {config.environment_timeout} seconds")
-        logger.info(f"DEBUG: app.py - Full config used: {config.model_dump_json(indent=2)}") # For Pydantic v2
-        # If you are using Pydantic v1, use: logger.info(f"DEBUG: app.py - Full config used: {config.json(indent=2)}")
-        # --- END ADDED DEBUG LOGGING ---
+        logger.info(f"DEBUG: app.py - Full config used: {config.model_dump_json(indent=2)}")
 
         _runner = Runner(config=config)
         logger.info("Proxy-lite Runner initialized successfully.")
     return _runner
 
-# --- MODIFIED run_async_task FUNCTION ---
-def run_async_task(coro):
-    """
-    Helper to run async coroutines in a synchronous context (like Flask routes).
-    Ensures an event loop exists and runs the coroutine.
-    """
-    try:
-        # Try to get the running loop (for current thread/greenlet)
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        # If no loop is running, create a new one for this thread
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    
-    # Run the coroutine until it completes
-    return loop.run_until_complete(coro)
+# --- MODIFIED run_async_task FUNCTION (SIMPLIFIED) ---
+# This function is no longer needed in most cases with gevent.monkey.patch_all(asyncio=True)
+# but if you must call async functions from sync context, you simply await them.
+# However, you are already in an async function context within Flask routes when using Gunicorn/gevent.
+# The Gunicorn worker itself implicitly runs an event loop.
+# Let's remove the run_until_complete part.
+
+# DELETED: def run_async_task(coro): ...
+
 # --- END MODIFIED run_async_task FUNCTION ---
 
 
 @app.route('/run_proxy_task', methods=['POST'])
-def run_proxy_task_endpoint():
+async def run_proxy_task_endpoint(): # <--- MAKE THIS FUNCTION ASYNC
     data = request.json
     request_task_instruction = data.get('task')
 
@@ -109,9 +90,6 @@ def run_proxy_task_endpoint():
         logger.error("Salesforce credentials (SALESFORCE_USERNAME, SALESFORCE_PASSWORD) environment variables not set.")
         return jsonify({"error": "Salesforce credentials not configured. Please set SALESFORCE_USERNAME and SALESFORCE_PASSWORD as Space secrets."}), 500
 
-    # Construct the full task for the proxy-lite agent,
-    # combining login instructions with the dynamic task from the user,
-    # and adding explicit verification steps for login success.
     agent_task = (
         f"Log in to Salesforce. The username is '{salesforce_username}' and the password is '{salesforce_password}'. "
         f"After attempting to log in, observe the page carefully. "
@@ -123,13 +101,16 @@ def run_proxy_task_endpoint():
     logger.info(f"Executing agent task: '{agent_task[:200]}...'")
 
     try:
-        runner = run_async_task(initialize_runner())
-        result = run_async_task(runner.run(agent_task))
+        # Since run_proxy_task_endpoint is now async, you can directly await
+        runner = await initialize_runner()
+        result = await runner.run(agent_task) # <--- AWAIT DIRECTLY
 
         logger.info(f"Proxy-lite task completed. Output: {result[:200]}...")
         return jsonify({"output": result})
     except Exception as e:
         logger.exception(f"Error processing Salesforce task: {e}")
+        # The RuntimeWarning: coroutine 'initialize_runner' was never awaited will disappear
+        # because initialize_runner is now awaited.
         return jsonify({"error": f"An error occurred: {str(e)}. Check logs for details."}), 500
 
 @app.route('/')

src/proxy_lite/browser/browser.py

@@ -15,6 +15,8 @@ from tenacity import before_sleep_log, retry, stop_after_delay, wait_exponential
 from proxy_lite.browser.bounding_boxes import POI, BoundingBox, Point, annotate_bounding_boxes
 from proxy_lite.logger import logger
 
+import base64
+
 SELF_CONTAINED_TAGS = [
     # many of these are non-interactive but keeping them anyway
     "area",
@@ -183,10 +185,53 @@ class BrowserSession:
     )
     async def update_poi(self) -> None:
         try:
-            await self.current_page.wait_for_load_state(timeout=60000)
-        except PlaywrightTimeoutError:
-            logger.error(f"Timeout waiting for website load state: {self.current_url}")
-        await self.current_page.wait_for_selector("body", timeout=180000, state="visible")
+            # Added for robustness based on previous discussions
+            await self.current_page.wait_for_load_state("networkidle", timeout=180000)
+            logger.debug("wait_for_load_state('networkidle') completed.")
+
+            # This is the line that was previously timing out, now with increased timeout.
+            # Adding explicit try/except around it for specific debugging.
+            try:
+                await self.current_page.wait_for_selector("body", timeout=180000, state="visible")
+                logger.debug("wait_for_selector('body', state='visible') completed.")
+            except PlaywrightTimeoutError as e:
+                # --- START TEMPORARY DEBUGGING CODE ---
+                current_url = self.current_page.url if self.current_page else "N/A"
+                logger.error(f"DEBUGGING: Playwright Timeout (180s) on body selector at URL: {current_url}")
+
+                html_content = None
+                try:
+                    if self.current_page:
+                        html_content = await self.current_page.content()
+                        # Log only a snippet of HTML to avoid excessively large logs
+                        logger.error(f"DEBUGGING: HTML Content (first 1000 chars) when timeout occurred:\n{html_content[:1000]}...")
+                except Exception as html_e:
+                    logger.error(f"DEBUGGING: Could not get HTML content: {html_e}")
+
+                screenshot_b64 = "N/A"
+                try:
+                    if self.current_page:
+                        # Capture screenshot at lower quality to keep log size manageable
+                        screenshot_bytes = await self.current_page.screenshot(type="jpeg", quality=50)
+                        screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
+                        # Log only a very short snippet of base64 string
+                        logger.error(f"DEBUGGING: Base64 Screenshot (truncated) when timeout occurred:\ndata:image/jpeg;base64,{screenshot_b64[:100]}... (full string is much longer)")
+                except Exception as ss_e:
+                    logger.error(f"DEBUGGING: Could not take screenshot: {ss_e}")
+
+                # Re-raise the original exception to ensure the task still fails,
+                # but now with crucial debugging information in the logs.
+                raise e
+                # --- END TEMPORARY DEBUGGING CODE ---
+
+        except PlaywrightTimeoutError: # This outer catch is for the wait_for_load_state timeout
+            logger.error(f"Timeout waiting for website load state (networkidle): {self.current_url}")
+            raise # Re-raise if load_state itself times out
+
+        except Exception as e:
+            logger.error(f"An unexpected error occurred during page readiness check: {e}")
+            raise
+
         # Run the bounding box javascript code to highlight the points of interest on the page
         page_info = await self.current_page.evaluate(
             """() => {
@@ -204,7 +249,6 @@ class BrowserSession:
             max_iframes = 10
 
             # Define an asynchronous function to process and filter each iframe
-
             tasks = [asyncio.create_task(self.process_iframe(iframe)) for iframe in iframes[:max_iframes]]
 
             results = await asyncio.gather(*tasks)