browser.py

"""
Persistent CDP Client — HTTP API for browser control.

Single entry point for the Agent CDP Relay stack. Running `python browser.py`
will auto-start the relay server and Chrome (with extension) if they aren't
already running, then serve the HTTP API on port 9223.

Usage:
    python browser.py                 # start everything, serve API
    requests.get("http://localhost:9223/tabs")
    requests.post("http://localhost:9223/eval", json={"js": "document.title"})
"""

import asyncio
import json
import logging
import os
import subprocess
import sys
import time
import base64
from pathlib import Path

if sys.platform == "win32":
    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
    sys.stderr.reconfigure(encoding="utf-8", errors="replace")

from aiohttp import WSMsgType, web
import aiohttp
import requests as http_requests  # sync requests for startup checks

log = logging.getLogger("browser")
log.setLevel(logging.DEBUG)
_h = logging.StreamHandler()
_h.setFormatter(logging.Formatter("%(asctime)s %(message)s", datefmt="%H:%M:%S"))
log.addHandler(_h)

# ── Paths & config ────────────────────────────────────────────────────

HERE = Path(__file__).parent
RELAY_SCRIPT = HERE / "relay.py"
EXTENSION_DIR = HERE / "extension"

RELAY_HOST = "127.0.0.1"
RELAY_PORT = 9222
RELAY_URL = f"http://{RELAY_HOST}:{RELAY_PORT}"
RELAY_WS = f"ws://{RELAY_HOST}:{RELAY_PORT}/devtools/browser"

API_PORT = 9223

CHROME_PATHS = [
    # Windows
    r"C:\Program Files\Google\Chrome\Application\chrome.exe",
    r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
    os.path.expandvars(r"%LOCALAPPDATA%\Google\Chrome\Application\chrome.exe"),
    # macOS
    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
    # Linux
    "/usr/bin/google-chrome",
    "/usr/bin/google-chrome-stable",
    "/usr/bin/chromium-browser",
    "/usr/bin/chromium",
]

_relay_proc = None
_chrome_proc = None


# ── Stack bootstrap ───────────────────────────────────────────────────

def find_chrome() -> str:
    """Find the Chrome binary on this system."""
    for path in CHROME_PATHS:
        if os.path.isfile(path):
            return path
    raise FileNotFoundError(
        "Chrome not found. Searched:\n  " + "\n  ".join(CHROME_PATHS)
    )


def is_relay_alive() -> bool:
    try:
        r = http_requests.get(f"{RELAY_URL}/json/version", timeout=2)
        return r.status_code == 200
    except Exception:
        return False


def is_extension_connected() -> bool:
    try:
        r = http_requests.get(f"{RELAY_URL}/json/version", timeout=2)
        return r.status_code == 200 and r.json().get("extensionConnected", False)
    except Exception:
        return False


def ensure_relay():
    """Start the relay server if it isn't already running."""
    global _relay_proc
    if is_relay_alive():
        log.info("Relay already running on port %d", RELAY_PORT)
        return

    log.info("Starting relay server...")
    _relay_proc = subprocess.Popen(
        [sys.executable, str(RELAY_SCRIPT)],
        cwd=str(HERE),
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0,
    )

    for _ in range(20):
        time.sleep(0.5)
        if is_relay_alive():
            log.info("Relay server ready on port %d", RELAY_PORT)
            return
        if _relay_proc.poll() is not None:
            out = _relay_proc.stdout.read().decode("utf-8", errors="replace")
            raise RuntimeError(f"Relay exited unexpectedly:\n{out}")

    raise TimeoutError("Relay did not start within 10 seconds")


def ensure_chrome():
    """Launch Chrome with the extension if no extension is connected."""
    global _chrome_proc
    if is_extension_connected():
        log.info("Extension already connected")
        return

    chrome = find_chrome()
    log.info("Launching Chrome: %s", chrome)

    # Patch preferences to suppress "Chrome didn't shut down correctly" bar
    try:
        pref_path = os.path.expandvars(
            r"%LOCALAPPDATA%\Google\Chrome\User Data\Default\Preferences"
        )
        if os.path.isfile(pref_path):
            with open(pref_path, "r", encoding="utf-8") as f:
                prefs = json.load(f)
            prefs.setdefault("profile", {})["exit_type"] = "Normal"
            prefs["profile"]["exited_cleanly"] = True
            with open(pref_path, "w", encoding="utf-8") as f:
                json.dump(prefs, f)
    except Exception:
        pass  # non-critical

    _chrome_proc = subprocess.Popen(
        [
            chrome,
            f"--load-extension={EXTENSION_DIR}",
            "--disable-session-crashed-bubble",
            "--hide-crash-restore-bubble",
            "--profile-directory=Default",
        ],
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL,
        creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0,
    )

    log.info("Waiting for extension to connect...")
    for i in range(30):
        time.sleep(1)
        if is_extension_connected():
            log.info("Extension connected")
            return

    raise TimeoutError(
        "Extension did not connect within 30 seconds.\n"
        "Check that the extension is enabled in chrome://extensions"
    )


def bootstrap():
    """Ensure the full stack is running: relay → Chrome → extension."""
    ensure_relay()
    ensure_chrome()


class BrowserClient:
    def __init__(self):
        self.ws = None
        self.cmd_id = 1
        self.pending = {}  # cmd_id -> Future
        self.session_id = None  # current attached session
        self.target_id = None  # current attached tab
        self._event_log = []  # last N events for debugging
        self._reader_task = None

    async def connect(self):
        """Connect to the relay WebSocket."""
        session = aiohttp.ClientSession()
        self.ws = await session.ws_connect(RELAY_WS, heartbeat=20)
        self._reader_task = asyncio.create_task(self._read_loop())
        log.info("Connected to relay")

    async def _read_loop(self):
        """Background task reading WebSocket messages."""
        async for msg in self.ws:
            if msg.type == WSMsgType.TEXT:
                data = json.loads(msg.data)
                cmd_id = data.get("id")
                if cmd_id is not None and cmd_id in self.pending:
                    self.pending[cmd_id].set_result(data)
                else:
                    # It's an event
                    self._event_log.append(data)
                    if len(self._event_log) > 100:
                        self._event_log = self._event_log[-50:]
            elif msg.type in (WSMsgType.ERROR, WSMsgType.CLOSED):
                break
        log.warning("WebSocket read loop ended")

    async def cdp(self, method, params=None, session_id=None):
        """Send a CDP command and wait for the response."""
        msg = {"id": self.cmd_id, "method": method, "params": params or {}}
        if session_id:
            msg["sessionId"] = session_id
        elif self.session_id and session_id is not False:
            msg["sessionId"] = self.session_id

        future = asyncio.get_event_loop().create_future()
        self.pending[self.cmd_id] = future
        self.cmd_id += 1

        await self.ws.send_json(msg)
        try:
            result = await asyncio.wait_for(future, timeout=30)
        finally:
            self.pending.pop(msg["id"], None)
        return result

    async def evaluate(self, js, session_id=None):
        """Evaluate JavaScript in the current session."""
        sid = session_id or self.session_id
        if not sid:
            return {"error": "No session attached. Use /attach first."}
        resp = await self.cdp(
            "Runtime.evaluate",
            {"expression": js, "awaitPromise": True, "returnByValue": True},
            session_id=sid,
        )
        result = resp.get("result", {}).get("result", {})
        if "error" in resp:
            return {"error": resp["error"]}
        return {"value": result.get("value"), "type": result.get("type")}


# ── HTTP API ──────────────────────────────────────────────────────────

def build_app(client: BrowserClient):
    app = web.Application()

    MARKER_JS = """(function() {
        var M = "\\uD83D\\uDD34 ";
        if (!document.title.startsWith(M)) document.title = M + document.title;
        if (!window.__agentMarkerObserver) {
            var titleEl = document.querySelector('title');
            if (titleEl) {
                window.__agentMarkerObserver = new MutationObserver(function() {
                    if (!document.title.startsWith(M)) document.title = M + document.title;
                });
                window.__agentMarkerObserver.observe(titleEl, { childList: true, characterData: true, subtree: true });
            }
        }
    })()"""

    async def inject_marker():
        """Inject 🔴 tab marker. Best-effort, ignores errors."""
        if client.session_id:
            try:
                await client.evaluate(MARKER_JS)
            except Exception:
                pass

    async def _inject_marker_after_load():
        """Wait for page to reach readyState=complete, then inject marker."""
        try:
            for _ in range(30):
                await asyncio.sleep(1)
                if not client.session_id:
                    return
                r = await client.evaluate("document.readyState")
                if r.get("value") in ("complete", "interactive"):
                    break
            await inject_marker()
        except Exception:
            pass

    async def handle_status(request):
        """GET /status — connection status."""
        return web.json_response({
            "connected": client.ws is not None and not client.ws.closed,
            "session_id": client.session_id,
            "target_id": client.target_id,
        })

    async def handle_tabs(request):
        """GET /tabs — list browser tabs."""
        resp = await client.cdp("Target.getTargets", session_id=False)
        targets = resp.get("result", {}).get("targetInfos", [])
        return web.json_response([
            {"id": t["targetId"], "title": t.get("title", ""), "url": t.get("url", "")}
            for t in targets
            if t.get("type") == "page"
        ])

    async def handle_navigate(request):
        """POST /navigate {"url": "..."} — open a new tab or navigate current."""
        body = await request.json()
        url = body.get("url", "about:blank")

        if body.get("new_tab", True) or not client.session_id:
            # Create new tab
            resp = await client.cdp("Target.createTarget", {"url": url}, session_id=False)
            target_id = resp.get("result", {}).get("targetId")
            if not target_id:
                return web.json_response({"error": "Failed to create tab", "detail": resp}, status=500)

            # Auto-attach
            resp = await client.cdp(
                "Target.attachToTarget",
                {"targetId": target_id, "flatten": True},
                session_id=False,
            )
            sid = resp.get("result", {}).get("sessionId")
            client.session_id = sid
            client.target_id = target_id
            # Wait briefly for page load, then inject marker
            asyncio.ensure_future(_inject_marker_after_load())
            return web.json_response({"target_id": target_id, "session_id": sid, "url": url})
        else:
            # Navigate existing tab
            resp = await client.cdp("Page.navigate", {"url": url})
            return web.json_response({"result": resp.get("result", {})})

    async def handle_attach(request):
        """POST /attach {"target_id": "..."} — attach to an existing tab."""
        body = await request.json()
        target_id = body["target_id"]
        resp = await client.cdp(
            "Target.attachToTarget",
            {"targetId": target_id, "flatten": True},
            session_id=False,
        )
        sid = resp.get("result", {}).get("sessionId")
        if sid:
            client.session_id = sid
            client.target_id = target_id
            await inject_marker()
        return web.json_response({"session_id": sid, "target_id": target_id})

    async def handle_eval(request):
        """POST /eval {"js": "..."} — evaluate JavaScript in current tab."""
        body = await request.json()
        js = body.get("js") or body.get("expression", "")
        result = await client.evaluate(js)
        return web.json_response(result)

    async def handle_click(request):
        """POST /click {"selector": "..."} — click an element."""
        body = await request.json()
        selector = body["selector"]
        js = f"""
            (function() {{
                var el = document.querySelector({json.dumps(selector)});
                if (!el) return 'NOT_FOUND: ' + {json.dumps(selector)};
                el.scrollIntoView({{block: 'center'}});
                el.click();
                return 'clicked';
            }})()
        """
        result = await client.evaluate(js)
        return web.json_response(result)

    async def handle_type(request):
        """POST /type {"selector": "...", "text": "...", "clear?": true, "submit?": true}
        Type text into an element. Works with plain inputs, React/Vue controlled
        components, and contenteditable elements."""
        body = await request.json()
        selector = body["selector"]
        text = body["text"]
        submit = body.get("submit", False)
        clear = body.get("clear", True)  # clear existing value by default
        js = f"""
            (function() {{
                var el = document.querySelector({json.dumps(selector)});
                if (!el) return JSON.stringify({{value: 'NOT_FOUND', selector: {json.dumps(selector)}}});
                el.scrollIntoView({{block: 'center'}});
                el.focus();
                el.dispatchEvent(new Event('focus', {{bubbles: true}}));

                var tag = el.tagName;
                if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') {{
                    // Use nativeInputValueSetter to bypass React's internal value tracking
                    var proto = tag === 'TEXTAREA'
                        ? Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')
                        : Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value');
                    var newVal = {json.dumps(clear)} ? {json.dumps(text)} : (el.value + {json.dumps(text)});
                    if (proto && proto.set) {{
                        proto.set.call(el, newVal);
                    }} else {{
                        el.value = newVal;
                    }}
                    // Fire the full event sequence React/Vue/Angular listen for
                    el.dispatchEvent(new Event('input', {{bubbles: true}}));
                    el.dispatchEvent(new Event('change', {{bubbles: true}}));
                    return JSON.stringify({{value: 'typed', method: 'nativeSetter'}});

                }} else if (el.contentEditable === 'true' || el.getAttribute('contenteditable') !== null) {{
                    // contenteditable — used by ChatGPT, Notion, etc.
                    if ({json.dumps(clear)}) {{
                        el.innerHTML = '';
                    }}
                    // Use insertText command which triggers all framework event handlers
                    document.execCommand('insertText', false, {json.dumps(text)});
                    // Fallback if execCommand didn't work (deprecated in some browsers)
                    if (!el.textContent.includes({json.dumps(text[:20] if len(text) > 20 else text)})) {{
                        el.innerHTML += '<p>' + {json.dumps(text)} + '</p>';
                        el.dispatchEvent(new Event('input', {{bubbles: true}}));
                    }}
                    return JSON.stringify({{value: 'typed', method: 'contentEditable'}});
                }} else {{
                    return JSON.stringify({{value: 'NOT_EDITABLE', tag: tag}});
                }}
            }})()
        """
        result = await client.evaluate(js)
        # Parse the JSON string result
        val = result.get("value")
        if isinstance(val, str):
            try:
                result = json.loads(val)
            except json.JSONDecodeError:
                pass

        if submit and result.get("value") == "typed":
            await asyncio.sleep(0.3)
            submit_js = """
                (function() {
                    var btn = document.querySelector('button[data-testid="send-button"]')
                        || document.querySelector('button[type="submit"]')
                        || document.querySelector('form button:last-of-type');
                    if (btn && !btn.disabled) { btn.click(); return 'submitted'; }
                    // Try pressing Enter on the focused element as fallback
                    var active = document.activeElement;
                    if (active) {
                        active.dispatchEvent(new KeyboardEvent('keydown', {key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true}));
                        active.dispatchEvent(new KeyboardEvent('keypress', {key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true}));
                        active.dispatchEvent(new KeyboardEvent('keyup', {key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true}));
                        return 'submitted_enter';
                    }
                    return 'no submit button';
                })()
            """
            submit_result = await client.evaluate(submit_js)
            result["submit"] = submit_result.get("value")

        return web.json_response(result)

    async def handle_screenshot(request):
        """GET /screenshot — capture screenshot. ?format=file saves to temp file."""
        if not client.session_id:
            return web.json_response({"error": "No session attached"}, status=400)
        resp = await client.cdp("Page.captureScreenshot", {"format": "png"})
        data = resp.get("result", {}).get("data", "")
        if request.query.get("format") == "file" or request.path == "/screenshot/file":
            import tempfile, os
            path = os.path.join(tempfile.gettempdir(), "screenshot.png")
            with open(path, "wb") as f:
                f.write(base64.b64decode(data))
            return web.json_response({"path": path})
        return web.json_response({"data_length": len(data), "data": data[:100] + "..."})

    async def handle_text(request):
        """GET /text — get visible text content of the page."""
        result = await client.evaluate("document.body.innerText")
        return web.json_response(result)

    async def handle_url(request):
        """GET /url — get current page URL."""
        result = await client.evaluate("window.location.href")
        return web.json_response(result)

    async def handle_title(request):
        """GET /title — get current page title."""
        result = await client.evaluate("document.title")
        return web.json_response(result)

    async def handle_cdp_raw(request):
        """POST /cdp {"method": "...", "params": {...}} — raw CDP command."""
        body = await request.json()
        method = body["method"]
        params = body.get("params", {})
        use_session = body.get("session", True)
        sid = client.session_id if use_session else False
        resp = await client.cdp(method, params, session_id=sid)
        return web.json_response(resp)

    async def handle_detach(request):
        """POST /detach — detach debugger from current tab (keeps tab open)."""
        if not client.session_id:
            return web.json_response({"error": "No session attached"}, status=400)
        sid = client.session_id
        tid = client.target_id
        # Remove 🔴 marker while we still have a live session
        try:
            await client.evaluate("""(function() {
                var M = "\\uD83D\\uDD34 ";
                if (window.__agentMarkerObserver) {
                    window.__agentMarkerObserver.disconnect();
                    delete window.__agentMarkerObserver;
                }
                if (document.title.startsWith(M)) document.title = document.title.slice(M.length);
            })()""")
        except Exception:
            pass  # best-effort
        resp = await client.cdp(
            "Target.detachFromTarget",
            {"sessionId": sid},
            session_id=False,
        )
        client.session_id = None
        client.target_id = None
        return web.json_response({"detached": tid, "session_id": sid})

    async def handle_close(request):
        """POST /close {"target_id": "..."} — close a tab."""
        body = await request.json()
        tid = body.get("target_id", client.target_id)
        resp = await client.cdp("Target.closeTarget", {"targetId": tid}, session_id=False)
        if tid == client.target_id:
            client.session_id = None
            client.target_id = None
        return web.json_response(resp.get("result", {}))

    async def handle_observe(request):
        """POST /observe — inject MutationObserver into current page for DOM awareness."""
        if not client.session_id:
            return web.json_response({"error": "No session attached"}, status=400)
        observer_js = """
        (function() {
            if (window.__agentObserver) {
                return 'already_active (events: ' + window.__agentEvents.length + ')';
            }
            window.__agentEvents = [];
            var MAX = 200;

            function classify(el) {
                var tag = el.tagName ? el.tagName.toLowerCase() : '';
                var role = el.getAttribute ? (el.getAttribute('role') || '') : '';
                var cls = el.className && typeof el.className === 'string' ? el.className : '';
                var aria = el.getAttribute ? (el.getAttribute('aria-label') || '') : '';
                var txt = (el.textContent || '').trim().substring(0, 150);

                // Dialogs and modals (ARIA roles + HTML5 dialog)
                if (role === 'dialog' || role === 'alertdialog' || tag === 'dialog')
                    return {type: 'dialog', tag: tag, role: role, text: txt};
                // Class-based popups, modals, toasts, overlays, banners
                if (cls.match(/modal|popup|overlay|toast|snackbar|banner|notification|drawer|dropdown-menu|lightbox/i))
                    return {type: 'overlay', tag: tag, class: cls.substring(0,100), text: txt};
                // ARIA live regions (screen reader announcements, status updates)
                if (el.getAttribute && (el.getAttribute('aria-live') || el.getAttribute('role') === 'status' || el.getAttribute('role') === 'alert'))
                    return {type: 'live-region', role: role || el.getAttribute('aria-live'), text: txt};
                // Forms that appear dynamically (login, signup, search)
                if (tag === 'form')
                    return {type: 'form', action: (el.action || '').substring(0,120), text: txt.substring(0,80)};
                // Iframes (embedded content, ads, auth flows)
                if (tag === 'iframe')
                    return {type: 'iframe', src: (el.src || '').substring(0, 150)};
                // Video/audio elements
                if (tag === 'video' || tag === 'audio')
                    return {type: 'media', tag: tag, src: (el.src || el.currentSrc || '').substring(0,120)};
                // Images (dynamically loaded content, generated images, thumbnails)
                if (tag === 'img' && el.src && !el.src.startsWith('data:image/svg'))
                    return {type: 'image', src: el.src.substring(0,200), alt: (el.alt || '').substring(0,100),
                            w: el.naturalWidth || el.width || 0, h: el.naturalHeight || el.height || 0};
                // Canvas elements (charts, drawings, generated graphics)
                if (tag === 'canvas')
                    return {type: 'canvas', w: el.width, h: el.height,
                            label: aria || (el.id ? '#'+el.id : '')};
                // SVG (icons, diagrams, vector graphics) — only substantial ones
                if (tag === 'svg' && (el.clientWidth > 48 || el.clientHeight > 48))
                    return {type: 'svg', w: el.clientWidth, h: el.clientHeight,
                            label: aria || ''};
                return null;
            }

            var INTERESTING = '[role="dialog"], [role="alertdialog"], [role="alert"], [role="status"], ' +
                '[aria-live], dialog, form, iframe, video, audio, img, canvas, svg, ' +
                '[class*="modal"], [class*="popup"], [class*="toast"], [class*="overlay"], ' +
                '[class*="snackbar"], [class*="banner"], [class*="notification"], ' +
                '[class*="drawer"], [class*="lightbox"]';

            window.__agentObserver = new MutationObserver(function(mutations) {
                for (var i = 0; i < mutations.length; i++) {
                    var m = mutations[i];
                    for (var j = 0; j < m.addedNodes.length; j++) {
                        var node = m.addedNodes[j];
                        if (node.nodeType !== 1) continue;
                        var info = classify(node);
                        if (info) {
                            info.time = Date.now();
                            info.action = 'added';
                            window.__agentEvents.push(info);
                        }
                        if (node.querySelectorAll) {
                            var children = node.querySelectorAll(INTERESTING);
                            for (var k = 0; k < children.length; k++) {
                                var ci = classify(children[k]);
                                if (ci) {
                                    ci.time = Date.now();
                                    ci.action = 'added';
                                    window.__agentEvents.push(ci);
                                }
                            }
                        }
                    }
                    for (var j2 = 0; j2 < m.removedNodes.length; j2++) {
                        var rnode = m.removedNodes[j2];
                        if (rnode.nodeType !== 1) continue;
                        var ri = classify(rnode);
                        if (ri) {
                            ri.time = Date.now();
                            ri.action = 'removed';
                            window.__agentEvents.push(ri);
                        }
                    }
                }
                if (window.__agentEvents.length > MAX) {
                    window.__agentEvents = window.__agentEvents.slice(-MAX);
                }
            });
            window.__agentObserver.observe(document.body, {
                childList: true, subtree: true
            });
            return 'observer_started';
        })()
        """
        result = await client.evaluate(observer_js)
        return web.json_response(result)

    async def handle_events(request):
        """GET /events — drain buffered DOM events from the MutationObserver."""
        if not client.session_id:
            return web.json_response({"error": "No session attached"}, status=400)
        drain_js = """
        (function() {
            if (!window.__agentEvents) return JSON.stringify({active: false, events: []});
            var evts = window.__agentEvents.splice(0, window.__agentEvents.length);
            return JSON.stringify({active: true, count: evts.length, events: evts});
        })()
        """
        result = await client.evaluate(drain_js)
        val = result.get("value")
        if isinstance(val, str):
            try:
                return web.json_response(json.loads(val))
            except json.JSONDecodeError:
                pass
        return web.json_response(result)

    async def handle_wait(request):
        """POST /wait {"selector": "...", "timeout": 5000, "visible?": true}
        Wait for a CSS selector to appear in the DOM. Polls every 200ms."""
        if not client.session_id:
            return web.json_response({"error": "No session attached"}, status=400)
        body = await request.json()
        selector = body["selector"]
        timeout_ms = body.get("timeout", 5000)
        check_visible = body.get("visible", False)
        interval = 0.2  # poll every 200ms
        elapsed = 0.0
        timeout_s = timeout_ms / 1000.0

        while elapsed < timeout_s:
            if check_visible:
                js = f"""(function() {{
                    var el = document.querySelector({json.dumps(selector)});
                    if (!el) return JSON.stringify({{found: false}});
                    var r = el.getBoundingClientRect();
                    var vis = r.width > 0 && r.height > 0 && getComputedStyle(el).visibility !== 'hidden';
                    return JSON.stringify({{found: true, visible: vis, tag: el.tagName, text: (el.textContent || '').trim().substring(0, 200)}});
                }})()"""
            else:
                js = f"""(function() {{
                    var el = document.querySelector({json.dumps(selector)});
                    if (!el) return JSON.stringify({{found: false}});
                    return JSON.stringify({{found: true, tag: el.tagName, text: (el.textContent || '').trim().substring(0, 200)}});
                }})()"""
            result = await client.evaluate(js)
            val = result.get("value")
            if isinstance(val, str):
                try:
                    parsed = json.loads(val)
                    if parsed.get("found"):
                        if check_visible and not parsed.get("visible"):
                            pass  # found but not visible yet, keep waiting
                        else:
                            parsed["elapsed_ms"] = int(elapsed * 1000)
                            return web.json_response(parsed)
                except json.JSONDecodeError:
                    pass
            await asyncio.sleep(interval)
            elapsed += interval

        return web.json_response({
            "found": False,
            "timeout": True,
            "elapsed_ms": int(elapsed * 1000),
            "selector": selector,
        })

    # Routes
    app.router.add_get("/status", handle_status)
    app.router.add_get("/tabs", handle_tabs)
    app.router.add_post("/navigate", handle_navigate)
    app.router.add_post("/attach", handle_attach)
    app.router.add_post("/eval", handle_eval)
    app.router.add_post("/click", handle_click)
    app.router.add_post("/type", handle_type)
    app.router.add_get("/screenshot", handle_screenshot)
    app.router.add_get("/screenshot/file", handle_screenshot)
    app.router.add_get("/text", handle_text)
    app.router.add_get("/url", handle_url)
    app.router.add_get("/title", handle_title)
    app.router.add_post("/cdp", handle_cdp_raw)
    app.router.add_post("/detach", handle_detach)
    app.router.add_post("/close", handle_close)
    app.router.add_post("/observe", handle_observe)
    app.router.add_get("/events", handle_events)
    app.router.add_post("/wait", handle_wait)

    return app


async def main():
    bootstrap()  # auto-start relay + Chrome if needed

    client = BrowserClient()
    await client.connect()

    # Clean orphaned 🔴 markers from any previous session
    try:
        resp = await client.cdp("Target.getTargets", session_id=False)
        targets = resp.get("result", {}).get("targetInfos", [])
        marker = "\U0001f534 "
        orphaned = [t for t in targets if t.get("type") == "page" and t.get("title", "").startswith(marker)]
        for t in orphaned:
            tid = t["targetId"]
            try:
                r = await client.cdp("Target.attachToTarget", {"targetId": tid, "flatten": True}, session_id=False)
                sid = r.get("result", {}).get("sessionId")
                if sid:
                    await client.cdp("Runtime.evaluate", {
                        "expression": '(function() { var M = "\\uD83D\\uDD34 "; if (window.__agentMarkerObserver) { window.__agentMarkerObserver.disconnect(); delete window.__agentMarkerObserver; } if (document.title.startsWith(M)) document.title = document.title.slice(M.length); })()',
                    }, session_id=sid)
                    await client.cdp("Target.detachFromTarget", {"sessionId": sid}, session_id=False)
                    log.info("Cleaned orphaned marker from tab %s (%s)", tid, t.get("title", "")[:60])
            except Exception:
                pass
    except Exception:
        pass

    app = build_app(client)
    runner = web.AppRunner(app)
    await runner.setup()
    site = web.TCPSite(runner, "127.0.0.1", API_PORT)
    await site.start()

    log.info("Browser API ready on http://127.0.0.1:%d", API_PORT)
    log.info("Endpoints: /status /tabs /navigate /attach /detach /eval /click /type /wait /screenshot /text /url /title /cdp /close /observe /events")

    # Keep running
    while True:
        await asyncio.sleep(3600)


if __name__ == "__main__":
    asyncio.run(main())