browserwright 0.7.3__tar.gz → 0.7.4__tar.gz

{browserwright-0.7.3 → browserwright-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: browserwright
-Version: 0.7.3
+Version: 0.7.4
 Summary: Browserwright — let AI/code agents drive a real or isolated browser and author userscripts. Single package: the agent-facing REPL/site-skills/memory layer plus the bundled browser-resolving daemon (CDP proxy + extension/cloud backends).
 Requires-Python: >=3.11
 Requires-Dist: websockets==15.0.1

{browserwright-0.7.3 → browserwright-0.7.4}/README.md

@@ -179,6 +179,16 @@ external profiles with N isolated daemons — each with its own `XDG_RUNTIME_DIR
 (distinct socket), `--facade-port`, and `BD_CDP_WS`, one `env` session apiece.
 See [docs/session-workspaces.md](docs/session-workspaces.md) §"Env Backend".
 
+**Reaching the facade from another machine (Tailscale/LAN):** the Playwright
+facade binds `127.0.0.1` by default and is *never* exposed off-box unless you
+opt in. Pass `--facade-host <tailnet-ip>` (or `BD_FACADE_HOST` / `facade_host`
+in config.toml; `0.0.0.0` to bind all interfaces) and a remote client can
+`connect_over_cdp("http://<tailnet-ip>:19990/cdp")` — the facade's
+`/json/version` bootstrap rewrites the advertised `webSocketDebuggerUrl` from
+the request's `Host` header, so the ws URL points back at the address the
+client actually used. No auth is added, so only bind an interface you trust
+(a Tailscale IP is private to your tailnet).
+
 ### Userscripts
 
 Author Tampermonkey-style scripts the `extension` backend injects on matching sites:

{browserwright-0.7.3 → browserwright-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "browserwright"
-version = "0.7.3"
+version = "0.7.4"
 description = "Browserwright — let AI/code agents drive a real or isolated browser and author userscripts. Single package: the agent-facing REPL/site-skills/memory layer plus the bundled browser-resolving daemon (CDP proxy + extension/cloud backends)."
 requires-python = ">=3.11"
 dependencies = [

{browserwright-0.7.3 → browserwright-0.7.4}/src/browserwright/daemon/cli.py

@@ -108,6 +108,16 @@ def _build_parser() -> argparse.ArgumentParser:
               "(default: ON at 19990; pass 0 to disable). Lets a real "
               "Playwright client `connect_over_cdp(ws://127.0.0.1:N/cdp)` and "
               "the skill heredoc `page`/`context` drive the resolved Chrome."))
+    # Facade bind host. Defaults to loopback (127.0.0.1) — the facade is NEVER
+    # reachable off-box unless you opt in here. Set a Tailscale/LAN IP (or
+    # 0.0.0.0) to let a remote Playwright client connect_over_cdp. Equivalent to
+    # BD_FACADE_HOST env or `facade_host` in config.toml.
+    p_serve.add_argument(
+        "--facade-host", type=str, default=None, metavar="HOST",
+        help=("bind the Playwright-facing CDP facade on this host "
+              "(default: 127.0.0.1 / loopback). Set a Tailscale/LAN IP or "
+              "0.0.0.0 to reach it from another machine. Equivalent to "
+              "BD_FACADE_HOST env or `facade_host` in config.toml."))
 
     # stop (v0.2)
     p_stop = sub.add_parser("stop", help="stop the running daemon")
@@ -283,6 +293,13 @@ def _build_parser() -> argparse.ArgumentParser:
                         help=argparse.SUPPRESS)
     p_inst.add_argument("--extension-port", type=int, default=None, metavar="N",
                         help="override the relay ws port (default 19989)")
+    p_inst.add_argument("--facade-port", type=int, default=None, metavar="N",
+                        help="override the Playwright facade port (default 19990)")
+    p_inst.add_argument(
+        "--facade-host", type=str, default=None, metavar="HOST",
+        help=("bind the Playwright facade on this host (default 127.0.0.1 / "
+              "loopback). Set a Tailscale/LAN IP or 0.0.0.0 to reach the "
+              "installed daemon's facade from another machine."))
     p_inst.add_argument("--force", action="store_true",
                         help="replace an existing LaunchAgent with the same name")
 
@@ -329,6 +346,7 @@ def _cfg_from_args(args) -> Config:
         # per subcommand, so getattr-with-default keeps non-serve calls clean.
         cli_extension_port=getattr(args, "extension_port", None),
         cli_facade_port=getattr(args, "facade_port", None),
+        cli_facade_host=getattr(args, "facade_host", None),
     )
 
 
@@ -949,7 +967,9 @@ def _resolve_browserwright_daemon_bin() -> str:
     )
 
 
-def _build_plist(*, extension_port: int | None) -> str:
+def _build_plist(*, extension_port: int | None,
+                 facade_host: str | None = None,
+                 facade_port: int | None = None) -> str:
     """Emit the plist content. Kept inline (no XML lib) — the schema is
     fixed + tiny, and we avoid a dependency. Every interpolated value passes
     through ``xml.sax.saxutils.escape``. Pure: no side effects — the caller is
@@ -959,6 +979,10 @@ def _build_plist(*, extension_port: int | None) -> str:
     args = [bin_path, "serve"]
     if extension_port is not None:
         args += ["--extension-port", str(extension_port)]
+    if facade_port is not None:
+        args += ["--facade-port", str(facade_port)]
+    if facade_host is not None:
+        args += ["--facade-host", str(facade_host)]
     log_dir = os.path.expanduser("~/.cache/browserwright-daemon/logs")
     stdout_path = f"{log_dir}/browserwright-daemon.stdout.log"
     stderr_path = f"{log_dir}/browserwright-daemon.stderr.log"
@@ -1030,7 +1054,11 @@ def _cmd_install(args, cfg: Config) -> int:
     # `_build_plist` so the generator stays pure / unit-testable (N-1).
     log_dir = os.path.expanduser("~/.cache/browserwright-daemon/logs")
     os.makedirs(log_dir, exist_ok=True)
-    content = _build_plist(extension_port=args.extension_port)
+    content = _build_plist(
+        extension_port=args.extension_port,
+        facade_host=getattr(args, "facade_host", None),
+        facade_port=getattr(args, "facade_port", None),
+    )
     # If --force and the plist exists, unload the old one first so launchctl
     # picks up the new ProgramArguments cleanly.
     if plist_path.exists():
@@ -1049,6 +1077,8 @@ def _cmd_install(args, cfg: Config) -> int:
         "label": label,
         "plist": str(plist_path),
         "extension_port": args.extension_port,
+        "facade_host": getattr(args, "facade_host", None),
+        "facade_port": getattr(args, "facade_port", None),
     }, sort_keys=True))
     return 0
 

{browserwright-0.7.3 → browserwright-0.7.4}/src/browserwright/daemon/config.py

@@ -29,6 +29,12 @@ _NAME_RE = re.compile(r"\A[A-Za-z0-9_-]{1,64}\Z")
 # re-exports it for backwards compat.
 DEFAULT_FACADE_PORT = 19990
 
+# Default bind host for the Playwright-facing CDP facade. Stays loopback so the
+# facade is NEVER reachable off-box by accident; override via `--facade-host` /
+# `BD_FACADE_HOST` / `facade_host` in config.toml to bind a Tailscale/LAN
+# interface (e.g. `0.0.0.0` or a specific tailnet IP) for remote CDP clients.
+DEFAULT_FACADE_HOST = "127.0.0.1"
+
 
 def check_name(name: str) -> str:
     """Path-traversal guard for filesystem-bound names (e.g. `--profile`)."""
@@ -116,6 +122,11 @@ class Config:
     #   - >0            -> explicit override port (CLI/env/toml).
     # Use `resolved_facade_port()` to collapse this to "bind / don't bind".
     facade_port: int | None = None
+    # Bind host for the Playwright facade. Defaults to loopback (never exposed by
+    # accident); set to a Tailscale/LAN IP or `0.0.0.0` to reach it off-box.
+    # Precedence mirrors facade_port: CLI `--facade-host` > `BD_FACADE_HOST` env
+    # > toml `facade_host` > DEFAULT_FACADE_HOST.
+    facade_host: str = DEFAULT_FACADE_HOST
     backends: BackendsConfig = field(default_factory=BackendsConfig)
     # Provenance for `env`: which alias key actually fired. Diagnostic-only.
     cdp_ws_source: str | None = None       # "BD_CDP_WS" | "BU_CDP_WS" | None
@@ -156,6 +167,7 @@ def load(
     cli_config_path: str | None = None,
     cli_extension_port: int | None = None,
     cli_facade_port: int | None = None,
+    cli_facade_host: str | None = None,
     env: dict[str, str] | None = None,
 ) -> Config:
     """Build a Config from CLI flags + env + optional toml file.
@@ -213,6 +225,9 @@ def load(
     # Playwright facade port (phase A1). toml key `facade_port`.
     if "facade_port" in toml and isinstance(toml["facade_port"], int):
         cfg.facade_port = toml["facade_port"]
+    # Playwright facade bind host. toml key `facade_host`.
+    if "facade_host" in toml and isinstance(toml["facade_host"], str):
+        cfg.facade_host = toml["facade_host"]
 
     # env level — BD_* wins over BU_*
     if "BD_TIMEOUT" in e:
@@ -317,6 +332,10 @@ def load(
             from .errors import UserError
             raise UserError(
                 f"BD_FACADE_PORT must be an integer, got {e['BD_FACADE_PORT']!r}")
+    # Playwright facade bind host via env. Symmetric to BD_FACADE_PORT — set
+    # BD_FACADE_HOST=<tailnet-ip>/0.0.0.0 to reach the facade off-box.
+    if "BD_FACADE_HOST" in e:
+        cfg.facade_host = e["BD_FACADE_HOST"]
 
     # CLI level — last word
     if cli_backend is not None:
@@ -333,5 +352,8 @@ def load(
     if cli_facade_port is not None:
         # Phase A1: CLI `--facade-port` tops env / toml.
         cfg.facade_port = cli_facade_port
+    if cli_facade_host is not None:
+        # CLI `--facade-host` tops env / toml.
+        cfg.facade_host = cli_facade_host
 
     return cfg

{browserwright-0.7.3 → browserwright-0.7.4}/src/browserwright/daemon/server/facade.py

@@ -158,13 +158,25 @@ class PlaywrightFacade:
         `webSocketDebuggerUrl: ws://host/cdp`; `connect_over_cdp("ws://...")`
         also accepts an `http://` URL it resolves via this route. We answer
         `/json/version`, `/json`, and `/json/list` (the latter two are cheap
-        and some CDP clients probe them)."""
+        and some CDP clients probe them).
+
+        The advertised `webSocketDebuggerUrl` is derived from the incoming
+        request's `Host` header so a client that reached us over Tailscale/LAN
+        gets a ws URL that points back at the same authority it just used —
+        exactly what CloakBrowser does. We only fall back to the configured
+        `host:port` when no Host header is present (e.g. a hand-rolled probe)."""
         path = (request.path or "/").split("?", 1)[0]
+        # Playwright's `connect_over_cdp("http://host:port")` probes
+        # `.../json/version/` WITH a trailing slash; normalize it away so the
+        # http bootstrap form works, not just the direct `ws://.../cdp` form.
+        if len(path) > 1:
+            path = path.rstrip("/")
         session_id = self._session_for_request(request)
+        authority = self._authority_from_request(request)
         if path == "/json/version":
-            return self._http_json(conn, self._version_payload(session_id))
+            return self._http_json(conn, self._version_payload(session_id, authority))
         if path in ("/json", "/json/list"):
-            return self._http_json(conn, self._list_payload(session_id))
+            return self._http_json(conn, self._list_payload(session_id, authority))
         # Anything else (e.g. the /cdp ws upgrade) falls through to the ws
         # handler. Return None to allow the upgrade.
         return None
@@ -180,22 +192,40 @@ class PlaywrightFacade:
         qs = parse_qs(urlparse(request.path or "/").query)
         return (qs.get("session") or [None])[0]
 
-    def _ws_url(self, session_id: str | None = None) -> str:
+    def _authority_from_request(self, request) -> str | None:
+        """Return the `Host` header (``host[:port]``) the client used to reach
+        us, or None when absent. Drives the advertised ws so a remote client
+        that connected over Tailscale/LAN gets a ws URL that points back at the
+        same authority (not a hardcoded loopback it can't reach)."""
+        try:
+            host = request.headers.get("Host")
+        except (AttributeError, KeyError):
+            return None
+        host = (host or "").strip()
+        return host or None
+
+    def _ws_url(self, session_id: str | None = None,
+                authority: str | None = None) -> str:
+        # Prefer the incoming request's Host (already `host[:port]`); fall back
+        # to the configured bind host:port when no Host header was sent.
+        netloc = authority or f"{self._host}:{self._port}"
         suffix = ""
         if session_id:
             from urllib.parse import quote
             suffix = f"?session={quote(session_id, safe='')}"
-        return f"ws://{self._host}:{self._port}{FACADE_WS_PATH}{suffix}"
+        return f"ws://{netloc}{FACADE_WS_PATH}{suffix}"
 
-    def _version_payload(self, session_id: str | None = None) -> dict:
+    def _version_payload(self, session_id: str | None = None,
+                         authority: str | None = None) -> dict:
         return {
             "Browser": f"Browserwright/{__version__}",
             "Protocol-Version": "1.3",
             "User-Agent": f"Browserwright facade {__version__}",
-            "webSocketDebuggerUrl": self._ws_url(session_id),
+            "webSocketDebuggerUrl": self._ws_url(session_id, authority),
         }
 
-    def _list_payload(self, session_id: str | None = None) -> list:
+    def _list_payload(self, session_id: str | None = None,
+                      authority: str | None = None) -> list:
         # The browser-level endpoint is what Playwright wants; per-page targets
         # are discovered via Target.* over the ws once connected. We advertise a
         # single synthetic "browser" entry pointing at our ws.
@@ -203,7 +233,7 @@ class PlaywrightFacade:
             "type": "browser",
             "title": "Browserwright",
             "url": "",
-            "webSocketDebuggerUrl": self._ws_url(session_id),
+            "webSocketDebuggerUrl": self._ws_url(session_id, authority),
         }]
 
     # ---- ws passthrough --------------------------------------------------

{browserwright-0.7.3 → browserwright-0.7.4}/src/browserwright/daemon/server/listener.py

@@ -290,10 +290,15 @@ async def run_serve(cfg: Config) -> int:
                 return shared_context.holder.relay
 
             facade = PlaywrightFacade(cfg=cfg, port=facade_port,
+                                      host=cfg.facade_host,
                                       relay_getter=_shared_relay,
                                       daemon=daemon)
             bound = await facade.start()
-            facade_ws = f"ws://127.0.0.1:{bound}/cdp"
+            # Advertise the bound host so `status`/skill discovery report a
+            # reachable ws (loopback by default; a tailnet/LAN IP when
+            # `--facade-host` opts in). Remote clients still get the real
+            # incoming Host echoed back via the facade's HTTP bootstrap.
+            facade_ws = f"ws://{cfg.facade_host}:{bound}/cdp"
             # Advertise the bound ws so the skill layer can discover it (Phase C
             # auto-enable). Best-effort: a write failure must not abort serving.
             with contextlib.suppress(Exception):

{browserwright-0.7.3 → browserwright-0.7.4}/src/browserwright.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: browserwright
-Version: 0.7.3
+Version: 0.7.4
 Summary: Browserwright — let AI/code agents drive a real or isolated browser and author userscripts. Single package: the agent-facing REPL/site-skills/memory layer plus the bundled browser-resolving daemon (CDP proxy + extension/cloud backends).
 Requires-Python: >=3.11
 Requires-Dist: websockets==15.0.1