loopable / api /browser_local.py
fsanyoto's picture
Deploy AIOS web (React glide grid + FastAPI slice)
8145bee verified
Raw History Blame Contribute Delete
9.92 kB
"""Run a guarded headless Chromium executor with credential recording disabled."""
import contextlib
import json
import logging
import os
import threading
from urllib.parse import urljoin, urlsplit
from browser_backend import BrowserRefusal
from core import login_origins, login_redact
_START_LOCK = threading.RLock()
_QUIET_LOCK = threading.RLock()
_DEBUG_KEYS = ("DEBUG", "PWDEBUG", "DEBUG_FILE", "PLAYWRIGHT_DEBUG_LOG",
"PW_TEST_TRACE", "PW_TEST_VIDEO", "PW_TEST_SCREENSHOT")
class _Discard:
def write(self, value):
return len(value)
def flush(self):
pass
@contextlib.contextmanager
def quiet_execution():
"""Discard executor and provider diagnostics rather than retaining credentials."""
# Logging and Python streams are process-wide, so nested callers share one lock.
with _QUIET_LOCK:
level = logging.root.manager.disable
saved_fds = []
sink = None
logging.disable(logging.CRITICAL)
try:
sink = os.open(os.devnull, os.O_WRONLY)
for fd in (1, 2):
saved_fds.append((fd, os.dup(fd)))
os.dup2(sink, fd)
with contextlib.redirect_stdout(_Discard()), contextlib.redirect_stderr(_Discard()):
yield
finally:
for fd, saved in reversed(saved_fds):
os.dup2(saved, fd)
os.close(saved)
if sink is not None:
os.close(sink)
logging.disable(level)
@contextlib.contextmanager
def _quiet_environment():
"""Clear inherited driver debug settings before starting the child process."""
with _START_LOCK:
saved = {name: os.environ.get(name) for name in _DEBUG_KEYS}
for name in _DEBUG_KEYS:
os.environ.pop(name, None)
os.environ["PWDEBUG"] = "0"
try:
yield
finally:
for name, value in saved.items():
if value is None:
os.environ.pop(name, None)
else:
os.environ[name] = value
class LocalBrowser:
"""Guard every request and fill against the saved Login origin."""
cost_bound_usd = 0
def __init__(self):
self._playwright = self._browser = self._context = self._page = None
self._handles = {}
self.blocked_origin = False
self._executor = False
@property
def landed_url(self):
return self._page.url if self._page is not None else ""
def _guard_url(self, url):
try:
parts = urlsplit(url)
if (parts.username is not None or parts.password is not None
or any(ord(ch) < 32 for ch in url) or "\\" in url):
raise ValueError()
clean = login_origins.normalize(parts.scheme + "://" + parts.netloc)
if clean != self._origin or self._origin_guard(clean) != clean:
raise ValueError()
except Exception:
self.blocked_origin = True
raise BrowserRefusal("blocked_origin") from None
return url
def _navigation_guard(self, route):
try:
self._guard_url(route.request.url)
if route.request.method not in ("GET", "HEAD") and not self._executor:
route.abort()
return
route.continue_()
except Exception:
self.blocked_origin = True
route.abort()
def _check_page(self):
if self.blocked_origin:
raise BrowserRefusal("blocked_origin")
self._guard_url(self.landed_url)
def open(self, origin, *, origin_guard):
self._origin, self._origin_guard = origin, origin_guard
try:
self._guard_url(origin)
with quiet_execution(), _quiet_environment():
from playwright.sync_api import sync_playwright
self._playwright = sync_playwright().start()
env = {key: value for key, value in os.environ.items() if key not in _DEBUG_KEYS}
env["PWDEBUG"] = "0"
self._browser = self._playwright.chromium.launch(
headless=True, env=env, args=["--disable-background-networking"])
# No tracing, video, HAR, screenshots, downloads or persistent profile.
self._context = self._browser.new_context(
service_workers="block", accept_downloads=False)
self._context.route("**/*", self._navigation_guard)
self._page = self._context.new_page()
self._page.set_default_timeout(5000)
self._page.set_default_navigation_timeout(5000)
self._page.on("dialog", lambda dialog: dialog.dismiss())
self._context.on("page", self._reject_popup)
return self
except Exception:
self.close()
raise BrowserRefusal("blocked_origin" if self.blocked_origin else "backend_unavailable") from None
def _reject_popup(self, page):
self.blocked_origin = True
page.close()
def goto(self, url):
try:
target = self._guard_url(urljoin(self._origin + "/", url))
self._page.goto(target, wait_until="domcontentloaded")
self._check_page()
except Exception:
raise BrowserRefusal("blocked_origin" if self.blocked_origin else "backend_unavailable") from None
def snapshot_text(self):
try:
self._check_page()
self._handles = {}
controls = []
nodes = self._page.locator("input, button, a[href]")
for index in range(nodes.count()):
node = nodes.nth(index)
if not node.is_visible():
continue
tag = node.evaluate("el => el.tagName.toLowerCase()")
kind, label = tag, ""
if tag == "input":
kind = node.get_attribute("type") or "text"
name = " ".join(node.get_attribute(key) or "" for key in
("name", "id", "autocomplete", "placeholder", "aria-label")).lower()
if kind == "password":
kind = "password"
elif any(word in name for word in ("code", "otp", "one-time")):
kind = "code"
elif any(word in name for word in ("username", "email", "user")):
kind = "username"
label = node.get_attribute("aria-label") or node.get_attribute("name") or kind
else:
label = node.inner_text()
handle = "h" + str(index)
self._handles[handle] = (node, kind)
controls.append({"handle": handle, "kind": kind, "label": label})
text = self._page.locator("body").inner_text()
return login_redact.scrub_for_model(json.dumps(
{"url": self.landed_url, "text": text, "controls": controls}))
except Exception:
raise BrowserRefusal("blocked_origin" if self.blocked_origin else "backend_unavailable") from None
def click(self, handle, *, executor=False):
try:
self._check_page()
node, kind = self._handles[handle]
if not executor:
if kind != "a" or node.get_attribute("download") is not None:
raise BrowserRefusal("read_only")
self._guard_url(urljoin(self.landed_url, node.get_attribute("href")))
elif kind != "button" or node.get_attribute("type") not in (None, "submit"):
raise BrowserRefusal("read_only")
if executor:
form = node.locator("xpath=ancestor::form")
if form.count() != 1:
raise BrowserRefusal("sign_in_failed")
self._guard_url(urljoin(self.landed_url, form.get_attribute("action") or self.landed_url))
self._executor = executor
try:
with quiet_execution():
node.click()
self._page.wait_for_load_state("domcontentloaded")
finally:
self._executor = False
self._check_page()
except BrowserRefusal:
raise
except Exception:
raise BrowserRefusal("blocked_origin" if self.blocked_origin else "sign_in_failed") from None
def type_handle(self, handle, text):
raise BrowserRefusal("read_only")
def fill_secret(self, handle, value, *, origin):
try:
self._check_page()
if origin != self._origin or login_origins.normalize(origin) != self._origin:
raise BrowserRefusal("blocked_origin")
node, kind = self._handles[handle]
if kind not in ("username", "password", "code"):
raise BrowserRefusal("sign_in_failed")
form = node.locator("xpath=ancestor::form")
if form.count() != 1:
raise BrowserRefusal("sign_in_failed")
self._guard_url(urljoin(self.landed_url, form.get_attribute("action") or self.landed_url))
with quiet_execution():
node.fill(value)
except BrowserRefusal:
raise
except Exception:
raise BrowserRefusal("sign_in_failed") from None
def close(self):
with quiet_execution():
for obj, method in ((self._context, "close"), (self._browser, "close"),
(self._playwright, "stop")):
if obj is not None:
try:
getattr(obj, method)()
except Exception:
pass
self._handles.clear()
self._playwright = self._browser = self._context = self._page = None