Fix page load: launch Chromium with the URL and poll readyState instead of relying on Page.navigate+loadEventFired

app.py

@@ -344,47 +344,66 @@ def _cp(path: str | None) -> str | None:
     return dst
 
 
-def _launch_chromium(w: int, h: int):
-    """Launch headless Chromium with CDP enabled. Returns (proc, port)."""
+def _launch_chromium(w: int, h: int, url: str | None = None):
+    """Launch headless Chromium with CDP enabled. Returns (proc, port).
+
+    url is passed at launch so the initial tab IS the target page — navigating
+    an empty chrome://newtab tab away via Page.navigate is unreliable on some
+    chromium builds (it can silently stay on the new-tab page).
+    """
     port = get_free_port()
     chromium = get_chromium_path()
-    proc = subprocess.Popen(
-        [
-            chromium,
-            f"--remote-debugging-port={port}",
-            "--headless",
-            "--no-sandbox",
-            "--disable-dev-shm-usage",
-            "--disable-setuid-sandbox",
-            "--use-gl=swiftshader",
-            "--enable-webgl",
-            "--hide-scrollbars",
-            "--autoplay-policy=no-user-gesture-required",
-            f"--window-size={w},{h}",
-        ],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
+    cmd = [
+        chromium,
+        f"--remote-debugging-port={port}",
+        "--headless",
+        "--no-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-setuid-sandbox",
+        "--use-gl=swiftshader",
+        "--enable-webgl",
+        "--hide-scrollbars",
+        "--autoplay-policy=no-user-gesture-required",
+        "--no-first-run",
+        "--no-default-browser-check",
+        f"--window-size={w},{h}",
+    ]
+    if url:
+        cmd.append(url)
+    proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     return proc, port
 
 
-async def _connect_cdp(port: int, log):
+async def _connect_cdp(port: int, log, target_url: str | None = None):
     """Wait for the Chrome DevTools websocket URL and return it.
 
     /json/list returns several targets (extension background pages, browser_ui,
-    etc.). We must pick the actual tab (type == "page") — pages[0] may be an
-    extension background_page, and navigating that would never reach the URL.
+    etc.). Prefer a type == "page" target; if target_url is given, prefer a page
+    whose URL already matches its host (launch-with-url case).
     """
+    host = None
+    if target_url:
+        from urllib.parse import urlparse
+        host = urlparse(target_url).netloc
+
     async with aiohttp.ClientSession() as session:
         for attempt in range(20):
             await asyncio.sleep(0.5)
             try:
                 async with session.get(f"http://localhost:{port}/json/list") as resp:
                     targets = await resp.json()
-                    page = next((t for t in targets if t.get("type") == "page"), None)
-                    if page:
-                        log(f"chrome devtools ready after {attempt+1} attempts")
-                        return page["webSocketDebuggerUrl"]
+                    pages = [t for t in targets if t.get("type") == "page"]
+                    if not pages:
+                        continue
+                    chosen = None
+                    if host:
+                        chosen = next(
+                            (t for t in pages if host in (t.get("url") or "")),
+                            None,
+                        )
+                    chosen = chosen or pages[0]
+                    log(f"chrome devtools ready after {attempt+1} attempts (target={chosen.get('url')})")
+                    return chosen["webSocketDebuggerUrl"]
             except Exception as e:
                 log(f"devtools attempt {attempt+1} failed: {e}")
                 continue
@@ -392,29 +411,54 @@ async def _connect_cdp(port: int, log):
 
 
 async def _navigate_and_wait(ws, send, url, log):
-    """Navigate to url and wait for Page.loadEventFired (max 15s). Returns False on timeout."""
+    """Ensure the tab is on `url` and wait for it to finish loading.
+
+    Sends Page.navigate (idempotent when the tab already holds the URL from the
+    launch argument), then polls document.readyState via Runtime.evaluate so we
+    don't miss Page.loadEventFired (which fires before we enable Page in the
+    launch-with-url case). Returns True when ready, False on timeout (callers
+    proceed anyway).
+    """
+    from urllib.parse import urlparse
+    host = urlparse(url).netloc
+
     log(f"navigating to {url}")
-    nav_id = await send("Page.navigate", {"url": url})
-    deadline = time.monotonic() + 10
-    while time.monotonic() < deadline:
-        try:
-            raw = await asyncio.wait_for(ws.recv(), timeout=1.0)
-            if json.loads(raw).get("id") == nav_id:
-                log("Page.navigate acknowledged")
-                break
-        except asyncio.TimeoutError:
-            continue
-
-    log("waiting for Page.loadEventFired (max 15s)")
+    await send("Page.navigate", {"url": url})
+    await send("Runtime.enable")
+
     deadline = time.monotonic() + 15
     while time.monotonic() < deadline:
         try:
-            raw = await asyncio.wait_for(ws.recv(), timeout=1.0)
-            if json.loads(raw).get("method") == "Page.loadEventFired":
-                log("Page.loadEventFired received")
+            eval_id = await send(
+                "Runtime.evaluate",
+                {
+                    "expression": "JSON.stringify({href: location.href, ready: document.readyState})",
+                    "returnByValue": True,
+                },
+            )
+            state = None
+            end = time.monotonic() + 2
+            while time.monotonic() < end:
+                try:
+                    raw = await asyncio.wait_for(ws.recv(), timeout=1.0)
+                except asyncio.TimeoutError:
+                    continue
+                obj = json.loads(raw)
+                if obj.get("id") == eval_id:
+                    val = (obj.get("result", {}).get("result", {}) or {}).get("value")
+                    if val:
+                        try:
+                            state = json.loads(val)
+                        except (json.JSONDecodeError, ValueError):
+                            state = None
+                    break
+            if state and state.get("ready") == "complete" and host in (state.get("href") or ""):
+                log(f"page ready: {state.get('href')}")
                 return True
-        except asyncio.TimeoutError:
-            continue
+        except Exception as e:
+            log(f"state poll error: {e}")
+        await asyncio.sleep(0.5)
+
     log("load timeout — proceeding anyway")
     return False
 
@@ -436,10 +480,10 @@ async def _record_async(
     chromium = get_chromium_path()
     log(f"launching chromium on port {port}, url={url}, size={w}x{h}, duration={duration}")
 
-    proc, port = _launch_chromium(w, h)
+    proc, port = _launch_chromium(w, h, url)
 
     try:
-        ws_url = await _connect_cdp(port, log)
+        ws_url = await _connect_cdp(port, log, url)
 
         if not ws_url:
             raise gr.Error("Could not connect to Chrome DevTools.")
@@ -541,10 +585,10 @@ async def _capture_async(
         print(f"[wr {time.monotonic()-t0:.1f}s] {msg}", flush=True)
 
     log(f"launching chromium, url={url}, size={w}x{h}")
-    proc, port = _launch_chromium(w, h)
+    proc, port = _launch_chromium(w, h, url)
 
     try:
-        ws_url = await _connect_cdp(port, log)
+        ws_url = await _connect_cdp(port, log, url)
         if not ws_url:
             raise gr.Error("Could not connect to Chrome DevTools.")