mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/threads/client.py

@@ -0,0 +1,326 @@
+"""A small client for the running Mobster's HTTP API: `mobster chat` and MCP's ``phone_task`` use it."""
+
+import http.client
+import json
+import os
+import socket
+import time
+from pathlib import Path
+from urllib.parse import quote, urlsplit
+
+DEFAULT_URL = "http://127.0.0.1:8765"
+LOCAL_HOSTS = ("127.0.0.1", "localhost")
+NOT_RUNNING = "Open Mobster or run `mobster serve` to chat."
+NO_THREADS = "This Mobster doesn't have conversations yet. Update Mobster, then try again."
+REFUSED = ("Mobster is running, but its token isn't readable here. Run this as the same user, or set "
+           "MOBSTER_API_TOKEN_FILE to the token file `mobster serve` printed.")
+NOT_LOCAL = "Mobster's address must be on this Mac (127.0.0.1 or localhost)."
+
+
+class NoService(Exception):
+    """Nothing answers at the address, or it isn't Mobster."""
+
+    frozen = False
+
+
+class ServiceError(Exception):
+    """An HTTP error from Mobster: ``status``, ``code`` and the sentence it sent."""
+
+    def __init__(self, status, data):
+        self.status = status
+        self.data = data if isinstance(data, dict) else {}
+        self.code = self.data.get("code")
+        super().__init__(self.data.get("error") or f"Mobster answered {status}")
+
+
+def default_url():
+    """$MOBSTER_URL, else the address a running service wrote beside its token file, else 8765."""
+    return (os.environ.get("MOBSTER_URL") or "").strip() or discovered_url() or DEFAULT_URL
+
+
+def written_urls():
+    """The addresses in the `api-url` files (the Mac app's data folder, then a source checkout's .state) that are on
+    this Mac, whether or not anything answers there. A service that crashed leaves its file behind; a clean exit
+    removes it."""
+    from ..paths import source_checkout, user_data_dir
+    files = [user_data_dir() / "state" / "api-url"]
+    if source_checkout():
+        files.append(Path(__file__).resolve().parent.parent / ".state" / "api-url")
+    urls = []
+    for path in files:
+        try:
+            url = path.read_text().strip()
+        except (OSError, UnicodeDecodeError):
+            continue
+        parts = urlsplit(url)
+        try:
+            port = parts.port
+        except ValueError:
+            continue
+        if parts.scheme == "http" and (parts.hostname or "") in LOCAL_HOSTS and port:
+            urls.append(f"http://{parts.hostname}:{port}")
+    return urls
+
+
+def service_urls():
+    """Where a Mobster service on this Mac is meant to answer: $MOBSTER_URL when it is set, else the addresses services
+    wrote (``written_urls``), answering or not."""
+    return [url] if (url := (os.environ.get("MOBSTER_URL") or "").strip()) else written_urls()
+
+
+def discovered_url():
+    """The first written address that is on this Mac and accepts a connection. A file left by a crashed service names a
+    port nobody holds, so it is skipped."""
+    for url in written_urls():
+        parts = urlsplit(url)
+        try:
+            socket.create_connection((parts.hostname, parts.port), timeout=0.2).close()
+        except OSError:
+            continue
+        return url
+    return None
+
+
+def token_candidates():
+    """Tokens to try, in order (values, never printed)."""
+    from ..paths import source_checkout, user_data_dir
+    seen = []
+    value = os.environ.get("MOBSTER_API_TOKEN", "").strip()
+    if value:
+        seen.append(value)
+    files = []
+    if os.environ.get("MOBSTER_API_TOKEN_FILE"):
+        files.append(Path(os.environ["MOBSTER_API_TOKEN_FILE"]).expanduser())
+    files.append(user_data_dir() / "state" / "api-token")
+    if source_checkout():
+        files.append(Path(__file__).resolve().parent.parent / ".state" / "api-token")
+    for path in files:
+        try:
+            text = path.read_text().strip()
+        except (OSError, UnicodeDecodeError):
+            continue
+        if text and text not in seen:
+            seen.append(text)
+    return seen
+
+
+class Client:
+    def __init__(self, url=None, token=None, origin="cli", timeout=10.0, extra_headers=None):
+        parts = urlsplit(url or default_url())
+        if parts.scheme != "http" or (parts.hostname or "") not in LOCAL_HOSTS:
+            raise NoService(NOT_LOCAL)
+        self.host, self.port = parts.hostname, parts.port or 80
+        self.url = f"http://{self.host}:{self.port}"
+        self.token, self.origin, self.timeout = token, origin, timeout
+        # Sent with every request (Mobster Remote's X-Mobster-Remote-Grant).
+        self.extra_headers = dict(extra_headers or {})
+        self.status = {}
+        self._app_session = False
+
+    @classmethod
+    def connect(cls, url=None, origin="cli", tokens=None, timeout=10.0):
+        """A client whose token the service accepts."""
+        refused = False
+        for token in (token_candidates() if tokens is None else tokens) or [None]:
+            client = cls(url, token, origin, timeout=timeout)
+            try:
+                status = client.call("GET", "/api/status")
+            except ServiceError as error:
+                if error.status == 401:
+                    refused = True
+                    continue
+                raise NoService(NOT_RUNNING) from None
+            if not isinstance(status, dict) or "api_version" not in status:
+                raise NoService(NOT_RUNNING)
+            client.status = status
+            client._app_session = bool(status.get("app_session"))
+            return client
+        if refused:
+            raise ServiceError(401, {"error": REFUSED, "code": "unauthorized"})
+        raise NoService(NOT_RUNNING)
+
+    @property
+    def has_threads(self):
+        return (self.status.get("extensions") or {}).get("threads") == "ok"
+
+    def _connection(self, timeout):
+        return http.client.HTTPConnection(self.host, self.port, timeout=timeout)
+
+    def headers(self, extra=None):
+        headers = {"Accept": "application/json", "X-Mobster-Origin": self.origin}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        headers.update(self.extra_headers)
+        headers.update(extra or {})
+        return headers
+
+    def call(self, method, path, body=None, *, key=None, timeout=None, raw=None, content_type=None):
+        """The JSON answer of one request. ServiceError for a 4xx/5xx; NoService when nothing answers."""
+        headers = self.headers({"Idempotency-Key": key} if key else None)
+        data = None
+        if raw is not None:
+            data = raw
+            headers["Content-Type"] = content_type or "application/octet-stream"
+        elif body is not None or method == "POST":
+            data = json.dumps(body if body is not None else {}).encode()
+            headers["Content-Type"] = "application/json"
+        if data is not None:
+            headers["Content-Length"] = str(len(data))
+        connection = self._connection(timeout or self.timeout)
+        try:
+            connection.request(method, path, body=data, headers=headers)
+            response = connection.getresponse()
+            payload = response.read()
+        except (ConnectionError, socket.timeout, TimeoutError, OSError, http.client.HTTPException) as error:
+            silent = NoService(NOT_RUNNING)
+            silent.frozen = isinstance(error, (socket.timeout, TimeoutError))
+            raise silent from None
+        finally:
+            connection.close()
+        try:
+            value = json.loads(payload) if payload else {}
+        except ValueError:
+            value = {}
+        if response.status >= 400:
+            raise ServiceError(response.status, value)
+        return value
+
+    def events(self, path, last_id=None, timeout=30.0):
+        """Server-sent events of ``path``: yields each event's data (a dict), and None for a keepalive."""
+        headers = self.headers({"Accept": "text/event-stream"})
+        if last_id is not None:
+            headers["Last-Event-ID"] = str(last_id)
+        connection = self._connection(timeout)
+        try:
+            connection.request("GET", path, headers=headers)
+            response = connection.getresponse()
+        except (ConnectionError, socket.timeout, TimeoutError, OSError, http.client.HTTPException):
+            connection.close()
+            raise NoService(NOT_RUNNING) from None
+        if response.status >= 400:
+            payload = response.read()
+            connection.close()
+            try:
+                raise ServiceError(response.status, json.loads(payload))
+            except ValueError:
+                raise ServiceError(response.status, {}) from None
+        try:
+            data = []
+            while True:
+                line = response.readline()
+                if not line:
+                    return
+                line = line.decode("utf-8", "replace").rstrip("\r\n")
+                if line.startswith(":"):
+                    yield None
+                elif line.startswith("data:"):
+                    data.append(line[5:].lstrip())
+                elif not line and data:
+                    try:
+                        yield json.loads("\n".join(data))
+                    except ValueError:
+                        pass
+                    data = []
+        finally:
+            connection.close()
+
+    def thread(self, thread_id):
+        return self.call("GET", f"/api/threads/{quote(thread_id, safe='')}")
+
+    def run(self, run_id):
+        return self.call("GET", f"/api/runs/{quote(run_id, safe='')}")["run"]
+
+    def send(self, thread_id, body, key=None):
+        """POST a message; a new thread when ``thread_id`` is None. Returns (thread id, response)."""
+        if thread_id is None:
+            answer = self.call("POST", "/api/threads", {"message": body}, key=key)
+            return answer["thread"]["id"], answer
+        return thread_id, self.call("POST", f"/api/threads/{quote(thread_id, safe='')}/messages", body, key=key)
+
+    def workflows(self):
+        """The saved workflows (GET /api/workflows), each with its blanks."""
+        return self.call("GET", "/api/workflows").get("workflows") or []
+
+    def workflow_tools(self):
+        """Each workflow made a tool (GET /api/workflows/tools): its MCP name, REST path and input schema."""
+        return self.call("GET", "/api/workflows/tools").get("tools") or []
+
+    def find_workflow(self, wanted):
+        """A workflow by its id or its name (case and spacing ignored). LookupError says what's wrong."""
+        wanted = " ".join(str(wanted or "").split())
+        listed = self.workflows()
+        found = [w for w in listed if w.get("id") == wanted.lower()] or [
+            w for w in listed if " ".join(str(w.get("name") or "").split()).casefold() == wanted.casefold()]
+        if not found:
+            names = ", ".join(f"“{w.get('name')}”" for w in listed[:8])
+            raise LookupError(f"No workflow is called {wanted}." + (f" Yours: {names}." if names else
+                                                                     " Save one in Mobster first."))
+        if len(found) > 1:
+            raise LookupError(f"Several workflows are called {wanted}. Give its id: "
+                              + ", ".join(w["id"] for w in found))
+        return found[0]
+
+    def run_workflow(self, workflow_id, *, values=None, thread_id=None, new_conversation=False, key=None):
+        """POST /api/workflows/{id}/run. Returns (thread id or None, response with run and replayed)."""
+        import uuid
+        body = {}
+        if values:
+            body["values"] = values
+        if thread_id:
+            body["threadId"] = thread_id
+        if new_conversation:
+            body["newConversation"] = True
+        answer = self.call("POST", f"/api/workflows/{quote(workflow_id, safe='')}/run", body,
+                           key=key or uuid.uuid4().hex)
+        return answer.get("threadId"), answer
+
+    def workflow_runs(self, workflow_id):
+        """A workflow's newest runs (GET /api/workflows/{id}/runs), each graph run with its nodes."""
+        return self.call("GET", f"/api/workflows/{quote(workflow_id, safe='')}/runs").get("batches") or []
+
+    def wait_batch(self, workflow_id, batch_id, seconds, poll=0.5, on_node=None):
+        """A workflow's graph run once it ended or ``seconds`` passed (polling)."""
+        deadline, seen = time.monotonic() + max(0.0, seconds), {}
+        while True:
+            batch = next((b for b in self.workflow_runs(workflow_id) if b.get("id") == batch_id), None)
+            if batch is None:
+                return None
+            for instance, node in sorted((batch.get("nodes") or {}).items(), key=lambda item: item[1].get("seq", 0)):
+                if on_node is not None and seen.get(instance) != node.get("state"):
+                    seen[instance] = node.get("state")
+                    on_node(node)
+            if batch.get("status") != "running" or time.monotonic() >= deadline:
+                return batch
+            time.sleep(min(poll, max(0.05, deadline - time.monotonic())))
+
+    def app_session(self):
+        """Whether approvals here need the Mac app (it holds the app session, S6.6)."""
+        return self._app_session
+
+    def group(self, group_id):
+        return self.call("GET", f"/api/groups/{quote(group_id, safe='')}")["group"]
+
+    def wait_group(self, group_id, seconds, poll=0.5):
+        """A task on several phones once every phone is done (its merged summary is in), one waits for someone, or
+        ``seconds`` passed (polling)."""
+        deadline = time.monotonic() + max(0.0, seconds)
+        while True:
+            group = self.group(group_id)
+            if group.get("state") in ("finished", "waiting") or time.monotonic() >= deadline:
+                return group
+            time.sleep(min(poll, max(0.05, deadline - time.monotonic())))
+
+    def wait_run(self, run_id, seconds, poll=0.5, until=None, through=False, through_approval=False):
+        """The run once it finished, waits for someone, or ``seconds`` passed (polling)."""
+        deadline = time.monotonic() + max(0.0, seconds)
+        while True:
+            run = self.run(run_id)
+            approval = run.get("approval")
+            waits = (bool(approval) and not through and not (through_approval and approval.get("kind") != "clarify")
+                     or bool(run.get("phoneWait")) and not through)
+            if run.get("finishedAt") is not None or waits or (until and until(run)):
+                return run
+            if time.monotonic() >= deadline:
+                return run
+            pause = 1.0 if run.get("approval") else poll
+            time.sleep(min(pause, max(0.05, deadline - time.monotonic())))

mobile_agent/threads/context.py

@@ -0,0 +1,246 @@
+"""The thread context provider (key ``thread``, order 10, SPEC §3.2 feature 3)."""
+
+from .. import harness_api, secret_filter
+
+KEY = "thread"
+ORDER = 10
+MAX_CHARS = 4500
+LISTS_CHARS = 1500
+RECENT = 3
+ASK_CHARS = 500          # one message, quoted
+EXTRA_CHARS = 300        # a message sent while Mobster worked, an answer to its question
+EXTRAS_PER_EXCHANGE = 3
+ANSWER_CHARS = 400
+NOTES_CHARS = 600
+CONDENSED_CHARS = 500
+TRUSTED_TITLE = "Earlier in this conversation (the user's own words)"
+RESULTS_TITLE = "What Mobster's earlier tasks in this conversation found"
+LISTS_TITLE = "Lists from earlier tasks in this conversation"
+REPORT_CHARS = 600
+OUTCOMES = {"done": "Done", "check": "Finished, worth a check", "answered": "Answered", "blocked": "Couldn't finish",
+            "stopped": "Stopped", "failed": "Failed"}
+
+
+def cut(text, limit):
+    text = " ".join(str(text or "").split())
+    return text if len(text) <= limit else text[:limit - 1].rstrip() + "…"
+
+
+def defang(text):
+    """Untrusted text can't close the fence it sits in."""
+    return str(text).replace("<<<", "‹‹‹").replace(">>>", "›››")
+
+
+def exchanges(items, exclude_run=None):
+    """The thread's exchanges in order: one per run, with the user's words and the run's result."""
+    by_run, order = {}, []
+    for item in items:
+        run_id = item.get("runId")
+        if not run_id or run_id == exclude_run:
+            continue
+        exchange = by_run.get(run_id)
+        if exchange is None:
+            exchange = by_run[run_id] = {"runId": run_id, "ask": None, "extras": [], "result": None, "context": {},
+                                         "appName": None, "goal": None, "seq": item.get("seq", 0)}
+        kind = item.get("kind")
+        if kind == "user":
+            routed = item.get("routed")
+            if routed == "new_run" and exchange["ask"] is None:
+                exchange["ask"] = item.get("text") or ""
+            elif routed == "steer":
+                exchange["extras"].append(("Added while it ran", item.get("text") or ""))
+            elif routed == "answer":
+                exchange["extras"].append(("Answer to Mobster's question", item.get("text") or ""))
+            elif routed == "unread":
+                exchange["extras"].append(("Sent after it finished (not read)", item.get("text") or ""))
+        elif kind == "run":
+            exchange["goal"] = item.get("goal")
+            exchange["result"] = item.get("result")
+            exchange["context"] = item.get("_context") or {}
+            exchange["appName"] = item.get("appName")
+            if item.get("seq") is not None:
+                exchange["seq"] = item["seq"]
+            order.append(run_id)
+    out = []
+    for run_id in order:
+        exchange = by_run[run_id]
+        if exchange["ask"] is None:
+            exchange["ask"] = exchange["goal"] or ""
+        out.append(exchange)
+    return out
+
+
+def outcome_words(result):
+    """"Done, in Messages" from a run item's result."""
+    if not result:
+        return "Still running or interrupted"
+    status = result.get("status") or ""
+    outcome = result.get("outcome") or ""
+    if status == "completed" or outcome == "done":
+        return OUTCOMES["done"]
+    if status == "completion_not_confirmed" or outcome == "check":
+        return OUTCOMES["check"]
+    if status in ("stopped", "approval_denied", "approval_timeout"):
+        return {"approval_denied": "The user declined the action", "approval_timeout": "Nobody answered the "
+                "approval in time"}.get(status, OUTCOMES["stopped"])
+    if status in ("blocked", "no_progress", "max_steps", "timeout", "spend_cap"):
+        return OUTCOMES["blocked"]
+    if status == "interrupted":
+        return "Interrupted"
+    return OUTCOMES["failed"] if status else "Unknown"
+
+
+def condensed_line(older):
+    """One line for the exchanges that no longer fit, newest kept when the line runs long."""
+    if not older:
+        return ""
+    parts = []
+    for exchange in reversed(older):
+        where = exchange["context"].get("lastApp") or exchange["appName"]
+        part = f"“{cut(exchange['ask'], 60)}” → {outcome_words(exchange['result']).lower()}" + (
+            f" in {where}" if where else "")
+        if sum(len(p) + 2 for p in parts) + len(part) > CONDENSED_CHARS - 40:
+            break
+        parts.append(part)
+    left = len(older) - len(parts)
+    text = "; ".join(reversed(parts))
+    if left:
+        text = f"{left} earlier task{'s' if left != 1 else ''}, then " + text
+    return f"Earlier, condensed: {text}."
+
+
+def trusted_text(recent, rules, first_number):
+    lines = []
+    if recent:
+        lines.append("Earlier requests, oldest first:")
+        for offset, exchange in enumerate(recent):
+            lines.append(f"{first_number + offset}. “{cut(exchange['ask'], ASK_CHARS)}”")
+            for label, text in exchange["extras"][-EXTRAS_PER_EXCHANGE:]:
+                lines.append(f"   {label}: “{cut(text, EXTRA_CHARS)}”")
+    if rules:
+        lines.append("Rules the user gave earlier in this conversation (they still apply unless this task says "
+                     "otherwise):")
+        lines += [f"- {rule}" for rule in rules]
+    return "\n".join(lines)
+
+
+def result_text(recent, older, first_number, with_notes=True):
+    lines = []
+    line = condensed_line(older)
+    if line:
+        lines.append(line)
+    for offset, exchange in enumerate(recent):
+        result = exchange["result"] or {}
+        where = exchange["context"].get("lastApp") or exchange["appName"]
+        lines.append(f"{first_number + offset}. {outcome_words(exchange['result'])}" + (f", in {where}." if where
+                                                                                         else "."))
+        report = exchange["context"].get("report")
+        answer = exchange["context"].get("answer") or result.get("answer")
+        if report:
+            lines.append(f"   Report: {cut(secret_filter.redact(report), REPORT_CHARS)}")
+        elif answer:
+            lines.append(f"   Answer: {cut(secret_filter.redact(answer), ANSWER_CHARS)}")
+        facts = [cut(secret_filter.redact(f), 160) for f in (result.get("facts") or [])[:4] if f]
+        if facts:
+            lines.append("   Seen: " + "; ".join(facts))
+        notes = exchange["context"].get("notes") or []
+        if with_notes and notes:
+            lines.append("   Notes: " + cut("; ".join(notes), NOTES_CHARS))
+    return defang("\n".join(lines))
+
+
+def lists_text(done, limit=LISTS_CHARS):
+    """The referents of earlier exchanges, newest first: "Turn 3, “Find the best ramen near me”:" and its numbered
+    lines, whole groups only, within ``limit`` characters."""
+    groups = []
+    for turn, exchange in enumerate(done, 1):
+        referents = (exchange.get("context") or {}).get("referents") or ()
+        if not referents:
+            continue
+        head = f"Turn {turn}, “{cut(exchange['ask'], 80)}”:"
+        rows = [f"{r.get('rank') or n}. {cut(secret_filter.redact(str(r.get('text') or '')), 200)}"
+                for n, r in enumerate(referents[:12], 1) if r.get("text")]
+        if rows:
+            groups.append("\n".join([head] + rows))
+    out, size = [], 0
+    for group in reversed(groups):
+        if size + len(group) + 2 > limit:
+            if not out:
+                out.append(group[:limit - 1] + "…")
+            break
+        out.append(group)
+        size += len(group) + 2
+    return defang("\n\n".join(out))
+
+
+def build_all(thread, items, *, current_run=None, current_goal="", limit=MAX_CHARS):
+    """(trusted, untrusted results, untrusted lists) for a run in ``thread``, together at most ``limit``."""
+    done = exchanges(items, exclude_run=current_run)
+    lists = lists_text(done, min(LISTS_CHARS, limit // 3))
+    while True:
+        trusted, results = _build(thread, done, current_goal, limit - len(lists))
+        if not lists or not trusted.endswith("…"):
+            return trusted, results, lists
+        # The user's own words were about to be cut: the lists go first, the oldest group first.
+        groups = lists.split("\n\n")
+        lists = "\n\n".join(groups[:-1])
+
+
+def _build(thread, done, current_goal, limit):
+    goal = " ".join(str(current_goal or "").split()).casefold()
+    limit = max(0, limit)
+    # A rule from the message that started this run is in its goal already.
+    rules = [rule for rule in (thread.get("rules") or []) if " ".join(rule.split()).casefold() not in goal]
+    if not done and not rules:
+        return "", ""
+    split = max(0, len(done) - RECENT)
+    older, recent = done[:split], done[split:]
+    with_notes = True
+    while True:
+        first = len(older) + 1
+        trusted = trusted_text(recent, rules, first)
+        results = result_text(recent, older, first, with_notes) if (recent or older) else ""
+        size = len(trusted) + len(results)
+        if size <= limit:
+            return trusted, results
+        if len(recent) > 1:
+            older, recent = older + recent[:1], recent[1:]
+            continue
+        if with_notes:
+            with_notes = False
+            continue
+        # One exchange left and still too long: cut the results first; the user's own words and rules stay.
+        room = max(0, limit - len(trusted))
+        if room < 40:
+            trusted = trusted[:max(0, limit - 1)] + "…" if len(trusted) > limit else trusted
+            return trusted, ""
+        return trusted, results[:room - 1] + "…"
+
+
+class ThreadProvider:
+    """harness_api.ContextProvider for one run in a thread."""
+
+    key = KEY
+    max_chars = MAX_CHARS
+
+    def __init__(self, service):
+        self.service = service
+
+    def blocks(self, ctx):
+        thread_id = ctx.thread_id
+        thread = self.service.store.get(thread_id) if thread_id else None
+        if thread is None:
+            return ()
+        items = self.service.store.items(thread_id)
+        trusted, results, lists = build_all(thread, items, current_run=ctx.run_id, current_goal=ctx.goal)
+        out = []
+        if trusted:
+            out.append(harness_api.ContextBlock(KEY, TRUSTED_TITLE, trusted, stable=True))
+        if results:
+            out.append(harness_api.ContextBlock(KEY, RESULTS_TITLE, results, stable=True, untrusted=True))
+        if lists:
+            out.append(harness_api.ContextBlock(KEY, LISTS_TITLE, lists, stable=True, untrusted=True))
+        return out
+
+    def turn_blocks(self, ctx, turn):
+        return ()