trying fixes for loading

src/proxy_lite/browser/browser.py

@@ -15,7 +15,7 @@ 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 # IMPORTANT: Make sure this import is present!
+import base64 # Make sure this import is present!
 
 SELF_CONTAINED_TAGS = [
     # many of these are non-interactive but keeping them anyway
@@ -144,7 +144,7 @@ class BrowserSession:
     # re-run for cases of mid-run redirects
     @retry(
         wait=wait_exponential(multiplier=1, min=1, max=10),
-        stop=stop_after_delay(5),  # This retry is for the entire update_poi method, in case of intermittent issues
+        stop=stop_after_delay(5),
         reraise=True,
         before_sleep=before_sleep_log(logger, logging.ERROR),
     )
@@ -187,29 +187,31 @@ class BrowserSession:
     )
     async def update_poi(self) -> None:
         try:
-            # Step 1: Wait for network to be idle. This indicates that initial requests have settled.
-            logger.debug("Attempting wait_for_load_state('networkidle')...")
-            await self.current_page.wait_for_load_state("networkidle", timeout=180000) # Increased timeout
-            logger.debug("wait_for_load_state('networkidle') completed.")
-
-            # Step 2: Wait for the 'loading' class to disappear from the body.
-            # This is a common and effective way to detect when SPAs like Salesforce are visually ready.
-            logger.debug("Attempting wait_for_selector('body:not(.loading)')...")
-            await self.current_page.wait_for_selector("body:not(.loading)", timeout=180000)
-            logger.debug("wait_for_selector('body:not(.loading)') completed.")
-
-            # Optional Step 3 (Highly Recommended): If the above still times out,
-            # uncomment and replace with a reliable selector for an interactive element
-            # that only appears after the Salesforce UI is fully loaded and ready for user input.
-            # Example: await self.current_page.wait_for_selector("#some_salesforce_specific_id", timeout=180000, state="visible")
-            # Example: await self.current_page.wait_for_selector("text=App Launcher", timeout=180000, state="visible")
-            # For now, we'll rely on the 'body:not(.loading)' as the primary indicator.
+            # Step 1: Wait for DOMContentLoaded. This ensures the basic HTML structure is parsed.
+            logger.debug("Attempting wait_for_load_state('domcontentloaded')...")
+            await self.current_page.wait_for_load_state("domcontentloaded", timeout=180000)
+            logger.debug("wait_for_load_state('domcontentloaded') completed.")
+
+            # Step 2: Wait for the specific text "Account Forecasting" to be visible on the page.
+            # This is a strong indicator that the core content for the task has loaded.
+            target_text = "Account Forecasting"
+            logger.debug(f"Attempting to wait for text: '{target_text}' to be visible...")
+            await self.current_page.wait_for_selector(f"text={target_text}", timeout=180000, state="visible")
+            logger.debug(f"Text '{target_text}' became visible.")
+
+            # Optional: You can still add a wait for network idle *after* the text is visible
+            # if the page still isn't interactive immediately, but prioritize the text.
+            # try:
+            #     await self.current_page.wait_for_load_state("networkidle", timeout=60000) # Shorter timeout here
+            #     logger.debug("wait_for_load_state('networkidle') completed after text appeared.")
+            # except PlaywrightTimeoutError:
+            #     logger.warning("Network idle state not reached after text appeared, but proceeding.")
 
         except PlaywrightTimeoutError as e:
             # --- START TEMPORARY DEBUGGING CODE ---
             # This block captures state specifically when a Playwright timeout occurs
             current_url = self.current_page.url if self.current_page else "N/A"
-            logger.error(f"DEBUGGING: Playwright Timeout (180s) during page readiness check at URL: {current_url}")
+            logger.error(f"DEBUGGING: Playwright Timeout (180s) during page readiness check for text '{target_text}' at URL: {current_url}")
 
             html_content = None
             try:
@@ -222,18 +224,9 @@ class BrowserSession:
             screenshot_b64 = "N/A"
             try:
                 if self.current_page:
-                    # Capture screenshot at lower quality (e.g., 50) to keep log size manageable.
-                    # Higher quality might make logs too large for some platforms.
                     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 to confirm it's there
                     logger.error(f"DEBUGGING: Base64 Screenshot (truncated) when timeout occurred:\ndata:image/jpeg;base64,{screenshot_b64[:100]}... (full string is much longer)")
-                
-                # If you want to view the full screenshot locally during development, you can save it:
-                # with open("debug_timeout_full_screenshot.jpeg", "wb") as f:
-                #     f.write(screenshot_bytes)
-                # logger.error("DEBUGGING: Full screenshot saved to debug_timeout_full_screenshot.jpeg for local inspection.")
-
             except Exception as ss_e:
                 logger.error(f"DEBUGGING: Could not take screenshot for debug: {ss_e}")
 
@@ -451,17 +444,17 @@ class BrowserSession:
             await self.current_page.keyboard.press("Backspace")
 
 
-if __name__ == "__main__":
+    if __name__ == "__main__":
 
-    async def dummy_test():
-        async with BrowserSession(headless=False) as s:
-            page = await s.context.new_page()
-            await page.goto("http://google.co.uk")
-            await asyncio.sleep(5)
-            await page.screenshot(path="example.png")
-            await s.update_poi()
-            _, annotated_image = await s.screenshot()
-            with open("output.png", "wb") as f:
-                f.write(annotated_image)
+        async def dummy_test():
+            async with BrowserSession(headless=False) as s:
+                page = await s.context.new_page()
+                await page.goto("http://google.co.uk")
+                await asyncio.sleep(5)
+                await page.screenshot(path="example.png")
+                await s.update_poi()
+                _, annotated_image = await s.screenshot()
+                with open("output.png", "wb") as f:
+                    f.write(annotated_image)
 
-    asyncio.run(dummy_test())
+        asyncio.run(dummy_test())