mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/screen_text.py

@@ -0,0 +1,101 @@
+"""The image head of the two-headed check: what the screen's pixels say inside a control's frame.
+
+Before a tap that would go ahead without asking, Mobster's agent compares the control's accessibility label with the
+text Apple Vision reads in the same frame of the same screen (frontier ``_two_heads``). When the pixels name an act
+the label doesn't (the tree says "Done" or "Button", the screen shows "Delete"), the person is asked first.
+
+The text is read from the live stream's frame of the screen the tree was read from (frontier.video_frame, free),
+while the model decides (``prefetch``), so the check adds no wait to a step in the usual case. No frame, no helper,
+or no answer within ``wait`` seconds: the reader says None (unknown) and the tree's reading stands.
+
+``reader()``: a ScreenText when the helper is installed (the Mac app ships it as Contents/Resources/screen-text;
+``mobster`` from source builds it with ``native_helpers.build("screen_text")``), else None.
+"""
+
+import json
+import subprocess
+import threading
+
+PAD = .01           # a frame's margin: Vision's boxes are a little smaller than the control
+KEEP = 4
+RUN_SECONDS = 3.0
+
+
+class ScreenText:
+    def __init__(self, helper, run=None):
+        self.helper = str(helper)
+        self._run = run or self._helper
+        self._lock = threading.Lock()
+        self._screens = {}
+        self._order = []
+
+    @staticmethod
+    def _key(snapshot):
+        return (getattr(snapshot, "content_fingerprint", None), getattr(snapshot, "read_started", None),
+                id(snapshot))
+
+    def _helper(self, data):
+        done = subprocess.run([self.helper], input=data, capture_output=True, timeout=RUN_SECONDS, check=True)
+        return json.loads(done.stdout or b"[]")
+
+    def read(self, data):
+        try:
+            return [row for row in self._run(data) if isinstance(row, dict)]
+        except Exception:  # noqa: BLE001 -- unknown: the caller keeps what it has
+            return None
+
+    def prefetch(self, driver, snapshot):
+        """Start reading ``snapshot``'s frame in the background (once per screen)."""
+        key = self._key(snapshot)
+        with self._lock:
+            if key in self._screens:
+                return
+            entry = {"done": threading.Event(), "rows": None}
+            self._screens[key] = entry
+            self._order.append(key)
+            while len(self._order) > KEEP:
+                self._screens.pop(self._order.pop(0), None)
+
+        def work():
+            try:
+                from .frontier.screen import video_frame
+                frame = video_frame(driver, since=getattr(snapshot, "read_started", None))
+                if frame is not None:
+                    entry["rows"] = [r for r in self._run(frame) if isinstance(r, dict)]
+            except Exception:  # noqa: BLE001 -- unknown: the tree's reading stands
+                entry["rows"] = None
+            finally:
+                entry["done"].set()
+        threading.Thread(target=work, daemon=True, name="mobster-screen-text").start()
+
+    def __call__(self, driver, element, snapshot, wait=.15):
+        """The text the pixels show inside ``element``'s frame ("" when they show none), or None when unknown."""
+        self.prefetch(driver, snapshot)
+        with self._lock:
+            entry = self._screens.get(self._key(snapshot))
+        if entry is None or not entry["done"].wait(wait) or entry["rows"] is None:
+            return None
+        x, y, w, h = element.rect
+        inside = []
+        for row in entry["rows"]:
+            rx, ry, rw, rh = (row.get("rect") or (0, 0, 0, 0))[:4]
+            cx, cy = rx + rw / 2, ry + rh / 2
+            if x - PAD <= cx <= x + w + PAD and y - PAD <= cy <= y + h + PAD:
+                inside.append(str(row.get("text") or ""))
+        return " ".join(" ".join(inside).split())
+
+
+def reader():
+    """A ScreenText on the installed helper, or None."""
+    try:
+        from . import native_helpers
+        helper = native_helpers.find("screen-text")
+    except Exception:  # noqa: BLE001
+        helper = None
+    return ScreenText(helper) if helper is not None else None
+
+
+def read_image(data):
+    """The text Vision reads in one image (bytes), as ScreenText.read gives it; None without the helper."""
+    found = reader()
+    return found.read(data) if found is not None else None

mobile_agent/secret_filter.py

@@ -0,0 +1,113 @@
+"""The one secret filter, frozen: a change may only widen what it catches."""
+
+import re
+
+from .agent_hooks import MASK
+
+_MASK = re.escape(MASK)
+# Words that name a secret. PIN counts in capitals, or as "pin code", "pin number", "pin is", "pin:".
+_WORDS = (r"(?:(?i:\b(?:password|passcode|passwd|pass\s?word|pin\s?code|pin\s?number|one[- ]time\s+(?:pass)?code|"
+          r"verification\s+code|security\s+code|cvv|cvc|pin(?=\s*(?:is\b|was\b|:|=))))|\bPIN\b)")
+# A quoted passphrase is one value, including escaped quotes and punctuation attached to its closing quote.
+_VALUE = r'''(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')[^\s,;]*|[^\s,;]+'''
+# A value after is/was/:/= within four words, or right after the word with a digit or symbol ("password hunter2!").
+KEYWORD_VALUE = re.compile(_WORDS + r"(?:(?:\s+[\w'’]+){0,4}?\s*(?:\bis\b|\bwas\b|:|=)\s*(" + _VALUE + r")"
+                           r"|\s+((?=[^\s,;]*(?:[\d_]|[^\w\s]))(?:" + _VALUE + r")))")
+KEYWORD = re.compile(_WORDS)
+# "the code is 551203", "code: 4821", "OTP 551 203": a code word with a value that has a digit.
+CODE_VALUE = re.compile(r"(?i:\b(?:code|otp)\b)(?:\s*(?:is|was|:|=)\s*|\s+)(" + _MASK
+                        + r"|(?=[^\s,;]*\d)(?:" + _VALUE + r")(?:\s\d{3,4}\b)?)")
+OTP = re.compile(r"(?<![\w.,/-])\d{6,8}(?![\w.,/]|-\d)")
+CARD = re.compile(r"(?<![\w-])(?:\d[ -]?){12,18}\d(?![\w-])")
+SSN = re.compile(r"(?<![\w-])\d{3}-\d{2}-\d{4}(?![\w-])")
+IBAN = re.compile(r"\b[A-Z]{2}\d{2}(?: ?[A-Z0-9]){11,30}\b")
+API_KEY = re.compile(r"\b(?:sk-(?:ant-)?[A-Za-z0-9_-]{16,}|[sr]k_(?:live|test)_[A-Za-z0-9]{16,}|ghp_[A-Za-z0-9]{20,}|"
+                     r"gho_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|xox[abprs]-[A-Za-z0-9-]{10,}|"
+                     r"(?:AKIA|ASIA)[A-Z0-9]{16}|AIza[A-Za-z0-9_-]{30,}|sb_secret_[A-Za-z0-9_-]{16,}|"
+                     r"whsec_[A-Za-z0-9+/=_-]{16,}|re_[A-Za-z0-9_]{16,}|mob_(?:at|rt|rk|dk)_[A-Za-z0-9_-]{16,}|"
+                     r"mob_ci_[A-Za-z0-9_-]{30}_[A-Za-z0-9_-]{43}(?![A-Za-z0-9_-])|"
+                     r"eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]*|ya29\.[A-Za-z0-9_-]{20,})|"
+                     r"(?<![\w/])1//0[A-Za-z0-9_-]{20,}")
+# "Authorization: Bearer abc123...": the token goes, the word stays.
+BEARER = re.compile(r"\b[Bb]earer\s+((?=[A-Za-z0-9._~+/=-]*(?:\d|[a-z][A-Za-z0-9._~+/=-]*[A-Z]))"
+                    r"[A-Za-z0-9._~+/=-]{12,})")
+# "OPENAI_API_KEY=value", "GH_TOKEN='value'", "APP_SECRET=value": the name stays, the value goes.
+ENV_VALUE = re.compile(r"\b(?:[A-Z][A-Z0-9]*_)*(?:API_KEY|TOKEN|SECRET)\s*=\s*[\"']?([^\s\"',;]+)")
+EMAIL_PASSWORD = re.compile(r"[\w.+-]+@[\w-]+(?:\.[\w-]+)+(?:\s*[:/|]\s*|\s+(?:and|with|pw|pwd)\s+)("
+                            + _VALUE + r")", re.I)
+IMAGE_DATA = re.compile(r"data:image/(?:png|jpeg|webp);base64,(?:[A-Za-z0-9+/]{4})*"
+                        r"(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?\Z")
+
+
+def _luhn(digits):
+    total, parity = 0, len(digits) % 2
+    for index, char in enumerate(digits):
+        value = int(char)
+        if index % 2 == parity:
+            value *= 2
+            if value > 9:
+                value -= 9
+        total += value
+    return total % 10 == 0
+
+
+def _cards(text):
+    """Spans of Luhn-valid 13–19-digit card numbers (spaces or dashes allowed between digits)."""
+    spans = []
+    for match in CARD.finditer(text):
+        digits = re.sub(r"\D", "", match.group())
+        if 13 <= len(digits) <= 19 and _luhn(digits):
+            spans.append(match.span())
+    return spans
+
+
+def _value_spans(text):
+    spans = []
+    for pattern in (API_KEY, SSN, IBAN, OTP):
+        spans += [m.span() for m in pattern.finditer(text)]
+    spans += _cards(text)
+    for pattern in (KEYWORD_VALUE, CODE_VALUE, EMAIL_PASSWORD, BEARER, ENV_VALUE):
+        for match in pattern.finditer(text):
+            group = next((g for g in range(1, (pattern.groups or 0) + 1) if match.group(g) is not None), None)
+            if group is not None:
+                spans.append(match.span(group))
+    return spans
+
+
+def is_secret(text):
+    """Whether ``text`` holds or names a secret (see the module docstring). Non-strings are never secret."""
+    if not isinstance(text, str) or not text:
+        return False
+    return MASK in text or bool(KEYWORD.search(text)) or bool(_value_spans(text))
+
+
+def redact(text):
+    """``text`` with every secret value replaced by MASK. Idempotent; non-strings come back unchanged."""
+    if not isinstance(text, str) or not text:
+        return text
+    spans = sorted(_value_spans(text))
+    if not spans:
+        return text
+    merged = [list(spans[0])]
+    for start, end in spans[1:]:
+        if start <= merged[-1][1]:
+            merged[-1][1] = max(merged[-1][1], end)
+        else:
+            merged.append([start, end])
+    out = text
+    for start, end in reversed(merged):
+        out = out[:start] + MASK + out[end:]
+    return out
+
+
+def redact_deep(value, depth=0):
+    """Redact JSON-shaped data, masking omitted subtrees beyond eight levels."""
+    if depth > 8:
+        return MASK
+    if isinstance(value, str):
+        return value if len(value) > 4096 and IMAGE_DATA.fullmatch(value) else redact(value)
+    if isinstance(value, dict):
+        return {key: redact_deep(item, depth + 1) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [redact_deep(item, depth + 1) for item in value]
+    return value

mobile_agent/serve.py

@@ -0,0 +1,160 @@
+"""`mobster serve`: the service's secrets, token file, parent watch and the serve loop."""
+
+import io
+import json
+import os
+import re
+import secrets
+import select
+import signal
+import sys
+import threading
+import time
+from pathlib import Path
+
+from . import harness_api, keychain_acl
+from .api_http import setup_scope_token
+from .costs import usd_to_nanodollars
+from .paths import write_private
+from .server import BoundedServer, Runtime, make_handler
+from .workflows.scheduler import KeepAwake, WorkflowScheduler
+
+TOKEN_FILE = "api-token"
+# `mobster chat` and MCP's phone_task find the service here when it moved off 8765 (threads/client.py).
+URL_FILE = "api-url"
+
+
+# The Mac app's shell passes the token and app session on stdin: `ps -E` shows the environment to the same user.
+SECRETS_ON_STDIN = "MOBSTER_SECRETS_ON_STDIN"
+
+
+def launch_secrets(stream=None, wait=10.0):
+    if os.environ.pop(SECRETS_ON_STDIN, "") != "1":
+        return None, None
+    # The app's windowless agent: an untrusted Keychain item fails to read instead of prompting (keychain_acl.py).
+    keychain_acl.no_prompts()
+    stream = stream or sys.stdin
+    try:
+        ready = select.select([stream], [], [], wait)[0]
+    except (OSError, ValueError, io.UnsupportedOperation):
+        ready = [stream]
+    if not ready:
+        raise ValueError("the Mac app did not pass the API token on stdin")
+    parts = stream.readline().split()
+    if len(parts) != 2:
+        raise ValueError("the Mac app passed no API token and app session on stdin")
+    return parts[0], parts[1]
+
+
+def api_token(supplied=None):
+    # Popped so the runner and relay processes don't inherit it.
+    configured = os.environ.pop("MOBSTER_API_TOKEN", "")
+    token = supplied or configured or secrets.token_urlsafe(32)
+    if not re.fullmatch(r"[A-Za-z0-9_.~-]{32,256}", token):
+        raise ValueError("MOBSTER_API_TOKEN must be 32 to 256 URL-safe characters")
+    return token
+
+
+def app_session_secret(supplied=None):
+    configured = os.environ.pop("MOBSTER_APP_SESSION", "")
+    value = supplied or configured
+    if not value:
+        return None
+    if not re.fullmatch(r"[A-Za-z0-9_.~-]{32,256}", value):
+        raise ValueError("MOBSTER_APP_SESSION must be 32 to 256 URL-safe characters")
+    return value
+
+
+def token_file(config):
+    state_db = getattr(config, "state_db", None)
+    return Path(state_db).parent / TOKEN_FILE if state_db else None
+
+
+def watch_parent(parent, interval=1.0):
+    # Killing only a frozen sidecar's bootloader used to orphan this process, which kept holding the API port.
+    def watch():
+        while True:
+            time.sleep(interval)
+            if os.getppid() != parent:
+                os.kill(os.getpid(), signal.SIGTERM)
+                return
+    threading.Thread(target=watch, name="mobster-parent-watch", daemon=True).start()
+
+
+def runtime_class_for(config, base=Runtime):
+    runtime_for = harness_api.hooks().runtime_for
+    runtime_class = (runtime_for(config) if runtime_for else None) or base
+    if runtime_class is not base:
+        return runtime_class
+    # Imported here: both modules import server at load.
+    from . import cable_bt_runtime, mirroring_runtime
+    for module, experimental in ((mirroring_runtime, mirroring_runtime.MirroringRuntime),
+                                 (cable_bt_runtime, cable_bt_runtime.CableBtRuntime)):
+        if module.wanted(config):
+            config.wda_url = module.CONFIG_URL
+            return experimental
+    return base
+
+
+def serve(config):
+    usd_to_nanodollars(getattr(config, "spend_cap_usd", None))
+    runtime_class = runtime_class_for(config)
+    supplied_token, supplied_session = launch_secrets()
+    token, path = api_token(supplied_token), token_file(config)
+    session = app_session_secret(supplied_session)
+    # The Mac app's agent (it has an app session) needs a plan or trial; `mobster serve` alone has no account.
+    config.require_plan = bool(session)
+    runtime = runtime_class(config)
+    runtime.model_reach.enabled = True
+    runtime.engine_sampler.start()
+    server = None
+    try:
+        setup_token = setup_scope_token(token) if session else None
+        server = BoundedServer(("127.0.0.1", config.port), make_handler(runtime, token, app_session=session,
+                                                                        setup_token=setup_token))
+        # --port 0 lets the system pick; a test's stand-in server may have no address.
+        bound = getattr(server, "server_address", None)
+        if bound:
+            config.port = bound[1]
+        url = f"http://127.0.0.1:{config.port}"
+        if path:
+            write_private(path, token + "\n")
+            write_private(path.with_name(URL_FILE), url + "\n")
+        runtime.local_api = {"url": url, "token": token, "app_session": bool(session)}
+        runtime.serving.set()
+        runtime.power.awake.attach(KeepAwake())
+        scheduled_checks = getattr(runtime, "test_schedules", None)
+        runtime.scheduler = WorkflowScheduler(runtime.workflows, keep_awake=runtime.power.awake.handle("schedule"),
+                                              also=scheduled_checks.tick if scheduled_checks is not None else None)
+        runtime.scheduler.start()
+    except Exception:
+        if server is not None:
+            server.server_close()
+        runtime.close()
+        raise
+    # The token is never printed: stdout reaches logs.
+    print(json.dumps({"service": "Mobster API", "url": url,
+                      "tokenFile": str(path) if path else None}), flush=True)
+    if getattr(config, "exit_with_parent", False):
+        watch_parent(os.getppid())
+    previous_term = None
+    if threading.current_thread() is threading.main_thread():
+        previous_term = signal.getsignal(signal.SIGTERM)
+        def terminate(*_):
+            raise KeyboardInterrupt
+        signal.signal(signal.SIGTERM, terminate)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+        runtime.close()
+        for leftover, mine in ((path, token), (path and path.with_name(URL_FILE), url)):
+            try:
+                if leftover and leftover.read_text().strip() == mine:
+                    leftover.unlink()
+            except OSError:
+                pass
+        if previous_term is not None:
+            signal.signal(signal.SIGTERM, previous_term)