browser_supervisor_frames.py 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166
  1. """Frame / OOPIF target tracking half of the CDP supervisor.
  2. Maintains ``CDPSupervisor._frames`` from ``Page.frame*`` and ``Target.*``
  3. events and renders the bounded ``frame_tree`` snapshot payload. ``FrameInfo``
  4. entries for OOPIFs carry the child CDP session id so ``browser_cdp(frame_id=)``
  5. can route calls into the iframe over the supervisor's live socket.
  6. """
  7. from __future__ import annotations
  8. import asyncio
  9. import logging
  10. from dataclasses import dataclass, replace
  11. from typing import Any, Callable, Dict, List, Optional, Tuple
  12. # Logger-name parity with the origin module (records must look unchanged).
  13. logger = logging.getLogger("tools.browser_supervisor")
  14. # Snapshot caps for frame_tree — keep payloads bounded on ad-heavy pages.
  15. FRAME_TREE_MAX_ENTRIES = 30
  16. FRAME_TREE_MAX_OOPIF_DEPTH = 2
  17. _AUTO_ATTACH_PARAMS = {"autoAttach": True, "waitForDebuggerOnStart": False, "flatten": True}
  18. @dataclass
  19. class FrameInfo:
  20. """One frame in the page's frame tree. ``is_oopif`` frames have their own CDP
  21. target (reachable via ``cdp_session_id``); same-origin / srcdoc iframes share
  22. the parent process (``is_oopif=False``, ``cdp_session_id=None``)."""
  23. frame_id: str
  24. url: str
  25. origin: str
  26. parent_frame_id: Optional[str]
  27. is_oopif: bool
  28. cdp_session_id: Optional[str] = None
  29. name: str = ""
  30. def to_dict(self) -> dict[str, Any]:
  31. d = {"frame_id": self.frame_id, "url": self.url, "origin": self.origin, "is_oopif": self.is_oopif}
  32. optional = (("session_id", self.cdp_session_id), ("parent_frame_id", self.parent_frame_id), ("name", self.name))
  33. d.update({k: v for k, v in optional if v})
  34. return d
  35. class FrameTrackingMixin:
  36. """Frame-tree bookkeeping for ``CDPSupervisor`` (event handlers run on its loop)."""
  37. async def _enable_page_domains(self, session_id: Optional[str], *, timeout: float) -> None:
  38. """Page.enable + Runtime.enable + nested auto-attach on one session."""
  39. await self._cdp("Page.enable", session_id=session_id, timeout=timeout)
  40. await self._cdp("Runtime.enable", session_id=session_id, timeout=timeout)
  41. await self._cdp("Target.setAutoAttach", _AUTO_ATTACH_PARAMS, session_id=session_id, timeout=timeout)
  42. def _on_frame_attached(self, params: dict[str, Any], session_id: Optional[str]) -> None:
  43. frame_id = params.get("frameId")
  44. if frame_id:
  45. self._set_frame(FrameInfo(frame_id=frame_id, url="", origin="", parent_frame_id=params.get("parentFrameId"),
  46. is_oopif=False, cdp_session_id=session_id))
  47. def _set_frame(self, frame: FrameInfo) -> None:
  48. with self._state_lock:
  49. self._frames[frame.frame_id] = frame
  50. def _on_frame_navigated(self, params: dict[str, Any], session_id: Optional[str]) -> None:
  51. frame = params.get("frame") or {}
  52. frame_id = frame.get("id")
  53. if not frame_id:
  54. return
  55. with self._state_lock:
  56. old = self._frames.get(frame_id) or FrameInfo(frame_id, "", "", None, False, session_id)
  57. self._frames[frame_id] = FrameInfo(
  58. frame_id=frame_id, url=str(frame.get("url") or ""),
  59. origin=str(frame.get("securityOrigin") or frame.get("origin") or ""),
  60. parent_frame_id=frame.get("parentId") or old.parent_frame_id, is_oopif=old.is_oopif,
  61. cdp_session_id=old.cdp_session_id, name=str(frame.get("name") or old.name),
  62. )
  63. def _on_frame_detached(self, params: dict[str, Any], session_id: Optional[str]) -> None:
  64. """Drop a frame only when it's truly gone. ``reason="swap"`` = migrating processes
  65. (e.g. promoted to an OOPIF) — dropping would hide the iframe. Even with ``remove``
  66. the parent only knows the child left ITS process; a live child session means it's
  67. still alive, so keep it until Target.detached + a later frameDetached clear it."""
  68. frame_id = params.get("frameId")
  69. if not frame_id or str(params.get("reason") or "remove").lower() == "swap":
  70. return
  71. with self._state_lock:
  72. old = self._frames.get(frame_id)
  73. if not (old and old.is_oopif and old.cdp_session_id):
  74. self._frames.pop(frame_id, None)
  75. async def _on_target_attached(self, params: dict[str, Any], session_id: Optional[str] = None) -> None:
  76. info = params.get("targetInfo") or {}
  77. sid = params.get("sessionId")
  78. target_type = info.get("type")
  79. if not sid or target_type not in {"iframe", "worker"}:
  80. return
  81. if target_type == "iframe":
  82. # Record the frame with its OOPIF session id for interaction routing;
  83. # origin is filled by frameNavigated on the child session.
  84. target_id = info.get("targetId")
  85. with self._state_lock:
  86. old = self._frames.get(target_id)
  87. self._frames[target_id] = FrameInfo(
  88. frame_id=target_id, url=str(info.get("url") or ""), origin="", is_oopif=True, cdp_session_id=sid,
  89. parent_frame_id=old.parent_frame_id if old else None, name=str(info.get("title") or (old.name if old else "")),
  90. )
  91. # Enable child domains off-loop: awaiting the replies here would deadlock
  92. # because only the reader can resolve those Futures.
  93. asyncio.create_task(self._enable_child_domains(sid))
  94. async def _enable_child_domains(self, sid: str) -> None:
  95. """Enable Page+Runtime (+nested setAutoAttach) and the dialog bridge on a child session."""
  96. try:
  97. await self._enable_page_domains(sid, timeout=3.0)
  98. except Exception as e:
  99. logger.debug("child session %s setup failed: %s", sid[:16], e)
  100. await self._install_dialog_bridge(sid)
  101. def _on_target_detached(self, params: dict[str, Any], session_id: Optional[str] = None) -> None:
  102. """Clear the session binding of frames on a detached child session. Frames are
  103. deliberately NOT dropped: Browserbase fires transient detaches during page transitions
  104. while the iframe is still visible; ``Page.frameDetached`` cleans up if it truly goes away."""
  105. sid = params.get("sessionId")
  106. if not sid:
  107. return
  108. with self._state_lock:
  109. self._frames.update({fid: replace(f, cdp_session_id=None) for fid, f in self._frames.items()
  110. if f.cdp_session_id == sid})
  111. def _build_frame_tree_locked(self) -> dict[str, Any]:
  112. """Capped frame_tree payload (must hold state lock). Top frame = one with
  113. no parent, preferring oopif=False; BFS from it, capped by
  114. FRAME_TREE_MAX_ENTRIES and FRAME_TREE_MAX_OOPIF_DEPTH for OOPIF branches."""
  115. frames = self._frames
  116. tops = [f for f in frames.values() if not f.parent_frame_id]
  117. top = next((f for f in tops if not f.is_oopif), tops[0] if tops else None)
  118. if top is None:
  119. return {"top": None, "children": [], "truncated": False}
  120. children: list[dict[str, Any]] = []
  121. truncated = False
  122. queue: list[tuple[FrameInfo, int]] = [(f, 1) for f in frames.values() if f.parent_frame_id == top.frame_id]
  123. visited = {top.frame_id}
  124. while queue and len(children) < FRAME_TREE_MAX_ENTRIES:
  125. frame, depth = queue.pop(0)
  126. if frame.frame_id in visited:
  127. continue
  128. visited.add(frame.frame_id)
  129. if frame.is_oopif and depth > FRAME_TREE_MAX_OOPIF_DEPTH:
  130. truncated = True
  131. continue
  132. children.append(frame.to_dict())
  133. queue.extend((f, depth + 1) for f in frames.values()
  134. if f.parent_frame_id == frame.frame_id and f.frame_id not in visited)
  135. return {"top": top.to_dict(), "children": children, "truncated": truncated or bool(queue)}
  136. # CDP event → handler(self, params, session_id); merged into CDPSupervisor._EVENT_HANDLERS.
  137. EVENT_HANDLERS: dict[str, Callable[..., Any]] = {
  138. "Page.frameAttached": _on_frame_attached,
  139. "Page.frameNavigated": _on_frame_navigated,
  140. "Page.frameDetached": _on_frame_detached,
  141. "Target.attachedToTarget": _on_target_attached,
  142. "Target.detachedFromTarget": _on_target_detached,
  143. }