mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/tui/session.py

@@ -0,0 +1,308 @@
+"""The terminal UI's engine: the same ``server.Runtime`` that `mobster serve` and the Mac app run."""
+
+import time
+from pathlib import Path
+
+from .. import serve, server
+from ..api_errors import APIError
+from ..cli_constants import DEFAULT_WDA_URL
+from ..journal import JournalError, LeaseHeld
+from ..paths import default_history_db, user_data_dir
+from ..transport import wda_screenshot
+
+
+def serve_config(**overrides):
+    """A config with exactly the attributes `mobster serve` would parse, then ``overrides``."""
+    from ..cli_parser import build_parser
+    config = build_parser().parse_args(["serve"])
+    for name, value in overrides.items():
+        setattr(config, name, value)
+    return config
+
+
+class TerminalRuntime(server.Runtime):
+    """``server.Runtime`` plus the USB iPhone's installed apps when no device manager runs."""
+
+    one_target = True  # its phone is --wda-url / --device; it never reads the device list to choose one
+
+    def __init__(self, config):
+        super().__init__(config)
+        if self.installed_apps is None and config.wda_url and _is_usb_relay(config.wda_url):
+            from ..device_manager import DeviceManager
+            from ..installed_apps import InstalledApps
+            data_dir = getattr(config, "data_dir", None) or user_data_dir()
+            manager = _phone_manager(data_dir, config.wda_url) or DeviceManager(data_dir, config.wda_url)
+            self.installed_apps = InstalledApps(manager.device)
+
+
+def _is_usb_relay(url):
+    """True for the USB relay's own address (8100), or another iPhone's (8101-8199, devices.py)."""
+    from ..devices import FIRST_SLOT, LAST_SLOT, WDA_BASE, port_of
+    url = url.rstrip("/")
+    port = port_of(url)
+    return (url.startswith(("http://127.0.0.1:", "http://localhost:")) and port is not None
+            and WDA_BASE <= port <= WDA_BASE + LAST_SLOT and (port == WDA_BASE or port - WDA_BASE >= FIRST_SLOT))
+
+
+def _phone_manager(data_dir, url):
+    """The device manager of the iPhone set up besides the first one whose relay is ``url`` (8101-8199)."""
+    from ..devices import DeviceStore, manager_for, port_of
+    port = port_of(url)
+    entry = next((item for item in DeviceStore(data_dir).phones() if item["wdaPort"] == port), None)
+    return manager_for(entry["udid"], data_dir) if entry else None
+
+
+class DemoRuntime(server.Runtime):
+    """The real runtime and Mobster's agent over a scripted phone and model (``demo_phone``). No network."""
+
+    one_target = True
+    needs_plan = False  # it never acts on a phone (plan_gate)
+    pace = 1.0
+
+    def target_status(self):
+        return {"device": True, "ready": True, "health": None, "can_act": True, "driver": "demo",
+                "screen_reading": False}
+
+    def status(self):
+        value = super().status()
+        value.update(live_enabled=not self.closing, device="Scripted demo iPhone", limitations=[], demo=True)
+        return value
+
+    def check_app(self, app):
+        pass
+
+    def smart_client(self):
+        from .demo_phone import DemoChat
+        return DemoChat(self.pace)
+
+    def open_driver(self, run, trace, setup):
+        from .demo_phone import DemoPhone
+        driver = setup.hold(DemoPhone(run.app["bundleId"], run.goal, self.pace))
+        if run.stop.is_set():
+            return None
+        run.emit({"event": "app_launch_started", "app": run.app["name"]})
+        setup.phase("launching")
+        driver._wait(.3)
+        run.emit({"event": "app_launch_acknowledged", "app": run.app["name"]})
+        setup.phase("reading_app")
+        return driver
+
+
+class Session:
+    """One terminal session: a runtime, its running task and settings. Methods may block,
+    so the UI calls them off its event loop."""
+
+    def __init__(self, *, wda_url=None, env_file=None, demo=False, history_db=None, spend_cap_usd=None, pace=1.0,
+                 origin="tui"):
+        """``history_db``: its journal (default: the terminal's; a demo keeps tasks in memory). ``origin``:
+        "tui" or "cli"."""
+        self.demo = demo
+        self.origin = origin
+        if env_file:
+            from ..config import load_env_file
+            # "~/keys.env" as typed (`--env-file=~/…` reaches us unexpanded): read and save in the home folder.
+            env_file = Path(env_file).expanduser()
+            load_env_file(env_file)
+        if demo:
+            # Its own lease key and no journal: a demo never waits for, or blocks, another Mobster.
+            import uuid
+            config = serve_config(wda_url=f"demo://phone/{uuid.uuid4().hex[:8]}", enable_live=True,
+                                  state_db=None, env_file=None, spend_cap_usd=spend_cap_usd)
+            runtime_class = type("DemoRuntime", (DemoRuntime,), {"pace": pace})
+        else:
+            import os
+            config = serve_config(wda_url=wda_url or os.environ.get("MOBSTER_WDA_URL") or DEFAULT_WDA_URL,
+                                  enable_live=os.environ.get("MOBSTER_ENABLE_LIVE", "1") != "0",
+                                  state_db=history_db if history_db is not None else default_history_db(),
+                                  env_file=env_file, spend_cap_usd=spend_cap_usd)
+            runtime_class = serve.runtime_class_for(config, TerminalRuntime)
+        self.config = config
+        try:
+            self.runtime = runtime_class(config)
+        except LeaseHeld:
+            # The terminal UI and `mobster run` share one task history, and one process at a time may hold it.
+            raise LeaseHeld("Another Mobster has this task history open, such as the terminal UI or a `mobster run` "
+                            "in another terminal. Use that one or wait for it to finish, then try again.") from None
+        self.run = None
+
+    @property
+    def wda_url(self):
+        return None if self.demo else self.config.wda_url
+
+    def status(self):
+        return self.runtime.status()
+
+    def apps(self, fresh=False):
+        """The apps a task can open: the catalog, plus the phone's own when they can be read."""
+        installed = getattr(self.runtime, "installed_apps", None)
+        if fresh and installed is not None:
+            installed.refresh()
+        return self.runtime.apps()
+
+    def settings(self):
+        return self.runtime.settings()
+
+    def set_setting(self, name, value):
+        """askBeforeActing. Saved to the env file when there is one, like the Mac app."""
+        return self.runtime.update_settings({name: bool(value)})
+
+    @property
+    def spend_cap_usd(self):
+        return getattr(self.config, "spend_cap_usd", None)
+
+    def set_spend_cap(self, usd):
+        """A cap in dollars for the next task, or None for no cap."""
+        if usd is not None:
+            from ..costs import usd_to_nanodollars
+            usd_to_nanodollars(usd)  # validates
+        self.config.spend_cap_usd = usd
+
+    def _await_phone_release(self):
+        """The last task has published its result; its worker releases the phone a moment later. Wait up to 3 s."""
+        previous = self.run
+        if previous is None or previous.finished_at is None:
+            return
+        deadline = time.monotonic() + 3
+        while self.runtime.capacity() == 0 and time.monotonic() < deadline:
+            with self.runtime.lock:
+                if previous.id not in self.runtime.active_runs:
+                    break
+            time.sleep(.02)
+
+    def start(self, app_id, goal, *, output_format="auto"):
+        """Start a task on the phone. Raises ValueError or APIError with a message for the user."""
+        self._await_phone_release()
+        run = self.runtime.create(app_id, goal, "live", output_format=output_format, origin=self.origin)
+        self.run = run
+        return run
+
+    def threads(self):
+        """The runtime's ThreadService, or None when conversations are not running."""
+        from ..threads.service import service_for
+        return service_for(self.runtime)
+
+    def recent_threads(self, limit=30):
+        live = self.threads()
+        if live is None:
+            return []
+        return live.store.list(limit=limit)[0]
+
+    def new_thread(self):
+        live = self.threads()
+        return live.create_thread() if live is not None else None
+
+    def send(self, thread_id, text, *, app_id=None, attachments=None, output_format="auto"):
+        """A message to a conversation."""
+        live = self.threads()
+        body = {"text": text, "outputFormat": output_format, "mode": "auto"}
+        if app_id:
+            body["appId"] = app_id
+        if attachments:
+            body["attachmentIds"] = list(attachments)
+        self._await_phone_release()
+        status, response = live.message(thread_id, body, origin=self.origin)
+        routed = response.get("routed") or ("new_run" if response.get("run") else "steer")
+        run = None
+        if response.get("run"):
+            run = self.runtime.runs.get(response["run"]["id"])
+            self.run = run
+        return routed, run, response
+
+    def attach(self, path, thread_id=None):
+        """Attach a file for the next task: (attachment id, its name and size in words). Raises ValueError."""
+        path = Path(path).expanduser()
+        if not path.is_file():
+            raise ValueError(f"There's no file at {path}.")
+        from ..attachments.service import store_for
+        from ..attachments.store import FILE_MAX
+        store = store_for(self.runtime)
+        if store is None:
+            raise ValueError("Attaching files needs Mobster's task history, which this window doesn't keep.")
+        if path.stat().st_size > FILE_MAX:
+            raise ValueError("Attach files of 25 MB or less.")
+        attachment = store.create(path.read_bytes(), path.name, thread_id=thread_id)
+        return attachment.public()
+
+    def stop(self, run=None):
+        run = run or self.run
+        if run is not None and run.finished_at is None:
+            self.runtime.stop_run(run.id)
+
+    def answer(self, approval_id, approve, choice=None, run=None, remember=False):
+        """Answer the run's pending approval; ``remember``: its "Don't ask again" (Always allow on an app card)."""
+        run = run or self.run
+        return bool(run and run.answer_approval(approval_id, approve, choice, remember=remember))
+
+    def pending_approval(self, run=None):
+        """The live approval request (with the exact text to be typed), or None."""
+        run = run or self.run
+        if run is None:
+            return None
+        with run.condition:
+            return dict(run.approval) if run.approval else None
+
+    def follow(self, run, on_event, *, stop=None):
+        """Call ``on_event(event)`` for each of the run's events, in order, until it finishes."""
+        index = 0
+        while stop is None or not stop.is_set():
+            with run.condition:
+                while index >= len(run.events) and run.finished_at is None and not (stop and stop.is_set()):
+                    run.condition.wait(timeout=.5)
+                batch = run.events[index:]
+                finished = run.finished_at is not None
+            for event in batch:
+                on_event(event)
+            index += len(batch)
+            if finished and index >= len(run.events):
+                return
+
+    def preview_image(self, run=None):
+        """The phone's latest screen as PNG bytes, or None. Captured the way the Mac app's live view is."""
+        import base64
+        run = run or self.run
+        image = None
+        if run is not None and run.finished_at is None:
+            image = self.runtime.preview(run).get("image")
+        elif run is not None and run.image:
+            image = run.image
+        if image is None and not self.demo and self.config.wda_url:
+            image = wda_screenshot(self.config.wda_url)
+        if image is None and self.demo and run is None:
+            from .demo_phone import SETTINGS, render_screen
+            return render_screen(SETTINGS, "top")
+        if isinstance(image, str) and image.startswith("data:image"):
+            try:
+                return base64.b64decode(image.split(",", 1)[1])
+            except (ValueError, IndexError):
+                return None
+        return None
+
+    def history(self):
+        """Runs in the journal, newest first."""
+        with self.runtime.lock:
+            runs = list(self.runtime.runs.values())
+        return sorted(runs, key=lambda run: run.created_at, reverse=True)
+
+    def find(self, prefix):
+        prefix = (prefix or "").strip().lower()
+        matches = [run for run in self.history() if run.id.startswith(prefix)] if prefix else []
+        return matches[0] if len(matches) == 1 else None
+
+    def close(self, timeout=10):
+        try:
+            if self.run is not None and self.run.finished_at is None:
+                self.runtime.stop_run(self.run.id)
+        except Exception:
+            pass
+        return self.runtime.close(timeout)
+
+
+def error_text(error):
+    """A one-line message for an exception from the runtime, for the user."""
+    if isinstance(error, (APIError, ValueError, JournalError)):
+        text = str(error)
+        if getattr(error, "code", None) == "engine_unavailable" and "_API_KEY" in text:
+            # The runtime's reason names the env file the Mac app's sidecar reads; here `mobster login` adds a key.
+            return "Mobster's agent needs your Claude or OpenAI key first: mobster login adds it."
+        return text
+    return f"{type(error).__name__}: {str(error)[:200]}"

mobile_agent/tui/tasks.py

@@ -0,0 +1,287 @@
+"""The terminal UI's tasks: starting one, steering it, answering its approvals."""
+
+from rich.text import Text
+from textual import work
+from textual.containers import VerticalScroll
+from textual.css.query import NoMatches
+from textual.widgets import Input, Static
+
+from ..narrate import status_tone
+from .render import ACCENT, FAINT, GREEN, MUTED, RED, TEXT
+from .screens import AskScreen
+from .widgets import NEXT_PLACEHOLDER, PLACEHOLDER, STEER_PLACEHOLDER, ApprovalCard, Composer, RunView
+
+
+class TaskMixin:
+    """Running a task for the app: submit it on a worker, show its events, steer it, answer its approvals."""
+
+    def start_task(self, app, goal):
+        if app is not None:
+            self.last_app = app
+        self.app_choice = None
+        self.query_one("#composer", Composer).add_class("busy")
+        attachments = [item["id"] for item in self.attachments]
+        self.attachments = []
+        self.refresh_notice()
+        self.submit_task(app, goal, self.output_format, attachments)
+
+    def default_app(self):
+        """Where a task that names no app starts: the Home Screen; Settings for the demo, which needs an app."""
+        if self.demo:
+            return self.last_app or next(a for a in self.apps if a["id"] == "settings")
+        return None
+
+    @work(thread=True, group="run")
+    def submit_task(self, app, goal, output_format, attachments=()):
+        from .session import error_text
+        app = app or self.default_app()
+        app_id = app["id"] if app else None
+        try:
+            threads = self.session.threads()
+            if threads is not None:
+                thread_id = self.thread_id or self.session.new_thread()["id"]
+                if thread_id != self.thread_id:
+                    self.thread_id = thread_id
+                    self.remember_thread(thread_id)
+                routed, run, response = self.session.send(thread_id, goal, app_id=app_id, attachments=attachments,
+                                                           output_format=output_format)
+                if routed == "remember":
+                    self.call_from_thread(self.offer_to_remember, goal, response.get("proposals") or [])
+                    return
+                if run is None:
+                    self.call_from_thread(self.task_idle)
+                    return
+            else:
+                if attachments:
+                    raise ValueError("Attaching files needs Mobster's task history, which this window doesn't keep.")
+                offered = self.remember_here(goal)
+                if offered is not None:
+                    self.call_from_thread(self.offer_to_remember, goal, offered)
+                    return
+                run = self.session.start(app_id, goal, output_format=output_format)
+        except Exception as error:
+            self.call_from_thread(self.task_refused, app, goal, error_text(error))
+            return
+        self.call_from_thread(self.task_started, run)
+        self.session.follow(run, lambda event: self.call_from_thread(self.task_event, run, event),
+                            stop=self.follow_stop)
+
+    def remember_here(self, goal):
+        """Without conversations (the demo): a "Remember that …" message becomes proposals,
+        else None to run it as a task."""
+        from ..memory import extract
+        from ..memory.store import default_store
+        found = extract.remember_only(goal)
+        if not found:
+            return None
+        if self.demo:
+            return [{"id": None, "text": candidate.text, "pin": candidate.pin} for candidate in found]
+        store = default_store()
+        if store is None:
+            return None
+        made = []
+        for candidate in found:
+            proposal = store.propose(candidate.text, "global", pin=candidate.pin)
+            if proposal is not None:
+                made.append({"id": proposal["id"], "text": proposal["text"], "pin": proposal["pin"]})
+        return made
+
+    def task_idle(self):
+        self.query_one("#composer", Composer).remove_class("busy")
+
+    def offer_to_remember(self, goal, proposals):
+        """A message that only asked Mobster to remember something: one card per suggestion, Remember or Not now."""
+        self.task_idle()
+        self.show_welcome(False)
+        transcript = self.query_one("#transcript", VerticalScroll)
+        line = Text()
+        line.append("❯ ", style=f"bold {ACCENT}")
+        line.append(goal, style=f"bold {TEXT}")
+        box = Static(line, classes="run")
+        transcript.mount(box)
+        if not proposals:
+            self.note("Mobster already has this.")
+            return
+        pending = list(proposals)
+
+        def ask_next():
+            if not pending:
+                return
+            proposal = pending.pop(0)
+            body = (f"“{proposal['text']}”\n\n" + ("It goes with every task (pinned). " if proposal.get("pin") else
+                                                    "Mobster will use it in tasks it fits. ")
+                    + "It stays on this Mac.")
+
+            def answered(yes):
+                self.answer_proposal(proposal, bool(yes))
+                ask_next()
+            self.push_screen(AskScreen("Remember this?", body, "Remember", "Not now"), answered)
+        ask_next()
+
+    @work(thread=True, group="memory")
+    def answer_proposal(self, proposal, yes):
+        message = "Mobster will remember this." if yes else "Not remembered."
+        try:
+            from ..memory.store import default_store
+            store = default_store()
+            if proposal.get("id"):
+                store.resolve_proposal(proposal["id"], yes)
+            elif yes and not self.demo:
+                store.add_fact(proposal["text"], pinned=bool(proposal.get("pin")))
+            elif yes and self.demo:
+                message = "The demo doesn't save anything; `mobster` would remember this."
+        except Exception as error:  # noqa: BLE001 -- the store's own sentence
+            message = str(error)
+        self.call_from_thread(self.proposal_answered, yes, message)
+
+    def proposal_answered(self, yes, message):
+        text = Text()
+        text.append("  ✓ " if yes else "  – ", style=GREEN if yes else FAINT)
+        text.append(message, style=MUTED)
+        line = Static(text, classes="item")
+        self.query_one("#transcript", VerticalScroll).mount(line)
+        self.query_one("#transcript", VerticalScroll).scroll_end(animate=False)
+
+    def steer(self, text):
+        """A message to the running task: it reads it before its next step (Mobster's agent only)."""
+        run = self.running
+        if run is None or self.session is None:
+            return
+        if self.run_view is not None:
+            self.run_view.note(f"While Mobster worked, you said “{text}”", MUTED)
+        self.send_steer(run, text)
+
+    @work(thread=True, group="steer")
+    def send_steer(self, run, text):
+        from .session import error_text
+        try:
+            if self.thread_id and self.session.threads() is not None:
+                self.session.send(self.thread_id, text)
+            else:
+                run.steer(text, source="tui")
+        except Exception as error:
+            self.call_from_thread(self.note, error_text(error), "warning")
+
+    def task_refused(self, app, goal, message):
+        self.task_idle()
+        transcript = self.query_one("#transcript", VerticalScroll)
+        view = Static(classes="run")
+        text = Text()
+        text.append("❯ ", style=f"bold {ACCENT}")
+        text.append(goal, style=f"bold {TEXT}")
+        if app:
+            text.append(f"  {app['name']}", style=FAINT)
+        text.append("\n\n")
+        text.append("✗ Couldn't start  ", style=f"bold {RED}")
+        text.append(message + "\n", style=TEXT)
+        if self.needs_setup():
+            text.append("\n")
+            text.append_text(self.setup_hints())
+        prompt = self.query_one("#prompt", Input)
+        if not prompt.value.strip():
+            # The task waits in the box, so enter runs it once what was missing is there.
+            prompt.value = goal
+            prompt.cursor_position = len(goal)
+            text.append("\nYour task is back in the box: press enter when you're set.\n", style=FAINT)
+        view.update(text)
+        self.show_welcome(False)
+        transcript.mount(view)
+        transcript.scroll_end(animate=False)
+        self.recall_index = None
+
+    def task_started(self, run):
+        self.show_welcome(False)
+        self.running = run
+        self.run_view = RunView(run, self.apps)
+        self.finished_views.append(self.run_view)
+        transcript = self.query_one("#transcript", VerticalScroll)
+        transcript.mount(self.run_view)
+        transcript.scroll_end(animate=False)
+        prompt = self.query_one("#prompt", Input)
+        prompt.placeholder = STEER_PLACEHOLDER if run.steerable else "Mobster is working… esc stops it"
+        self.refresh_chip()
+        self.refresh_status()
+        self.poll_phone()
+
+    def task_event(self, run, event):
+        view = self.run_view
+        if view is None or view.run is not run:
+            return
+        changed = view.feed(event)
+        kind = event.get("event")
+        if kind == "approval_requested":
+            request = self.session.pending_approval(run)
+            if request:
+                self.show_approval(request)
+        elif kind == "approval_resolved":
+            self.hide_approval()
+        elif kind == "run_finished":
+            self.task_finished(run)
+        if changed:
+            transcript = self.query_one("#transcript", VerticalScroll)
+            if transcript.max_scroll_y - transcript.scroll_y < 6 or kind == "run_finished":
+                transcript.scroll_end(animate=False)
+        if kind in {"observation", "observation_after_action", "run_finished"} or (
+                not self.image_class and kind in {"decision", "action_started", "action_acknowledged"}):
+            self.poll_phone()
+        self.refresh_status()
+
+    def task_finished(self, run):
+        self.running = None
+        self.tasks_done += 1
+        self.hide_approval()
+        self.task_idle()
+        status = run.status
+        if self.bell_enabled and status_tone(status) in {"error", "warning"}:
+            self.bell()
+        self.refresh_status()
+        self.refresh_chip()
+        self.query_one("#prompt", Input).focus()
+        if status == "approval_denied":
+            self.query_one("#prompt", Input).placeholder = "Tell Mobster what to do instead…  (↑ for the last task)"
+        else:
+            self.query_one("#prompt", Input).placeholder = NEXT_PLACEHOLDER if self.thread_id else PLACEHOLDER
+
+    def approval_open(self):
+        try:
+            return self.query_one(ApprovalCard).has_class("open")
+        except NoMatches:
+            return False
+
+    def show_approval(self, request):
+        card = self.query_one(ApprovalCard)
+        card.ask(request)
+        card.add_class("open")
+        card.focus()
+        self.refresh_status()
+        if self.bell_enabled:
+            self.bell()
+
+    def hide_approval(self):
+        card = self.query_one(ApprovalCard)
+        if card.has_class("open"):
+            card.remove_class("open")
+            card.request = None
+            self.query_one("#prompt", Input).focus()
+            self.refresh_status()
+
+    def answer_approval(self, request, choice):
+        if not request or self.session is None:
+            return
+        run = self.running
+        approve = choice != "__no"
+        picked = None if choice in {"__yes", "__always", "__no"} else choice
+        self.hide_approval()
+        self.send_answer(run, request["id"], approve, picked, remember=choice == "__always")
+
+    @work(thread=True, group="answer")
+    def send_answer(self, run, approval_id, approve, choice, remember=False):
+        try:
+            self.session.answer(approval_id, approve, choice, run=run, remember=remember)
+        except Exception as error:
+            from .session import error_text
+            self.call_from_thread(self.note, error_text(error), "error")
+
+    def note(self, message, tone="neutral"):
+        self.notify(message, severity={"warning": "warning", "error": "error"}.get(tone, "information"),
+                    timeout=4)