real-browser-cli 0.16.8__tar.gz → 0.16.9__tar.gz

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: real-browser-cli
-Version: 0.16.8
+Version: 0.16.9
 Summary: Control your real running browser from the terminal or Python SDK
 Project-URL: Homepage, https://git.yiprawr.dev/Automatisation/browser-cli
 Project-URL: Repository, https://git.yiprawr.dev/Automatisation/browser-cli
@@ -275,6 +275,21 @@ optional `tab_id` and act on the active tab when it is omitted, so a caller
 does not need a preceding `browser_tabs_list` round trip. `browser_tabs_close`
 reports the tab it closed.
 
+`browser_tabs_open` does not duplicate pages. It takes over an already-open tab
+whose URL is nearly the same and reports `reused` next to the tab metadata, so
+an agent that re-opens a page keeps working in the tab the user already has.
+The `reuse` argument selects the match:
+
+| `reuse` | Matches |
+|---------|---------|
+| `similar` (default) | Same site and page, ignoring fragment, trailing slash, query order, `www.` and default ports — plus any tab of the site when the requested URL is its root |
+| `exact` | Only a character-for-character identical URL |
+| `origin` | Any tab of the same site, whatever its path |
+| `none` | Never reuse, always open a new tab |
+
+A reused tab is only navigated when it is not already on the requested page, so
+no reload throws away page state.
+
 Available tools:
 - `browser_tabs_list`, `browser_tabs_open`, `browser_tabs_close`
 - `browser_navigate`, `browser_page_info`
@@ -340,6 +355,12 @@ browser-cli nav open https://example.com --focus            # bring opened tab/w
 browser-cli nav open https://example.com --window work      # into a named window
 browser-cli nav open https://example.com --group research   # into a tab group (name or ID)
 
+# Reuse an open tab instead of duplicating a page
+browser-cli nav open https://example.com/app --reuse         # nearly identical URL (fragment, trailing slash, query order, www)
+browser-cli nav open https://example.com/app --reuse-exact   # only a character-for-character match
+browser-cli nav open https://example.com/app --reuse-domain  # any tab of the same site
+browser-cli nav open https://example.com/app --reuse-title "App"  # tab whose title contains the text
+
 # Reload
 browser-cli nav reload                  # reload active tab
 browser-cli nav reload 1234             # reload tab by ID
@@ -552,6 +573,9 @@ b.nav.search("google", "python asyncio")
 tabs = b.tabs.list()          # list[Tab]; in multi-browser mode each tab.browser is set
 tab = b.tabs.open("https://example.com")              # returns a bound Tab object
 tab = b.tabs.open("https://example.com", wait=True, timeout=10)
+tab = b.tabs.open("https://example.com/app", reuse=True)   # reuse a tab with a nearly identical URL
+tab = b.tabs.open("https://example.com/app", reuse="origin")  # reuse any tab of that site
+existing = b.nav.reusable_tab("https://example.com/app", reuse=True)  # Tab or None, without touching the browser
 active = b.tabs.active()      # active Tab object
 tab = b.tabs.get(1234)        # tab by ID
 tab = b.tabs.first("github")  # first matching tab or None

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/README.md

@@ -179,6 +179,21 @@ optional `tab_id` and act on the active tab when it is omitted, so a caller
 does not need a preceding `browser_tabs_list` round trip. `browser_tabs_close`
 reports the tab it closed.
 
+`browser_tabs_open` does not duplicate pages. It takes over an already-open tab
+whose URL is nearly the same and reports `reused` next to the tab metadata, so
+an agent that re-opens a page keeps working in the tab the user already has.
+The `reuse` argument selects the match:
+
+| `reuse` | Matches |
+|---------|---------|
+| `similar` (default) | Same site and page, ignoring fragment, trailing slash, query order, `www.` and default ports — plus any tab of the site when the requested URL is its root |
+| `exact` | Only a character-for-character identical URL |
+| `origin` | Any tab of the same site, whatever its path |
+| `none` | Never reuse, always open a new tab |
+
+A reused tab is only navigated when it is not already on the requested page, so
+no reload throws away page state.
+
 Available tools:
 - `browser_tabs_list`, `browser_tabs_open`, `browser_tabs_close`
 - `browser_navigate`, `browser_page_info`
@@ -244,6 +259,12 @@ browser-cli nav open https://example.com --focus            # bring opened tab/w
 browser-cli nav open https://example.com --window work      # into a named window
 browser-cli nav open https://example.com --group research   # into a tab group (name or ID)
 
+# Reuse an open tab instead of duplicating a page
+browser-cli nav open https://example.com/app --reuse         # nearly identical URL (fragment, trailing slash, query order, www)
+browser-cli nav open https://example.com/app --reuse-exact   # only a character-for-character match
+browser-cli nav open https://example.com/app --reuse-domain  # any tab of the same site
+browser-cli nav open https://example.com/app --reuse-title "App"  # tab whose title contains the text
+
 # Reload
 browser-cli nav reload                  # reload active tab
 browser-cli nav reload 1234             # reload tab by ID
@@ -456,6 +477,9 @@ b.nav.search("google", "python asyncio")
 tabs = b.tabs.list()          # list[Tab]; in multi-browser mode each tab.browser is set
 tab = b.tabs.open("https://example.com")              # returns a bound Tab object
 tab = b.tabs.open("https://example.com", wait=True, timeout=10)
+tab = b.tabs.open("https://example.com/app", reuse=True)   # reuse a tab with a nearly identical URL
+tab = b.tabs.open("https://example.com/app", reuse="origin")  # reuse any tab of that site
+existing = b.nav.reusable_tab("https://example.com/app", reuse=True)  # Tab or None, without touching the browser
 active = b.tabs.active()      # active Tab object
 tab = b.tabs.get(1234)        # tab by ID
 tab = b.tabs.first("github")  # first matching tab or None

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/browser_cli/commands/navigate.py

@@ -13,13 +13,14 @@ def nav_group():
 @click.option("--focus", is_flag=True, help="Bring the opened tab/window to the front")
 @click.option("--window", "window_name", default=None, help="Open in named window")
 @click.option("--group", "group_name", default=None, help="Open directly into a tab group (name or ID)")
-@click.option("--reuse", is_flag=True, help="Reuse an existing tab with exactly this URL")
+@click.option("--reuse", is_flag=True, help="Reuse an existing tab with a nearly identical URL (ignores fragment, trailing slash, query order)")
+@click.option("--reuse-exact", is_flag=True, help="Reuse an existing tab only when its URL matches character for character")
 @click.option("--reuse-domain", is_flag=True, help="Reuse an existing tab with the same domain")
 @click.option("--reuse-title", default=None, metavar="TEXT", help="Reuse an existing tab whose title contains TEXT")
 @handle_errors
-def cmd_open(url, focus, window_name, group_name, reuse, reuse_domain, reuse_title):
+def cmd_open(url, focus, window_name, group_name, reuse, reuse_exact, reuse_domain, reuse_title):
     """Open URL in a new tab without stealing focus by default."""
-    client_from_ctx().nav.open(url, focus=focus, window=window_name, group=group_name, reuse=reuse, reuse_domain=reuse_domain, reuse_title=reuse_title)
+    client_from_ctx().nav.open(url, focus=focus, window=window_name, group=group_name, reuse="exact" if reuse_exact else reuse, reuse_domain=reuse_domain, reuse_title=reuse_title)
     suffix = ""
     if group_name:
         suffix = f" in group '{group_name}'"
@@ -76,13 +77,14 @@ def cmd_focus(pattern):
 @click.option("--focus", is_flag=True, help="Bring the opened tab/window to the front")
 @click.option("--window", "window_name", default=None, help="Open in named window")
 @click.option("--group", "group_name", default=None, help="Open in tab group")
-@click.option("--reuse", is_flag=True, help="Reuse an existing tab with exactly this URL")
+@click.option("--reuse", is_flag=True, help="Reuse an existing tab with a nearly identical URL (ignores fragment, trailing slash, query order)")
+@click.option("--reuse-exact", is_flag=True, help="Reuse an existing tab only when its URL matches character for character")
 @click.option("--reuse-domain", is_flag=True, help="Reuse an existing tab with the same domain")
 @click.option("--reuse-title", default=None, metavar="TEXT", help="Reuse an existing tab whose title contains TEXT")
 @handle_errors
-def cmd_open_wait(url, timeout, focus, window_name, group_name, reuse, reuse_domain, reuse_title):
+def cmd_open_wait(url, timeout, focus, window_name, group_name, reuse, reuse_exact, reuse_domain, reuse_title):
     """Open URL in a new tab and wait until fully loaded."""
-    tab = client_from_ctx().nav.open_wait(url, timeout=timeout, focus=focus, window=window_name, group=group_name, reuse=reuse, reuse_domain=reuse_domain, reuse_title=reuse_title)
+    tab = client_from_ctx().nav.open_wait(url, timeout=timeout, focus=focus, window=window_name, group=group_name, reuse="exact" if reuse_exact else reuse, reuse_domain=reuse_domain, reuse_title=reuse_title)
     console.print(f"[green]Loaded:[/green] {url}" + (f" — {tab.title}" if tab.title else ""))
 
 @nav_group.command("wait")

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/browser_cli/mcp/server.py

@@ -12,12 +12,12 @@ import json
 import os
 from collections.abc import Callable
 from typing import Any, Literal
-from urllib.parse import urlsplit
 
 from browser_cli import BrowserCLI
 from browser_cli.mcp.naming import resolve_tool_prefix, tool_name
 from browser_cli.mcp.serialization import structured
 from browser_cli.mcp.targets import resolve_tab_id
+from browser_cli.url_match import find_reusable_tab, needs_navigation, tab_id as read_tab_id, tab_url
 
 ClientFactory = Callable[..., BrowserCLI]
 
@@ -25,6 +25,11 @@ _SERVER_INSTRUCTIONS = """Control a real, user-visible browser through browser-c
 The server is stateless: pass browser, remote, and key on each tool call when a
 specific target is required. Tool calls affect the user's actual browser. Read
 current tabs/page state instead of assuming IDs or content from an earlier call.
+Reuse before opening: tabs_open takes over an already-open tab whose URL is
+nearly the same (same site and page, or any tab of that site when you ask for
+its root) and reports reused=true with that tab's ID. Pass reuse="none" only
+when a separate tab is really wanted, and reuse="origin" to take over any tab
+of the site. Use tabs_list(search=...) first when you want to pick the tab.
 """
 
 def _client(factory: ClientFactory, browser: str | None, remote: str | None, key: str | None) -> BrowserCLI:
@@ -74,7 +79,10 @@ def create_server(*, client_factory: ClientFactory = BrowserCLI, tool_prefix: st
     remote: str | None = None,
     key: str | None = None,
   ) -> list[dict[str, Any]]:
-    """List current tabs, optionally filtering by URL or title substring."""
+    """List current tabs, optionally filtering by URL or title substring.
+
+    Check this before opening anything so an already-open page gets reused.
+    """
     tabs = structured(_client(client_factory, browser, remote, key).tabs.list())
     if not search:
       return tabs
@@ -92,15 +100,29 @@ def create_server(*, client_factory: ClientFactory = BrowserCLI, tool_prefix: st
     timeout: float = 30.0,
     background: bool = False,
     focus: bool = False,
+    reuse: Literal["similar", "exact", "origin", "none"] = "similar",
     browser: str | None = None,
     remote: str | None = None,
     key: str | None = None,
   ) -> dict[str, Any]:
-    """Open a URL in a new real-browser tab and return its current metadata."""
-    tab = _client(client_factory, browser, remote, key).tabs.open(
-      url, wait=wait, timeout=timeout, background=background, focus=focus
-    )
-    return structured(tab)
+    """Open a URL in the real browser, reusing an already-open tab with a nearly identical URL.
+
+    Returns the tab metadata plus ``reused``. ``reuse`` selects the match:
+    ``similar`` (default: same site and page, or any tab of that site when the
+    requested URL is its root), ``exact``, ``origin`` (any tab of the site), or
+    ``none`` to always create a new tab.
+    """
+    client = _client(client_factory, browser, remote, key)
+    existing = find_reusable_tab(structured(client.tabs.list()), url, reuse)
+    if existing is not None:
+      target = read_tab_id(existing)
+      if needs_navigation(tab_url(existing), url):
+        client.nav.to(target, url)
+      if focus:
+        client.tabs.activate(target)
+      return {**structured(client.tabs.status(target)), "reused": True}
+    tab = client.tabs.open(url, wait=wait, timeout=timeout, background=background, focus=focus)
+    return {**structured(tab), "reused": False}
 
   @mcp.tool(name=tool_name("tabs_close", prefix))
   def tabs_close(

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/browser_cli/sdk/navigation.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 from browser_cli.models import Tab
 from browser_cli.sdk.base import Namespace, sdk_command
+from browser_cli.url_match import find_reusable_tab, needs_navigation, normalize_mode
 
 def _open_args(self, url, *, background=False, focus=False, window=None, group=None, **_ignored):
   return {"url": url, "background": background or not focus, "focus": focus, "window": window, "group": group}
@@ -21,18 +22,20 @@ class NavigationNS(Namespace):
     focus: bool = False,
     window: str | None = None,
     group: str | None = None,
-    reuse: bool = False,
+    reuse: bool | str = False,
     reuse_domain: bool = False,
     reuse_title: str | None = None,
   ) -> None:
     """Open *url* in a new tab without stealing OS focus by default.
 
     ``reuse``/``reuse_domain``/``reuse_title`` navigate an existing matching tab
-    instead of creating a new one.
+    instead of creating a new one. ``reuse=True`` matches nearly identical URLs;
+    pass ``reuse='exact'`` or ``reuse='origin'`` to tighten or widen that.
     """
-    tab = self._reuse_target(url, reuse=reuse, reuse_domain=reuse_domain, reuse_title=reuse_title)
+    tab = self.reusable_tab(url, reuse=reuse, reuse_domain=reuse_domain, reuse_title=reuse_title)
     if tab is not None:
-      self.to(tab.id, url)
+      if needs_navigation(tab.url, url):
+        self.to(tab.id, url)
       if focus:
         self._c.tabs.activate(tab.id)
       return None
@@ -48,14 +51,15 @@ class NavigationNS(Namespace):
     focus: bool = False,
     window: str | None = None,
     group: str | None = None,
-    reuse: bool = False,
+    reuse: bool | str = False,
     reuse_domain: bool = False,
     reuse_title: str | None = None,
   ) -> Tab:
     """Open *url* in a new tab and block until fully loaded. Returns the Tab."""
-    tab = self._reuse_target(url, reuse=reuse, reuse_domain=reuse_domain, reuse_title=reuse_title)
+    tab = self.reusable_tab(url, reuse=reuse, reuse_domain=reuse_domain, reuse_title=reuse_title)
     if tab is not None:
-      self.to(tab.id, url)
+      if needs_navigation(tab.url, url):
+        self.to(tab.id, url)
       if focus:
         self._c.tabs.activate(tab.id)
       return self._c.tabs.wait_for_load(tab.id, timeout=timeout)
@@ -91,21 +95,31 @@ class NavigationNS(Namespace):
   def to(self, tab_id: int, url: str) -> None:
     """Navigate a specific tab to *url* in place."""
 
-  def _reuse_target(self, url: str, *, reuse: bool, reuse_domain: bool, reuse_title: str | None):
-    if not (reuse or reuse_domain or reuse_title):
+  def reusable_tab(
+    self,
+    url: str,
+    *,
+    reuse: bool | str = False,
+    reuse_domain: bool = False,
+    reuse_title: str | None = None,
+  ) -> Tab | None:
+    """Return the open tab that already fits *url*, or ``None``.
+
+    ``reuse`` takes ``True`` (nearly identical URL), ``'exact'``, ``'similar'``,
+    ``'origin'`` or ``'none'``; ``reuse_title`` falls back to a title substring.
+    """
+    mode = normalize_mode(reuse, reuse_domain)
+    if mode == "none" and not reuse_title:
       return None
-    from urllib.parse import urlparse
-    wanted = urlparse(url)
-    wanted_host = wanted.netloc.lower()
-    for tab in self._c.tabs.list():
-      tab_url = tab.url or ""
-      parsed = urlparse(tab_url)
-      if reuse and tab_url == url:
-        return tab
-      if reuse_domain and wanted_host and parsed.netloc.lower() == wanted_host:
-        return tab
-      if reuse_title and reuse_title.lower() in (tab.title or "").lower():
-        return tab
+    tabs = self._c.tabs.list()
+    match = find_reusable_tab(tabs, url, mode)
+    if match is not None:
+      return match
+    if reuse_title:
+      needle = reuse_title.lower()
+      for tab in tabs:
+        if needle in (tab.title or "").lower():
+          return tab
     return None
 
   def search(

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/browser_cli/sdk/tabs.py

@@ -5,6 +5,7 @@ from collections.abc import Callable, Iterable
 
 from browser_cli.models import BrowserCounts, Tab
 from browser_cli.sdk.base import Namespace
+from browser_cli.url_match import needs_navigation
 
 # Keep SDK-driven bulk closes comfortably below the native-host response
 # timeout. The extension can close larger batches, but real browsers may take
@@ -32,14 +33,29 @@ class TabsNS(Namespace):
     focus: bool = False,
     window: str | None = None,
     group: str | None = None,
+    reuse: bool | str = False,
+    reuse_domain: bool = False,
+    reuse_title: str | None = None,
   ) -> Tab:
     """Open *url* in a new tab and return a bound :class:`Tab`.
 
     Set ``wait=True`` to block until the page reaches ``readyState=complete``.
     Pass ``focus=True`` to explicitly bring the created tab/window forward.
+    ``reuse=True`` navigates an already-open tab with a nearly identical URL
+    instead of creating a duplicate.
     """
     if wait:
-      return self._c.nav.open_wait(url, timeout=timeout, background=background, focus=focus, window=window, group=group)
+      return self._c.nav.open_wait(
+        url, timeout=timeout, background=background, focus=focus, window=window, group=group,
+        reuse=reuse, reuse_domain=reuse_domain, reuse_title=reuse_title,
+      )
+    existing = self._c.nav.reusable_tab(url, reuse=reuse, reuse_domain=reuse_domain, reuse_title=reuse_title)
+    if existing is not None:
+      if needs_navigation(existing.url, url):
+        self._c.nav.to(existing.id, url)
+      if focus:
+        self.activate(existing.id)
+      return self.status(existing.id)
     return self.require_tab(
       self.command("navigate.open", {"url": url, "background": background or not focus, "focus": focus, "window": window, "group": group}),
       "navigate.open returned unexpected data",

real_browser_cli-0.16.9/browser_cli/url_match.py

@@ -0,0 +1,138 @@
+"""Match a requested URL against already-open tabs.
+
+Agents and scripts usually want the tab that already shows a page instead of a
+duplicate of it. These helpers answer "is this tab already (nearly) the URL I
+am about to open?" without touching the browser.
+
+Modes:
+  ``none``     never reuse a tab
+  ``exact``    only a byte-identical URL
+  ``similar``  same site and page, ignoring fragment, trailing slash, query
+               order, ``www.`` and default ports; a request for the site root
+               also matches any tab on that site
+  ``origin``   any tab on the same site, whatever its path
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal
+from urllib.parse import parse_qsl, urlsplit
+
+ReuseMode = Literal["none", "exact", "similar", "origin"]
+
+REUSE_MODES: tuple[str, ...] = ("none", "exact", "similar", "origin")
+
+_DEFAULT_PORTS = {"http": 80, "https": 443, "ws": 80, "wss": 443}
+_ROOT_PATHS = {"", "/"}
+
+@dataclass(frozen=True)
+class UrlKey:
+  """Canonical, comparable form of a URL."""
+
+  scheme: str
+  host: str
+  port: int | None
+  path: str
+  query: tuple[tuple[str, str], ...]
+
+  @property
+  def origin(self) -> tuple[str, str, int | None]:
+    return (self.scheme, self.host, self.port)
+
+  @property
+  def is_root(self) -> bool:
+    return self.path == "" and not self.query
+
+def url_key(url: str | None) -> UrlKey | None:
+  """Return the canonical key of *url*, or ``None`` when it is not comparable."""
+  if not url:
+    return None
+  parts = urlsplit(url.strip())
+  if not parts.scheme or not parts.hostname:
+    return None
+  scheme = parts.scheme.lower()
+  host = parts.hostname.lower()
+  if host.startswith("www.") and len(host) > 4:
+    host = host[4:]
+  port = parts.port
+  if port is not None and _DEFAULT_PORTS.get(scheme) == port:
+    port = None
+  path = parts.path.rstrip("/")
+  query = tuple(sorted(parse_qsl(parts.query, keep_blank_values=True)))
+  return UrlKey(scheme=scheme, host=host, port=port, path=path, query=query)
+
+def normalize_mode(reuse: bool | str | None, reuse_domain: bool = False) -> ReuseMode:
+  """Fold the boolean flags and explicit mode names into one :data:`ReuseMode`."""
+  if reuse_domain:
+    return "origin"
+  if reuse is True:
+    return "similar"
+  if reuse is False or reuse is None:
+    return "none"
+  mode = str(reuse).lower()
+  if mode not in REUSE_MODES:
+    raise ValueError(f"Unknown reuse mode '{reuse}'. Use one of: {', '.join(REUSE_MODES)}")
+  return mode  # type: ignore[return-value]
+
+def urls_match(url: str, candidate: str | None, mode: ReuseMode) -> bool:
+  """Report whether *candidate* may be reused for *url* under *mode*."""
+  if mode == "none" or not candidate:
+    return False
+  if mode == "exact":
+    return candidate == url
+  wanted, other = url_key(url), url_key(candidate)
+  if wanted is None or other is None:
+    return False
+  if wanted.origin != other.origin:
+    return False
+  if mode == "origin":
+    return True
+  return wanted.path == other.path or wanted.is_root
+
+def needs_navigation(current: str | None, url: str) -> bool:
+  """Report whether a reused tab still has to be navigated to *url*."""
+  if current == url:
+    return False
+  wanted, other = url_key(url), url_key(current)
+  return wanted is None or other is None or wanted != other
+
+def tab_url(tab: Any) -> str | None:
+  """Read a tab URL from an SDK ``Tab`` or a serialized tab dict."""
+  if isinstance(tab, dict):
+    value = tab.get("url")
+  else:
+    value = getattr(tab, "url", None)
+  return value if isinstance(value, str) else None
+
+def tab_id(tab: Any) -> int | None:
+  """Read a tab ID from an SDK ``Tab`` or a serialized tab dict."""
+  value = tab.get("id") if isinstance(tab, dict) else getattr(tab, "id", None)
+  return value if isinstance(value, int) else None
+
+def find_reusable_tab(tabs: Any, url: str, mode: ReuseMode):
+  """Return the open tab that best fits *url*, or ``None``.
+
+  Closer matches win: an identical URL beats a canonical match, which beats a
+  looser site-level match; among equally loose matches the tab closest to the
+  requested page wins.
+  """
+  if mode == "none":
+    return None
+  wanted = url_key(url)
+  best, best_rank = None, None
+  for tab in tabs or ():
+    candidate = tab_url(tab)
+    if not urls_match(url, candidate, mode):
+      continue
+    rank = _rank(wanted, candidate)
+    if best_rank is None or rank < best_rank:
+      best, best_rank = tab, rank
+  return best
+
+def _rank(wanted: UrlKey | None, candidate: str | None) -> tuple[int, int]:
+  """Lower is a closer match: exact string, canonical, then shallowest path."""
+  other = url_key(candidate)
+  if wanted is not None and other is not None and wanted == other:
+    return (0, 0)
+  depth = other.path.count("/") if other is not None else 99
+  return (1, depth)

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "browser-cli",
-  "version": "0.16.8",
+  "version": "0.16.9",
   "description": "Control your browser from the terminal or Python SDK",
   "browser_specific_settings": {
     "gecko": {

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "real-browser-cli"
-version = "0.16.8"
+version = "0.16.9"
 description = "Control your real running browser from the terminal or Python SDK"
 readme = "README.md"
 license = { file = "LICENSE" }

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/tests/test_mcp.py

@@ -27,6 +27,7 @@ class FakeClient:
       open=self.tabs_open,
       close=self.tabs_close,
       active=self.tabs_active,
+      activate=self.tabs_activate,
       status=self.tabs_status,
       screenshot=self.tabs_screenshot,
     )
@@ -54,6 +55,9 @@ class FakeClient:
     self.calls.append(("active",))
     return SimpleNamespace(id=7)
 
+  def tabs_activate(self, tab_id):
+    self.calls.append(("activate", tab_id))
+
   def tabs_status(self, tab_id):
     self.calls.append(("status", tab_id))
     return {"id": tab_id, "title": "Navigated", "url": "https://example.com/next"}
@@ -207,6 +211,7 @@ async def test_mutating_tools_use_sdk_and_return_fresh_state(client):
     "url": "https://example.com",
     "wait": True,
     "focus": True,
+    "reuse": "none",
   })
   navigated = await client.call_tool("browser_navigate", {
     "tab_id": 8,
@@ -216,7 +221,7 @@ async def test_mutating_tools_use_sdk_and_return_fresh_state(client):
   typed = await client.call_tool("browser_dom_type", {"selector": "#name", "text": "Daniel"})
 
   assert opened.structured_content == {
-    "id": 8, "title": "Opened", "url": "https://example.com"
+    "id": 8, "title": "Opened", "url": "https://example.com", "reused": False
   }
   assert navigated.structured_content["id"] == 8
   assert clicked.structured_content["url"] == "https://example.com"
@@ -230,6 +235,36 @@ async def test_mutating_tools_use_sdk_and_return_fresh_state(client):
     ("navigate", 8, "https://example.com/next"), ("status", 8)
   ]
 
+@pytest.mark.anyio
+async def test_tabs_open_reuses_a_tab_that_already_shows_the_page(client):
+  opened = await client.call_tool("browser_tabs_open", {"url": "https://www.example.com/#top"})
+
+  assert opened.structured_content == {
+    "id": 7, "title": "Navigated", "url": "https://example.com/next", "reused": True
+  }
+  assert FakeClient.instances[0].calls == [("status", 7)]  # already there → no navigation
+
+@pytest.mark.anyio
+async def test_tabs_open_reuses_a_site_tab_and_navigates_it(client):
+  opened = await client.call_tool(
+    "browser_tabs_open",
+    {"url": "https://browser-host.example/app?view=logs", "focus": True},
+  )
+
+  assert opened.structured_content["reused"] is True
+  assert FakeClient.instances[0].calls == [
+    ("navigate", 9, "https://browser-host.example/app?view=logs"),
+    ("activate", 9),
+    ("status", 9),
+  ]
+
+@pytest.mark.anyio
+async def test_tabs_open_does_not_reuse_an_unrelated_tab(client):
+  opened = await client.call_tool("browser_tabs_open", {"url": "https://other.example/docs"})
+
+  assert opened.structured_content["reused"] is False
+  assert FakeClient.instances[0].calls[0][0] == "open"
+
 @pytest.mark.anyio
 async def test_tab_tools_default_to_the_active_tab(client):
   navigated = await client.call_tool("browser_navigate", {"url": "https://example.com/next"})

{real_browser_cli-0.16.8 → real_browser_cli-0.16.9}/tests/test_new_feature_commands.py

@@ -34,21 +34,60 @@ def test_session_export_cli_prints_json():
   assert result.exit_code == 0
   assert '"name": "work"' in result.output
 
-def test_nav_open_reuse_navigates_existing_tab_instead_of_opening_new():
-  calls = []
+def _reuse_sender(calls, tab_url="https://example.com"):
+  tab = {"id": 7, "windowId": 1, "active": False, "muted": False, "title": "Example", "url": tab_url}
 
   def sender(command, args=None, **kwargs):
     calls.append((command, args))
     if command == "tabs.list":
-      return [{"id": 7, "windowId": 1, "active": False, "muted": False, "title": "Example", "url": "https://example.com"}]
+      return [tab]
+    if command in {"tabs.status", "navigate.open"}:
+      return dict(tab)
     return {}
+  return sender
+
+def test_nav_open_reuse_navigates_existing_tab_instead_of_opening_new():
+  calls = []
 
-  BrowserCLI(browser="testing", _command_sender=sender).nav.open("https://example.com", reuse=True)
+  BrowserCLI(browser="testing", _command_sender=_reuse_sender(calls, "https://example.com/app?a=1")).nav.open(
+    "https://example.com/app?a=2", reuse=True
+  )
   assert calls == [
     ("tabs.list", {}),
-    ("navigate.to", {"tabId": 7, "url": "https://example.com"}),
+    ("navigate.to", {"tabId": 7, "url": "https://example.com/app?a=2"}),
   ]
 
+def test_nav_open_reuse_matches_nearly_identical_urls():
+  calls = []
+
+  BrowserCLI(browser="testing", _command_sender=_reuse_sender(calls, "https://example.com/app?a=1&b=2")).nav.open(
+    "https://www.example.com/app/?b=2&a=1#top", reuse=True
+  )
+  assert calls == [("tabs.list", {})]  # same page already open → no reload, no new tab
+
+def test_nav_open_reuse_exact_opens_a_new_tab_for_a_different_url():
+  calls = []
+
+  BrowserCLI(browser="testing", _command_sender=_reuse_sender(calls)).nav.open(
+    "https://example.com/", reuse="exact"
+  )
+  assert [command for command, _ in calls] == ["tabs.list", "navigate.open"]
+
+def test_tabs_open_reuse_returns_the_existing_tab():
+  calls = []
+
+  tab = BrowserCLI(browser="testing", _command_sender=_reuse_sender(calls)).tabs.open(
+    "https://example.com/deep/page", reuse="origin"
+  )
+  assert tab.id == 7
+  assert [command for command, _ in calls] == ["tabs.list", "navigate.to", "tabs.status"]
+
+def test_tabs_open_without_reuse_always_creates_a_tab():
+  calls = []
+
+  BrowserCLI(browser="testing", _command_sender=_reuse_sender(calls)).tabs.open("https://example.com")
+  assert [command for command, _ in calls] == ["navigate.open"]
+
 def _tree_sender(tabs, groups):
   def sender(command, args=None, **kwargs):
     if command == "tabs.list":