Spaces:
Running on CPU Upgrade
Running on CPU Upgrade
Download api/browser_local.py from fsanyoto/runloopable: direct link, hf CLI and curl.
- Browser
- Download file 9.92 kB
-
https://huggingface.co/spaces/fsanyoto/runloopable/resolve/main/api/browser_local.py
- Command line
-
hf download hf://spaces/fsanyoto/runloopable/api/browser_local.py
-
curl -L -o browser_local.py https://huggingface.co/spaces/fsanyoto/runloopable/resolve/main/api/browser_local.py
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 | |
| 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) | |
| 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 | |
| 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 | |