[Bug]: connect_over_cdp: Page objects fail to sync after navigating from about:blank via Bookmark/Address bar (Empty page.url & Timeouts)

[Hmily88]

Version

1.57.0

Steps to reproduce

1.Launch Microsoft Edge (or Chrome) manually with the remote debugging port enabled. Use your default profile or a persistent session to ensure bookmarks are available:
msedge.exe --remote-debugging-port=9222

2.In the opened browser, click the "+" button to create a new blank tab (about:blank).

3.Immediately click any website from your Favorites/Bookmark bar (e.g., https://www.google.com) to navigate.

4.ONLY AFTER completing the manual navigation, run the Python script to connect via CDP.
(Note: This is NOT a runtime monitoring issue; it is a discovery issue at the moment of connection.)

Minimal reproduction code:

import json
from urllib.request import urlopen
from playwright.sync_api import sync_playwright

def test_cdp_issue():
    # 1. Inspect raw CDP targets via HTTP API
    try:
        raw_targets = json.loads(urlopen("http://127.0.0.1:9222/json/list").read().decode("utf-8"))
        print("--- Raw CDP Targets (from /json/list) ---")
        for t in raw_targets:
            if t.get("type") == "page":
                print(f"ID: {t.get('id')[:8]} | URL: {t.get('url')} | Title: {t.get('title')}")
    except Exception as e:
        print(f"Cannot fetch /json/list: {e}. Is browser running with --remote-debugging-port=9222?")

    with sync_playwright() as p:
        # Connect to existing browser
        # IMPORTANT: Manually navigate the browser FIRST, then run this script.
        print("\nConnecting to CDP...")
        browser = p.chromium.connect_over_cdp("http://127.0.0.1:9222")
        
        if not browser.contexts:
            print("Error: No contexts found.")
            return
            
        context = browser.contexts[0]
        print(f"Playwright Context Pages: {len(context.pages)}")

        for i, page in enumerate(context.pages):
            print(f"\n[Page {i}]")
            print(f"  Playwright URL: {repr(page.url)}")
            
            # Probe via CDP Session
            cdp = context.new_cdp_session(page)
            try:
                target_info = cdp.send("Target.getTargetInfo").get("targetInfo", {})
                print(f"  CDP Target URL: {repr(target_info.get('url'))}")
                
                # This usually SUCCEEDS via raw CDP
                result = cdp.send("Runtime.evaluate", {
                    "expression": "document.title", 
                    "returnByValue": True
                })
                js_title = result.get("result", {}).get("value")
                print(f"  CDP Runtime.evaluate (title): {js_title}")
                
                # This usually FAILS / TIMEOUTS via Playwright API
                # Playwright 高级 API 在此场景下通常会超时
                print("  Attempting Playwright wait_for_selector('body')...")
                page.wait_for_selector("body", timeout=3000)
                print("  Playwright Interaction: OK")
            except Exception as e:
                error_msg = str(e).splitlines()[0] if str(e) else "Timeout"
                print(f"  Playwright Interaction: FAILED -> {type(e).__name__}: {error_msg}")
            finally:
                try:
                    cdp.detach()
                except:
                    pass

if __name__ == "__main__":
    test_cdp_issue()

Expected behavior

1.All tab targets visible in http://127.0.0.1:9222/json (or /json/list) should be correctly mapped and returned as Page objects in Playwright's context.pages.

2.These Page objects should have synchronized internal states (URL, frames, etc.) and be fully interactable.

Actual behavior

1.Target Discovery Failure at Connection: When the script connects to the browser, context.pages does not include the tab that was navigated from about:blank via a bookmark, even though the tab is physically present and active in the browser.

2.Inconsistency with CDP HTTP API: If I check http://127.0.0.1:9222/json, the problematic tab IS VISIBLE and has the correct URL/Title. This proves the browser's CDP server recognizes the target, but Playwright's initialization logic fails to "adopt" it into the BrowserContext.

3.Missing Binding: Even if I try to wait for several seconds after connecting, the Page object never appears in context.pages, or if it does, it remains uninitialized (page.url == "").

Additional context

Important Note on Reproducibility:
I have tested this multiple times. While the bug occurs in the majority of attempts, there are rare occasions where the page syncs correctly. This suggests a race condition during the initial target discovery/attachment phase. I kindly ask the team to perform multiple test runs if it doesn't reproduce on the first try. Please do not close the issue immediately, as the "hollow page" state is a significant blocker for RPA scenarios involving manual browser intervention.

Cross-Machine Consistency: I have confirmed this issue on multiple different computers, indicating it is not a machine-specific configuration error but a systemic synchronization flaw.

Edge-Specific Observation: My testing primarily focused on Microsoft Edge, where the issue is highly reproducible.

Environment

- Playwright Python: 1.57.0
- Browser: Microsoft Edge 145.0.3800.82
- CDP Protocol-Version: 1.3
- OS: Windows (Windows NT 10.0 x64)
- Connection mode: `chromium.connect_over_cdp("http://127.0.0.1:9222")`

[dgozman]

@Hmily88 I cannot repro this with latest Playwright and Microsoft Edge v145.0.3800.82 (Official build) (64-bit). Perhaps there is something special in your setup, like browser policies or some other restrictions? I'm not sure how we can help.

[Hmily88]

Thank you for the follow-up.
To clarify your point about environment restrictions: There are no browser policies set on my machine (about:policy shows no active policies), and I am testing on a clean user profile without extensions.
I have updated Playwright to the latest version, but the issue persists. I have found a consistent way to reproduce the "missing page" or "API timeout" issue:

Updated Steps to Reproduce:

Launch Edge/Chrome with --remote-debugging-port=9222.

Manually open 4 blank tabs (about:blank).

Navigation Method A: Click a bookmark directly from the Favorites Bar. Playwright usually detects these pages correctly.

Navigation Method B: Click a bookmark located inside a Folder/Directory on the Favorites Bar.

The Issue:
In Method B, Playwright often fails to include the new page in context.pages. Even if the page is visible in the browser, len(context.pages) returns a number smaller than the actual tab count, leading to list index out of range in my automation scripts.

I have written a diagnostic script below to visualize this. It attempts to inject a 6px solid red border into every page Playwright can "see". If a tab has no red border, it means Playwright has lost track of that target.

import json
from urllib.request import urlopen
from playwright.sync_api import sync_playwright

def diagnostic_border_test():
    # 1. Inspect low-level CDP targets via HTTP API
    print("--- [Step 1] Raw Browser Targets via HTTP API ---")
    try:
        with urlopen("http://127.0.0.1:9222/json/list", timeout=5) as resp:
            raw_list = json.loads(resp.read().decode("utf-8"))
            # Filter targets that are actual web pages
            pages_on_http = [t for t in raw_list if t.get("type") == "page"]
            print(f"HTTP API detection: {len(pages_on_http)} pages found.")
            for i, t in enumerate(pages_on_http):
                print(f"  Target {i}: {t.get('url')[:60]}")
    except Exception as e:
        print(f"Failed to fetch HTTP API: {e}")

    # 2. Compare with Playwright's detected pages
    print("\n--- [Step 2] Playwright Context Pages Injection ---")
    with sync_playwright() as p:
        try:
            # Connect to the existing browser instance
            browser = p.chromium.connect_over_cdp("http://127.0.0.1:9222")
            context = browser.contexts[0]
            detected_pages = context.pages
            print(f"Playwright detection: {len(detected_pages)} pages found.")

            # Loop through all pages detected by Playwright
            for i in range(len(detected_pages)):
                page = detected_pages[i]
                print(f"\nProcessing Page [{i}]")
                print(f"  URL: {page.url}")
                
                try:
                    # Visual feedback: Inject a thick red border to confirm Playwright control
                    page.evaluate("document.body.style.border = '6px solid red'")
                    print(f"  Result: Success! Page [{i}] should now have a RED border.")
                except Exception as e:
                    # If this fails, Playwright has the page object but cannot communicate with it
                    error_msg = str(e).splitlines()[0]
                    print(f"  Result: FAILED to inject JS -> {error_msg}")

            # Alert if there is a mismatch between your manual tabs and Playwright's list
            # For example, if you opened 4 tabs but only 2 are listed.
            if len(detected_pages) < 4:
                print(f"\n[!!!] DISCOVERY: Playwright is missing {4 - len(detected_pages)} page(s)!")

        except Exception as e:
            print(f"Critical Connection Error: {e}")

if __name__ == "__main__":
    diagnostic_border_test()

[dgozman]

@Hmily88 Thank you for the updated script, but I still cannot reproduce. As I said before, this is most likely related to something specific to your computer, like browser policies, extensions or something similar.