feat: add multi-tab support to remote browser

backend/app/services/browser_session_service.py

@@ -24,18 +24,35 @@ class BrowserSessionError(RuntimeError):
     """Raised when an existing browser session can no longer be used."""
 
 
+@dataclass
+class BrowserTab:
+    id: str
+    page: Any
+    created_at: float
+
+
 @dataclass
 class BrowserSession:
     id: str
     custom_page_id: int
     profile_key: str
     context: Any
-    page: Any
+    tabs: dict[str, BrowserTab]
+    active_tab_id: str
     lock: asyncio.Lock
+    tab_revision: int = 0
     cdp_session: Any = None
     captured_headers: list[dict] = None  # auth headers from CDP
     last_saved_state_at: float = 0.0
 
+    @property
+    def active_tab(self) -> BrowserTab:
+        return self.tabs[self.active_tab_id]
+
+    @property
+    def page(self) -> Any:
+        return self.active_tab.page
+
 
 class BrowserSessionService:
     # Idle TTL: close sessions that haven't had activity for this long
@@ -110,17 +127,22 @@ class BrowserSessionService:
             except Exception:
                 logger.debug("clipboard permission grant failed (non-fatal)")
             page = context.pages[0] if context.pages else await context.new_page()
+            tab_id = uuid4().hex
+            tab = BrowserTab(id=tab_id, page=page, created_at=asyncio.get_event_loop().time())
             session = BrowserSession(
                 id=uuid4().hex,
                 custom_page_id=custom_page_id,
                 profile_key=profile_key,
                 context=context,
-                page=page,
+                tabs={tab_id: tab},
+                active_tab_id=tab_id,
                 lock=asyncio.Lock(),
             )
             self._sessions[session.id] = session
             self._profiles[profile_key] = session.id
             self._touch(session.id)
+            # Register page capture for multi-tab support
+            context.on("page", lambda p: self._handle_new_page(session, p))
             # Evict again after adding the new session so cap is enforced immediately
             await self._evict_idle_sessions()
         try:
@@ -136,6 +158,33 @@ class BrowserSessionService:
         """Mark a session as recently active (reset idle timer)."""
         self._last_event_at[session_id] = asyncio.get_event_loop().time()
 
+    def _handle_new_page(self, session: BrowserSession, page: Any) -> None:
+        """Capture a new page opened by the remote browser (e.g. target="_blank")."""
+        tab_id = uuid4().hex
+        tab = BrowserTab(id=tab_id, page=page, created_at=asyncio.get_event_loop().time())
+        session.tabs[tab_id] = tab
+        session.active_tab_id = tab_id
+        session.tab_revision += 1
+        logger.info("session %s: captured new tab %s (total: %d)", session.id[:12], tab_id[:8], len(session.tabs))
+        # Best-effort: bring to front and reset zoom
+        asyncio.create_task(self._init_new_tab(session, tab))
+
+    async def _init_new_tab(self, session: BrowserSession, tab: BrowserTab) -> None:
+        try:
+            await tab.page.bring_to_front()
+            await self._reset_page_zoom(session)
+            # Grant clipboard permission for the new page's origin if possible
+            try:
+                url = tab.page.url
+                if url.startswith("http"):
+                    parsed = urlparse(url)
+                    origin = f"{parsed.scheme}://{parsed.netloc}"
+                    await session.context.grant_permissions(["clipboard-read", "clipboard-write"], origin=origin)
+            except Exception:
+                pass
+        except Exception as exc:
+            logger.debug("new tab %s init failed: %s", tab.id[:8], exc)
+
     async def screenshot(self, session_id: str) -> bytes:
         session = self._get(session_id)
         self._touch(session_id)
@@ -309,12 +358,82 @@ class BrowserSessionService:
             self._ensure_open(session)
             return await self._session_state(session)
 
+    async def activate_tab(self, session_id: str, tab_id: str) -> dict[str, Any]:
+        session = self._get(session_id)
+        self._touch(session_id)
+        async with session.lock:
+            self._ensure_open(session)
+            if tab_id not in session.tabs:
+                raise KeyError("tab not found")
+            session.active_tab_id = tab_id
+            session.tab_revision += 1
+            await session.page.bring_to_front()
+            return await self._session_state(session)
+
+    async def close_tab(self, session_id: str, tab_id: str) -> dict[str, Any]:
+        session = self._get(session_id)
+        self._touch(session_id)
+        async with session.lock:
+            self._ensure_open(session)
+            if tab_id not in session.tabs:
+                raise KeyError("tab not found")
+            if len(session.tabs) <= 1:
+                raise ValueError("cannot close the last tab")
+            
+            tab = session.tabs.pop(tab_id)
+            try:
+                await tab.page.close()
+            except Exception:
+                pass
+            
+            if session.active_tab_id == tab_id:
+                # Pick the latest remaining tab
+                latest = max(session.tabs.values(), key=lambda t: t.created_at)
+                session.active_tab_id = latest.id
+                await session.page.bring_to_front()
+            
+            session.tab_revision += 1
+            return await self._session_state(session)
+
     async def _session_state(self, session: BrowserSession) -> dict[str, Any]:
+        tabs = []
+        # We might need to prune closed pages during state generation too
+        closed_ids = []
+        for tid, tab in session.tabs.items():
+            if tab.page.is_closed():
+                closed_ids.append(tid)
+                continue
+            try:
+                title = await tab.page.title()
+                url = tab.page.url
+            except Exception:
+                title, url = "Loading...", "about:blank"
+            tabs.append({
+                "id": tid,
+                "title": title,
+                "url": url,
+                "created_at": tab.created_at,
+            })
+        
+        if closed_ids:
+            for cid in closed_ids:
+                session.tabs.pop(cid, None)
+            if not session.tabs:
+                raise BrowserSessionError("all browser pages are closed")
+            if session.active_tab_id in closed_ids:
+                latest = max(session.tabs.values(), key=lambda t: t.created_at)
+                session.active_tab_id = latest.id
+            session.tab_revision += 1
+
+        tabs.sort(key=lambda x: x["created_at"])
         return {
             "id": session.id,
             "custom_page_id": session.custom_page_id,
             "url": session.page.url,
             "title": await session.page.title(),
+            "active_tab_id": session.active_tab_id,
+            "tabs": tabs,
+            "tab_revision": session.tab_revision,
         }
 
     async def _ensure_playwright(self) -> None:
@@ -470,9 +589,18 @@ class BrowserSessionService:
     _get = get_session  # alias for internal use
 
     def _ensure_open(self, session: BrowserSession) -> None:
-        if session.page.is_closed():
-            self._discard_session(session.id)
-            raise BrowserSessionError("browser page is closed")
+        if session.active_tab.page.is_closed():
+            # Current tab closed? Try to cleanup and find another one
+            session.tabs.pop(session.active_tab_id, None)
+            if session.tabs:
+                # Pick the latest created tab
+                latest = max(session.tabs.values(), key=lambda t: t.created_at)
+                session.active_tab_id = latest.id
+                session.tab_revision += 1
+                logger.info("active tab closed, switched to %s", latest.id[:8])
+            else:
+                self._discard_session(session.id)
+                raise BrowserSessionError("all browser pages are closed")
 
     def _discard_session(self, session_id: str) -> BrowserSession | None:
         session = self._sessions.pop(session_id, None)
@@ -592,17 +720,22 @@ class BrowserSessionService:
             except Exception:
                 logger.debug("clipboard permission grant failed (non-fatal)")
             page = context.pages[0] if context.pages else await context.new_page()
+            tab_id = uuid4().hex
+            tab = BrowserTab(id=tab_id, page=page, created_at=asyncio.get_event_loop().time())
             session = BrowserSession(
                 id=session_id,
                 custom_page_id=0,
                 profile_key=profile_key,
                 context=context,
-                page=page,
+                tabs={tab_id: tab},
+                active_tab_id=tab_id,
                 lock=asyncio.Lock(),
                 captured_headers=[],
             )
             self._sessions[session.id] = session
             self._touch(session.id)
+            # Register page capture
+            context.on("page", lambda p: self._handle_new_page(session, p))
         # Start CDP network capture BEFORE the initial page load,
         # so we capture login redirects and auth headers from the start.
         await self._start_cdp_capture(session)