File size: 21,864 Bytes
89af3b2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
"""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)