mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/smart_run.py

@@ -0,0 +1,413 @@
+"""`mobster run` on Mobster's agent, or on the scripted demo phone (`run --demo`).
+
+It runs through the same runtime the terminal UI and Mobster for Mac use (``tui.session.Session``, started
+without a UI), so nothing about a run is reimplemented: its events, approvals, stop and result are the runtime's.
+On a terminal each step prints as a line (``console.ConsoleRenderer``); piped, or with --json, every event prints as
+one JSON object, and the last one is the ``result``.
+
+Approvals: Mobster asks before it sends, buys, posts or deletes. On a terminal you answer with y or n. Without one
+(--json, a pipe, a script) nobody can answer, so the answer is no: the run ends as declined (exit 1) and says where
+to run it instead. Nothing typed into a task, and no flag, approves an action.
+
+Long tasks (mobile_agent/longform): a request that is one (or --long, --budget) prints its plan card as text and asks
+"Start? [Y/n]" on a terminal (--yes, --json or a pipe start at once; JSON prints the plan as a ``longform_plan``
+event). A plan over the per-task spending limit asks whether to allow its proposed amount (--spend-cap-usd sets it
+instead). While it runs, a line every 10 items ("Watched 20 Reels, 2 ads skipped"); at the end, the report as Markdown.
+"""
+
+import os
+import re
+import sys
+import threading
+
+from .narrate import verbs
+
+DONE = {"completed", "completed_unverified", "expected_text_visible", "user_condition_met"}
+NOBODY_TO_ASK = ("Mobster asks before it sends, buys, posts or deletes, and nobody can answer here (--json or a "
+                 "pipe), so it didn't. Run it on a terminal without --json, in `mobster`, or in Mobster for Mac.")
+REASSURANCE = {"send": "sent", "post": "posted", "pay": "paid", "buy": "bought", "book": "booked",
+               "delete": "deleted"}
+
+
+def run_smart(args, demo=False):
+    """Run ``args.goal`` on Mobster's agent (or the demo). Returns the exit code."""
+    from .cli_constants import EXIT_COULDNT, EXIT_FAILED, EXIT_OK, EXIT_USAGE
+    from .cli_run import (
+        MissingKey,
+        NoDevice,
+        error_line,
+        error_result,
+        event_printer,
+        output,
+        stop_at_safe_point,
+        wda_url_for,
+    )
+    as_json = bool(getattr(args, "json", False)) or not sys.stdout.isatty()
+    remember = remember_only(args.goal)
+    if remember:
+        # "Remember that my gym is …" is a note for Mobster, not a task for the phone: nothing runs.
+        quoted = remember[0].text.replace('"', "'")
+        message = ("That's something for Mobster to remember, not a task for your iPhone, so nothing ran. Save it "
+                   f'with: mobster memory add "{quoted}"')
+        if as_json:
+            output({"event": "result", "status": "error", "ok": False, "error": message, "reason": message,
+                    "routed": "remember", "exit_code": EXIT_USAGE})
+        else:
+            print(f"mobster run: {message}", file=sys.stderr)
+        return EXIT_USAGE
+    if getattr(args, "dry_run", False):
+        return dry_run(args, as_json)
+    if not demo:
+        from .engines import smart_key
+        if not smart_key():
+            from .cli_run import NO_KEY
+            raise MissingKey(NO_KEY)
+        if not args.execute:
+            message = ("Mobster's agent acts from its first step, so there is nothing to preview. Add --execute to "
+                       "run it: it asks before it sends, buys, posts or deletes.")
+            if as_json:
+                output({"event": "result", "status": "error", "ok": False, "error": message, "reason": message,
+                        "exit_code": EXIT_USAGE})
+            else:
+                print(f"mobster run: {message}", file=sys.stderr)
+            return EXIT_USAGE
+    from .journal import LeaseHeld
+    from .tui.session import Session, error_text
+    emit = event_printer(args, preview=False)
+    try:
+        session = Session(wda_url=None if demo else wda_url_for(args), demo=demo,
+                          history_db=None if demo else args.state_db, origin="cli",
+                          spend_cap_usd=args.spend_cap_usd, pace=float(os.environ.get("MOBSTER_DEMO_PACE", "1")))
+    except LeaseHeld as error:
+        # The task history is open in another Mobster: nothing started and the phone was never reached.
+        if as_json:
+            output(error_result(error, EXIT_COULDNT))
+        else:
+            print(error_line(error), file=sys.stderr)
+        return EXIT_COULDNT
+    except Exception as error:
+        raise RuntimeError(error_text(error)) from None
+    stop = threading.Event()
+    try:
+        app_id = _app_for(args.goal, session) if demo else None
+        extras = None
+        if not demo:
+            planned = long_plan(args, session, as_json)
+            if planned == "cancelled":
+                return EXIT_OK
+            extras = planned
+        try:
+            if extras:
+                run = session.runtime.create(app_id, args.goal, "live", origin=session.origin, extras=extras)
+                session.run = run
+            else:
+                run = session.start(app_id, args.goal)
+        except Exception as error:
+            text = error_text(error)
+            code = getattr(error, "code", None)
+            exc = NoDevice(text) if code in ("device_unavailable", "device_busy") else RuntimeError(text)
+            if code == "engine_unavailable" and "key" in text.lower():
+                exc = MissingKey(text)
+            raise exc from None
+        if emit is not output:
+            from .engines import model_words, smart_model
+            where = ("scripted demo: no iPhone, no model calls"
+                     if demo else f"Mobster's agent, {model_words(smart_model())}")
+            emit.start(args.goal, where)
+        prompt = None if as_json else Approver(session, run, emit)
+        progress = Progress(emit if emit is not output else None)
+        with stop_at_safe_point(stop, on_stop=lambda: session.stop(run)) as caught:
+            result = {}
+
+            def on_event(event):
+                kind = event.get("event")
+                if kind == "run_finished":
+                    return
+                if emit is not output and progress.take(event):
+                    return
+                if kind == "result":
+                    # Printed last, after the run's other closing events, so a script's last line is the result.
+                    result.update(event)
+                    return
+                if emit is output:
+                    output(event)
+                else:
+                    emit(event)
+                if kind == "approval_requested":
+                    if prompt is not None:
+                        prompt.ask(event)
+                    else:
+                        session.answer(event.get("approval_id"), False, run=run)
+                        output({"event": "note", "text": NOBODY_TO_ASK})
+            try:
+                session.follow(run, on_event)
+            except KeyboardInterrupt:
+                session.stop(run)
+                if emit is output:
+                    output({"event": "result", "status": "stopped", "reason": "Stopped with a second signal before "
+                            "the next safe point; an action may have been sent", "exit_code": 130})
+                raise
+        if not result:
+            summary = run.summary if isinstance(getattr(run, "summary", None), dict) else {}
+            result = {**summary, "event": "result", "status": run.status}
+        if emit is output:
+            output(result)
+        else:
+            emit(result)
+            if result.get("markdown"):
+                emit.line("")
+                emit.line(result["markdown"].rstrip())
+        if caught:
+            return 128 + caught[0]
+        status = result.get("status") or run.status
+        if status == "error" and _no_phone(result):
+            return EXIT_COULDNT
+        return EXIT_OK if status in DONE else EXIT_FAILED
+    finally:
+        if emit is not output:
+            emit.close()
+        session.close()
+
+
+def dry_run(args, as_json):
+    """`mobster run --dry-run`: the plan from the task's words. No session, no journal, no phone, no model."""
+    from . import dry_run as plan_of
+    from .catalog import APPS
+    from .cli_run import output
+    from .permissions import from_env, project_policy
+    policy = None
+    if project_policy.enabled():
+        folder = project_policy.project_folder()
+        policy = project_policy.load(folder, project_policy.counts_path(None)) if folder else None
+    result = plan_of.plan(args.goal, apps=APPS, mode=from_env().mode, policy=policy, origin="cli")
+    if as_json:
+        output({"event": "dry_run", **result})
+    else:
+        print("\n".join(plan_of.lines(result)))
+    return 0
+
+
+def remember_only(goal):
+    """The things to remember when ``goal`` only asks Mobster to remember something, else None."""
+    try:
+        from .memory.extract import remember_only as only
+    except ImportError:  # a build without memory runs it as a task, as before
+        return None
+    return only(goal)
+
+
+def _no_phone(result):
+    text = f"{result.get('reason') or ''} {result.get('error') or ''}".lower()
+    return any(words in text for words in ("not reachable", "not answering", "unplugged", "no phone"))
+
+
+def _app_for(goal, session):
+    """The demo's app: the one the task names, else Settings (app_choice.infer_app, as the terminal UI does)."""
+    from .app_choice import infer_app
+    apps = session.apps()
+    app = infer_app(goal, apps)
+    return (app or next(a for a in apps if a["id"] == "settings"))["id"]
+
+
+def reassurance(request):
+    """The line under an approval: nothing is sent until the person chooses (MESSAGING §11)."""
+    if (request or {}).get("act") == "use app":
+        return "Mobster doesn't open it until you choose. If you're away, Mobster waits 10 minutes, then stops " \
+               "without opening it."
+    yes, _ = verbs(request or {})
+    done = REASSURANCE.get(yes.lower())
+    if done is None:
+        return ("Nothing happens until you choose. If you're away, Mobster waits 10 minutes, then stops without "
+                "doing it.")
+    verb = {"sent": "sending", "posted": "posting", "paid": "paying", "bought": "buying", "booked": "booking",
+            "deleted": "deleting"}[done]
+    return f"Nothing is {done} until you choose. If you're away, Mobster waits 10 minutes, then stops without " \
+           f"{verb} it."
+
+
+class Approver:
+    """Asks on the terminal: y or n (and a, on an app card); only an exact answer counts, and ctrl+c is no."""
+
+    def __init__(self, session, run, renderer):
+        self.session, self.run, self.renderer = session, run, renderer
+
+    def ask(self, event):
+        from .narrate import approval_title
+        from .style import palette
+        request = self.session.pending_approval(self.run) or {}
+        if not request:
+            return
+        paint = palette(sys.stdout)
+        yes, no = verbs(request or {})
+        pause = getattr(self.renderer, "pause", None)
+        if pause is not None:
+            pause()
+        lines = ["", "  " + paint("?", "accent", "bold") + " " + paint(approval_title(request), "bold")]
+        if request.get("explain"):
+            lines.append("    " + request["explain"])
+        if request.get("text"):
+            lines.append("    " + f"“{request['text']}”")
+        if request.get("act") == "use app" and request.get("reason"):
+            lines.append("    " + paint(request["reason"], "tertiary"))
+        lines.append("    " + paint(reassurance(request), "tertiary"))
+        # A task's app card: Allow covers this task, Always allow keeps its apps for later tasks.
+        app_card = request.get("act") == "use app" and request.get("rememberable")
+        always = (request.get("rememberLabel") or "Always allow") if app_card else None
+        lines.append("    " + paint("[y]", "accent", "bold") + f" {yes}   "
+                     + (paint("[a]", "bold") + f" {always}   " if always else "") + paint("[n]", "bold") + f" {no}")
+        print("\n".join(lines), flush=True)
+        answer, words = None, ("y", "a", "n") if always else ("y", "n")
+        while answer is None:
+            try:
+                line = input("    Type y, a or n, then Return: " if always else "    Type y or n, then Return: ")
+            except (EOFError, KeyboardInterrupt):
+                print()
+                answer = False
+                self.session.answer(request["id"], False, run=self.run)
+                self.session.stop(self.run)
+                break
+            word = line.strip().lower()
+            if word in words:
+                answer = "always" if word == "a" else word == "y"
+        if answer == "always":
+            self.session.answer(request["id"], True, run=self.run, remember=True)
+        elif answer:
+            self.session.answer(request["id"], True, run=self.run)
+        elif answer is False and self.session.pending_approval(self.run):
+            self.session.answer(request["id"], False, run=self.run)
+        resume = getattr(self.renderer, "resume", None)
+        if resume is not None:
+            resume()
+
+
+def long_plan(args, session, as_json):
+    from .cli_run import output
+    from .longform import budget as B
+    from .longform import plan as P
+    runtime = session.runtime
+    apps = P.runtime_apps(runtime)
+    forced = bool(getattr(args, "long", False) or getattr(args, "budget", None))
+    if forced and P.bulk_change(args.goal):
+        return {"longform": {}}         # no card: the start says why it isn't a long task (server.BULK_CHANGE_LONG)
+    kind = P.detect(args.goal, apps)
+    if kind is None and not forced:
+        return None
+    change = B.from_cli(args.budget) if getattr(args, "budget", None) else None
+    from .longform import enabled
+    if not enabled():
+        return None
+    card = P.make_plan(args.goal, apps=apps, limit_usd=runtime.task_cap(), nav_model=P.nav_model(),
+                       kind=kind or ("feed" if P.FEED_NOUN.search(args.goal) else "browse"), change=change)
+    P.store_for(runtime).put(card)
+    field = {"planId": card["id"]}
+    if change:
+        field["budget"] = change
+    cap = card.get("cap") or {}
+    explicit = getattr(args, "spend_cap_usd", None)
+    if as_json:
+        output({"event": "longform_plan", "plan": P.public(card), "revision": 0})
+        if cap.get("exceeds") and explicit and cap.get("limitUsd") is not None and explicit >= cap["limitUsd"]:
+            field["capUsd"] = round(explicit, 2)
+        return {"longform": field}
+    for line in card_lines(card):
+        print(line, flush=True)
+    yes = bool(getattr(args, "yes", False))
+    interactive = not yes and sys.stdin.isatty()
+    if interactive:
+        full = next((a for a in card.get("alternatives") or () if a.get("id") == "full"), None)
+        # "Use the full 10 minutes" -> "Start? [Y/n, f for the full 10 minutes]"
+        what = re.sub(r"^use\s+", "", (full or {}).get("label") or "", flags=re.I)
+        prompt = "  Start? [Y/n" + (f", f for {what}" if full else "") + "] "
+        answer = read(prompt)
+        if answer in ("n", "no", None):
+            print("  Not started.", flush=True)
+            return "cancelled"
+        if full is not None and answer in ("f", "full"):
+            field["alternative"] = "full"
+            cap = {**cap, "exceeds": full.get("exceeds"), "proposedUsd": full.get("proposedUsd")}
+    if cap.get("exceeds"):
+        if explicit and cap.get("limitUsd") is not None and explicit >= cap["limitUsd"]:
+            field["capUsd"] = round(explicit, 2)
+        elif cap.get("proposedUsd") and interactive:
+            if ask(f"  This may cost more than your ${cap['limitUsd']:.2f} limit per task. Allow up to "
+                   f"${cap['proposedUsd']:.2f}? [y/N] ", default=False):
+                field["capUsd"] = cap["proposedUsd"]
+    return {"longform": field}
+
+
+def read(prompt):
+    """The answer typed at ``prompt``, folded; None when the input ended (ctrl+d, ctrl+c)."""
+    try:
+        return input(prompt).strip().casefold()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return None
+
+
+def ask(prompt, default):
+    answer = read(prompt)
+    if answer is None:
+        return False
+    if not answer:
+        return default
+    return answer in ("y", "yes")
+
+
+def card_lines(card):
+    """The plan card as text: the summary, the steps, the estimate, the policy lines and the cap."""
+    from .longform.context import duration
+    estimate = card.get("estimate") or {}
+    lines = ["", "  " + str(card.get("summary") or card.get("title") or "")]
+    for step in card.get("steps") or ():
+        lines.append(f"    {step['id']}. {step['title']}")
+    cents = estimate.get("usd")
+    facts = [f"About {duration(estimate.get('phoneSeconds') or 0)} on your iPhone",
+             f"about ${cents:.2f}" if isinstance(cents, (int, float)) else None,
+             f"report about {estimate.get('reportSeconds')} s later" if estimate.get("reportSeconds") else None]
+    lines.append("  " + ", ".join(f for f in facts if f) + ".")
+    for alternative in card.get("alternatives") or ():
+        if alternative.get("id") == "full":
+            lines.append(f"  Or {alternative['label'][:1].lower() + alternative['label'][1:]}: about "
+                         f"${alternative['lowUsd']:.2f} to ${alternative['highUsd']:.2f}.")
+    for line in (card.get("policy") or {}).get("lines") or ():
+        lines.append("  " + line)
+    return lines
+
+
+class Progress:
+    """Progress lines for a long task on a terminal: one every 10 items, the phone handed back, the report."""
+
+    def __init__(self, renderer):
+        self.renderer = renderer
+        self.printed = 0
+        self.noun = "items"
+
+    def say(self, text):
+        if self.renderer is not None:
+            self.renderer.line("  " + text)
+
+    def take(self, event):
+        """True when ``event`` is a long task's and was handled here (the step renderer never sees it)."""
+        kind = event.get("event")
+        if not str(kind or "").startswith("longform_") and kind != "phone_released":
+            return False
+        if kind == "longform_plan":
+            self.noun = ((event.get("plan") or {}).get("budget") or {}).get("itemNoun") or self.noun
+        elif kind == "longform_progress":
+            items = event.get("items") or {}
+            kept = int(items.get("kept") or 0)
+            if kept >= self.printed + 10:
+                self.printed = kept - kept % 10
+                verb = "Read" if event.get("phase") == "reading" else "Watched"
+                skipped = []
+                if items.get("ads"):
+                    skipped.append(f"{items['ads']} ad{'s' if items['ads'] != 1 else ''}")
+                if items.get("repeats"):
+                    skipped.append(f"{items['repeats']} repeat{'s' if items['repeats'] != 1 else ''}")
+                self.say(f"{verb} {self.printed} {self.noun}"
+                         + (f", {' and '.join(skipped)} skipped" if skipped else ""))
+        elif kind == "phone_released":
+            self.say("Your iPhone is free to use. Writing the report…")
+        elif kind == "longform_step" and event.get("state") == "done" and event.get("result"):
+            self.say(f"Step {event.get('stepId')} done: {event['result'][:120]}")
+        return True