Download api/browser_worker.py from fsanyoto/loopable: direct link, hf CLI and curl.
- Browser
- Download file 21.9 kB
-
https://huggingface.co/spaces/fsanyoto/loopable/resolve/f694a2bb8305731dbfb36abe080ff76fe2b3a6c4/api/browser_worker.py
- Command line
-
hf download hf://spaces/fsanyoto/loopable@f694a2bb8305731dbfb36abe080ff76fe2b3a6c4/api/browser_worker.py
-
curl -L -o browser_worker.py https://huggingface.co/spaces/fsanyoto/loopable/resolve/f694a2bb8305731dbfb36abe080ff76fe2b3a6c4/api/browser_worker.py
21.9 kB
| """Execute read-only Login tasks while credentials stay inside the browser worker.""" | |
| import dash_norm | |
| import json | |
| import re | |
| import secrets | |
| import time | |
| from decimal import Decimal | |
| from urllib.parse import urlsplit | |
| from browser_backend import BrowserRefusal, get_backend | |
| from browser_local import quiet_execution | |
| from core import login_budget, login_origins, login_redact, login_relay, login_run, logins | |
| MODEL_TOOLS = [ | |
| {"name": "goto", "schema": {"type": "object", "properties": {"url": {"type": "string"}}, | |
| "required": ["url"], "additionalProperties": False}}, | |
| {"name": "click", "schema": {"type": "object", "properties": {"handle": {"type": "string"}}, | |
| "required": ["handle"], "additionalProperties": False}}, | |
| {"name": "snapshot_text", "schema": {"type": "object", "properties": {}, | |
| "additionalProperties": False}}, | |
| ] | |
| class Worker: | |
| """Pause model calls during sign-in and scrub every outbound value.""" | |
| def __init__(self, rt, login_id, username, *, is_admin=False, backend=None, | |
| breaker=None, totp_clock=None, reservation_id=None): | |
| self.rt, self.login_id, self.username = rt, login_id, username | |
| self.is_admin, self.backend = is_admin, backend | |
| self.breaker = breaker or login_run.Breaker() | |
| self.totp_clock = totp_clock or time.time | |
| self.reservation_id = reservation_id | |
| self._credentials = [] | |
| self.origin = None | |
| def scrub(self, value): | |
| if isinstance(value, str): | |
| return dash_norm.plain(login_redact.scrub(value, self._credentials)) | |
| if isinstance(value, dict): | |
| return {self.scrub(key): self.scrub(item) for key, item in value.items() if isinstance(key, str)} | |
| if isinstance(value, (list, tuple)): | |
| return [self.scrub(item) for item in value] | |
| if value is None or type(value) in (bool, int, float): | |
| return value | |
| return None | |
| def _url(self, value): | |
| clean = self.scrub(value) | |
| if not isinstance(clean, str) or "[hidden]" in clean: | |
| raise BrowserRefusal("blocked_origin") | |
| parts = urlsplit(clean) | |
| if parts.username is not None or parts.password is not None: | |
| raise BrowserRefusal("blocked_origin") | |
| return clean | |
| def snapshot(self): | |
| # Keep this boundary visible to the physical credential-leak mutation. | |
| return self.scrub(self.backend.snapshot_text()) | |
| def _controls(self): | |
| self.breaker.check() | |
| body = json.loads(self.backend.snapshot_text()) | |
| if not isinstance(body, dict) or not isinstance(body.get("controls"), list): | |
| raise BrowserRefusal("sign_in_failed") | |
| self._challenge(body) | |
| return body["controls"] | |
| def _challenge(self, body): | |
| text = body.get("text", "") | |
| if isinstance(text, str): | |
| for item in body.get("controls", []): | |
| if isinstance(item, dict) and item.get("kind") == "a" and isinstance(item.get("label"), str): | |
| label = item["label"].strip() | |
| if label: | |
| text = text.replace(label, "", 1) | |
| kinds = {item.get("kind") for item in body.get("controls", []) if isinstance(item, dict)} | |
| if (body.get("state") == "captcha" or "captcha" in kinds | |
| or re.search(r"\b(?:captcha|solve (?:this|the) puzzle|human must complete|requires a human)\b", | |
| text if isinstance(text, str) else "", re.I)): | |
| raise BrowserRefusal("needs_human") | |
| def _push_wait(self): | |
| logins.set_wait_state(self.rt, self.reservation_id, self.username, "waiting_for_approval") | |
| approval_url = self.backend.landed_url | |
| while True: | |
| self.breaker.check() | |
| logins.entry_for_run(self.rt, self.login_id, self.username, self.is_admin) | |
| body = json.loads(self.backend.snapshot_text()) | |
| self._challenge(body) | |
| controls = body.get("controls", []) | |
| if (body.get("state") in ("approved", "signed_in") | |
| or (body.get("state") is None | |
| and self.backend.landed_url != approval_url | |
| and not any(item.get("kind") in ("password", "code", "push", "approval") | |
| for item in controls))): | |
| logins.set_wait_state(self.rt, self.reservation_id, self.username, "running") | |
| return | |
| time.sleep(0.25) | |
| def _fill(self, controls, kind, value): | |
| candidates = [item for item in controls if item.get("kind") == kind] | |
| if len(candidates) != 1: | |
| raise BrowserRefusal("sign_in_failed") | |
| self.breaker.check() | |
| self.backend.fill_secret(candidates[0]["handle"], value, origin=self.origin) | |
| def _submit(self, controls): | |
| buttons = [item for item in controls if item.get("kind") == "button"] | |
| if len(buttons) != 1: | |
| raise BrowserRefusal("sign_in_failed") | |
| self.breaker.check() | |
| self.backend.click(buttons[0]["handle"], executor=True) | |
| def sign_in(self, login_id): | |
| """Fill credentials only in the executor and return two safe fields.""" | |
| try: | |
| return self._sign_in(login_id) | |
| except (BrowserRefusal, login_run.BreakerOpen, login_budget.LoginBudgetExceeded, | |
| login_budget.LoginBudgetUnavailable, login_origins.LoginOriginError, | |
| logins.LoginAccessDenied): | |
| raise | |
| except Exception: | |
| raise BrowserRefusal("sign_in_failed") from None | |
| def _sign_in(self, login_id): | |
| if login_id != self.login_id: | |
| raise BrowserRefusal("sign_in_failed") | |
| # Import only when the credentialed executor runs, never during web-tier import. | |
| from core import login_unseal | |
| with quiet_execution(): | |
| fields = login_unseal.open_fields(self.rt, login_id, self.username, self.is_admin, | |
| reservation_id=self.reservation_id) | |
| self._credentials.extend(fields[name] for name in ("username", "password", "totp_seed") | |
| if fields[name]) | |
| self.origin = fields["origin"] | |
| self.breaker.check() | |
| self.backend.goto(self.origin) | |
| controls = self._controls() | |
| self._fill(controls, "username", fields["username"]) | |
| self._fill(controls, "password", fields["password"]) | |
| self._submit(controls) | |
| controls = self._controls() | |
| if any(item.get("kind") == "password" for item in controls): | |
| return {"ok": False, "landed_url": self.scrub(self.backend.landed_url)} | |
| row = logins.entry_for_run(self.rt, login_id, self.username, self.is_admin) | |
| factor = row["second_factor"] | |
| if factor == "push": | |
| self._push_wait() | |
| controls = self._controls() | |
| if any(item.get("kind") == "code" for item in controls): | |
| if factor in ("text", "sms", "email", "manual", "code", "ask_user"): | |
| code = login_relay.wait_for_code( | |
| self.rt, self.username, self.reservation_id, row["label"], | |
| "email" if factor == "email" else "text", self.breaker) | |
| controls = self._controls() | |
| elif fields["totp_seed"]: | |
| from core import login_totp | |
| code = login_totp.worker_code(fields["totp_seed"], self.totp_clock()) | |
| else: | |
| raise BrowserRefusal("needs_code") | |
| self._credentials.append(code) | |
| self._fill(controls, "code", code) | |
| self._submit(controls) | |
| controls = self._controls() | |
| if any(item.get("kind") in ("code", "password") for item in controls): | |
| return {"ok": False, "landed_url": self.scrub(self.backend.landed_url)} | |
| fields.clear() | |
| return {"ok": True, "landed_url": self.scrub(self.backend.landed_url)} | |
| def action(self, tool): | |
| self.breaker.check() | |
| if not isinstance(tool, dict) or set(tool) != {"name", "arguments"}: | |
| raise BrowserRefusal("read_only") | |
| name, args = tool["name"], self.scrub(tool["arguments"]) | |
| if not isinstance(args, dict): | |
| raise BrowserRefusal("read_only") | |
| if name == "goto" and set(args) == {"url"}: | |
| self.backend.goto(self._url(args["url"])) | |
| elif name == "click" and set(args) == {"handle"}: | |
| self.backend.click(args["handle"]) | |
| elif name == "snapshot_text" and not args: | |
| pass | |
| else: | |
| raise BrowserRefusal("read_only") | |
| return {"ok": True, "landed_url": self.scrub(self.backend.landed_url)} | |
| def _cost(value): | |
| if type(value) not in (int, float, Decimal): | |
| raise login_run.BreakerOpen("cost_unknown") | |
| try: | |
| return login_budget._decimal(value) | |
| except Exception: | |
| raise login_run.BreakerOpen("cost_unknown") from None | |
| class PricedModelAdapter: | |
| """Require trusted quotes and measured usage for every provider attempt, including fallbacks.""" | |
| def __init__(self, *, quote_attempt, measure_attempt, invoke): | |
| if not all(callable(fn) for fn in (quote_attempt, measure_attempt, invoke)): | |
| raise login_run.BreakerOpen("cost_unknown") | |
| self.quote_attempt, self.measure_attempt, self.invoke = quote_attempt, measure_attempt, invoke | |
| def request(self, request, breaker, on_attempt, on_measured): | |
| tickets, measured_total, failure = {}, Decimal(0), None | |
| def fail(): | |
| nonlocal failure | |
| failure = "cost_unknown" | |
| raise login_run.BreakerOpen(failure) from None | |
| def before_attempt(spec, messages, tools): | |
| if failure or any(not row["done"] for row in tickets.values()): | |
| fail() | |
| try: | |
| breaker.check() | |
| if tickets: | |
| breaker.step() | |
| bound = _cost(self.quote_attempt(spec, messages, tools)) | |
| if bound > breaker.usd_limit - Decimal(str(breaker.spent_usd)): | |
| raise login_run.BreakerOpen("cost_limit") | |
| token = secrets.token_hex(12) | |
| tickets[token] = {"spec": spec, "bound": bound, "done": False} | |
| on_attempt() | |
| return token | |
| except Exception: | |
| fail() | |
| def after_attempt(token, usage): | |
| nonlocal measured_total | |
| if failure or token not in tickets or tickets[token]["done"]: | |
| fail() | |
| ticket = tickets[token] | |
| try: | |
| measured = _cost(self.measure_attempt(ticket["spec"], usage)) | |
| on_measured(measured) | |
| measured_total += measured | |
| ticket["done"] = True | |
| breaker.charge(measured) | |
| if (measured > ticket["bound"] or isinstance(ticket["spec"], dict) | |
| and ticket["spec"].get("_usage_bound_exceeded") is True): | |
| fail() | |
| except Exception: | |
| fail() | |
| try: | |
| reply = self.invoke(request, before_attempt=before_attempt, after_attempt=after_attempt) | |
| except Exception: | |
| if not failure and (not tickets or any(not row["done"] for row in tickets.values())): | |
| on_attempt() | |
| raise login_run.BreakerOpen("model_failed") from None | |
| if failure or not tickets or any(not row["done"] for row in tickets.values()): | |
| if not failure: | |
| on_attempt() | |
| fail() | |
| if not isinstance(reply, dict): | |
| fail() | |
| return {**reply, "cost_usd": measured_total} | |
| def run_web_task(rt, login_id, goal, *, username, ask_model, is_admin=False, | |
| backend=None, model_cost_bound_usd=None, breaker=None, totp_clock=None, run_id=None): | |
| """Reserve the run bound and return scrubbed evidence with fixed outcomes.""" | |
| result = {"ok": False, "status": "run_failed", "answer": "", "transcript": [], | |
| "tool_calls": [], "run_id": None} | |
| worker = Worker(rt, login_id, username, is_admin=is_admin, backend=backend, | |
| breaker=breaker, totp_clock=totp_clock) | |
| admitted = False | |
| usage_accounted = True | |
| browser_usage_accounted = True | |
| paid_browser = False | |
| browser_bound = Decimal(0) | |
| run_limit = worker.breaker.usd_limit | |
| measured_total = Decimal(0) | |
| try: | |
| with quiet_execution(): | |
| if run_id is not None: | |
| run = logins.run_for_owner(rt, run_id, username) | |
| if run["entry_id"] != login_id or run["status"] != "running": | |
| raise logins.LoginAccessDenied("This Login run is unavailable.") | |
| result["run_id"] = worker.reservation_id = run_id | |
| admitted = True | |
| # Protected or revoked Logins fail before backend selection or navigation. | |
| row = logins.entry_for_run(rt, login_id, username, is_admin) | |
| if (worker.breaker.step_limit > 25 or worker.breaker.usd_limit > Decimal("0.50") | |
| or worker.breaker._seconds > 900): | |
| raise login_run.BreakerOpen("limit_invalid") | |
| worker.origin = row["origin"] | |
| worker._credentials.append(row["username"]) | |
| worker.backend = backend if backend is not None else get_backend() | |
| priced = isinstance(ask_model, PricedModelAdapter) | |
| model_bound = None if priced else _cost(model_cost_bound_usd) | |
| if run_id is None: | |
| run = logins.begin_run(rt, login_id, username, is_admin, | |
| reserve_usd=worker.breaker.usd_limit) | |
| else: | |
| run = logins.run_for_owner(rt, run_id, username) | |
| if run["entry_id"] != login_id or run["status"] != "running": | |
| raise logins.LoginAccessDenied("This Login run is unavailable.") | |
| admitted = True | |
| worker.reservation_id = result["run_id"] = run["id"] | |
| worker.breaker.check() | |
| paid_browser = getattr(worker.backend, "paid_browser", False) is True | |
| if paid_browser: | |
| from browser_agentcore import AgentCoreBackend | |
| if not isinstance(worker.backend, AgentCoreBackend): | |
| raise BrowserRefusal() | |
| if not priced and not worker.backend._fixture_mode: | |
| raise BrowserRefusal() | |
| worker.backend.prepare_run(tenant=rt.key, run_id=run["id"], origin=worker.origin, | |
| timeout_seconds=int(min(900, worker.breaker._seconds))) | |
| browser_bound = _cost(getattr(worker.backend, "cost_bound_usd", None)) | |
| if (not paid_browser and browser_bound) or browser_bound >= run_limit: | |
| raise BrowserRefusal() | |
| if not priced and model_bound + browser_bound > run_limit: | |
| raise login_run.BreakerOpen("cost_limit") | |
| # Keep the browser maximum unavailable to every model attempt and fallback. | |
| worker.breaker.usd_limit = run_limit - browser_bound | |
| worker.breaker.check() | |
| browser_usage_accounted = not paid_browser | |
| worker.backend.open(worker.origin, origin_guard=lambda origin: logins.check_origin(rt, origin)) | |
| signed = worker.sign_in(login_id) | |
| result["tool_calls"].append({"name": "sign_in", "arguments": {"login_id": login_id}, | |
| "result": signed}) | |
| if not signed["ok"]: | |
| raise BrowserRefusal("sign_in_failed") | |
| messages = [{"role": "system", "content": "Read this website. Use only the supplied read tools. " | |
| "Return an answer or a tool with name and arguments. Never write or submit a form."}, | |
| {"role": "user", "content": worker.scrub(goal)}] | |
| while True: | |
| worker.breaker.step() | |
| if not priced and model_bound > worker.breaker.usd_limit - Decimal(str(worker.breaker.spent_usd)): | |
| raise login_run.BreakerOpen("cost_limit") | |
| snapshot = worker.snapshot() | |
| try: | |
| body = json.loads(snapshot) | |
| except (TypeError, ValueError): | |
| body = {"text": snapshot} | |
| if isinstance(body, dict): | |
| worker._challenge(body) | |
| request = worker.scrub({"login_id": login_id, "messages": messages, | |
| "snapshot": snapshot, "tools": MODEL_TOOLS}) | |
| result["transcript"].append({"role": "tool", "content": snapshot}) | |
| worker.breaker.check() | |
| def attempted(): | |
| nonlocal usage_accounted | |
| usage_accounted = False | |
| def measured_attempt(amount): | |
| nonlocal usage_accounted, measured_total | |
| login_budget.charge(rt, run["id"], "charge_" + secrets.token_hex(12), amount) | |
| measured_total += amount | |
| usage_accounted = True | |
| if not priced: | |
| usage_accounted = model_bound == 0 | |
| try: | |
| raw = (ask_model.request(request, worker.breaker, attempted, measured_attempt) | |
| if priced else ask_model(request)) | |
| except login_run.BreakerOpen: | |
| raise | |
| except Exception: | |
| result["status"] = "model_failed" | |
| break | |
| if not isinstance(raw, dict): | |
| raise login_run.BreakerOpen("cost_unknown") | |
| measured = _cost(raw.get("cost_usd")) | |
| if not priced: | |
| measured_total += measured | |
| # Book usage before parsing the answer or opening the breaker. | |
| login_budget.charge(rt, run["id"], "charge_" + secrets.token_hex(12), measured) | |
| usage_accounted = True | |
| worker.breaker.charge(measured) | |
| if measured > model_bound: | |
| raise login_run.BreakerOpen("cost_bound_exceeded") | |
| reply = worker.scrub(raw) | |
| if isinstance(reply.get("answer"), str) and reply["answer"].strip(): | |
| result.update(ok=True, status="completed", answer=reply["answer"]) | |
| result["transcript"].append({"role": "assistant", "content": reply["answer"]}) | |
| break | |
| tool = reply.get("tool") | |
| output = worker.action(tool) | |
| result["tool_calls"].append({**tool, "result": output}) | |
| messages.extend(({"role": "assistant", "content": json.dumps(tool)}, | |
| {"role": "tool", "content": json.dumps(output)})) | |
| except login_origins.LoginOriginError: | |
| result["status"] = "blocked_origin" | |
| except logins.LoginAccessDenied: | |
| result["status"] = "login_unavailable" | |
| except login_budget.LoginBudgetExceeded: | |
| result["status"] = "budget_exceeded" | |
| except login_budget.LoginBudgetUnavailable: | |
| result["status"] = "budget_unavailable" | |
| except login_run.BreakerOpen: | |
| result["status"] = "breaker_open" | |
| except BrowserRefusal as exc: | |
| result["status"] = exc.code | |
| if exc.code == "needs_human": | |
| result["answer"] = logins.CAPTCHA_MESSAGE | |
| except Exception: | |
| result["status"] = "run_failed" | |
| finally: | |
| with quiet_execution(): | |
| if worker.backend is not None: | |
| try: | |
| browser_usage = worker.backend.close() | |
| if paid_browser: | |
| if getattr(worker.backend, "billing_attempted", True): | |
| measured_browser = _cost(browser_usage) | |
| login_budget.charge(rt, result["run_id"], | |
| "charge_" + secrets.token_hex(12), measured_browser) | |
| measured_total += measured_browser | |
| browser_usage_accounted = True | |
| if measured_browser > browser_bound or measured_total > run_limit: | |
| result.update(ok=False, status="breaker_open", answer="") | |
| else: | |
| browser_usage_accounted = True | |
| except Exception: | |
| if paid_browser: | |
| browser_usage_accounted = not getattr(worker.backend, "billing_attempted", True) | |
| result.update(ok=False, status="backend_unavailable", answer="") | |
| worker.breaker.usd_limit = run_limit | |
| usage_accounted = usage_accounted and browser_usage_accounted | |
| if admitted: | |
| if usage_accounted: | |
| try: | |
| login_budget.release(rt, result["run_id"]) | |
| except Exception: | |
| result.update(ok=False, status="budget_unavailable", answer="") | |
| try: | |
| logins.finish_run(rt, result["run_id"], result["status"], | |
| steps=min(worker.breaker.steps_taken, 25), | |
| spent_usd=measured_total, cost_known=usage_accounted) | |
| except Exception: | |
| result.update(ok=False, status="run_failed", answer="") | |
| return worker.scrub(result) | |