mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/connectors/graph_api.py

@@ -0,0 +1,396 @@
+"""The Microsoft 365 connector's tools, answered by Mobster with Microsoft Graph and your sign-in (a delegated token),
+because Microsoft runs no MCP server for Outlook, Calendar, OneDrive, Contacts and Teams chats that a Mobster app can
+sign in to."""
+
+import json
+import re
+import time
+from datetime import datetime, timedelta, timezone
+from urllib.parse import quote, urlencode
+
+from ..outlets import net, webhook
+from . import client as mcp
+from .api_session import ApiSession, Refusal, count_schema, required_text, short, tool_spec
+
+API = "https://graph.microsoft.com/v1.0"
+NAME = "Microsoft 365"
+LIMIT_TOP = 50
+BODY_CHARS = 8000                   # what is kept of one message's text
+TEXT_CHARS = 2000                   # what is kept of one chat message's text
+SEND_CHARS = 28_000                 # Teams takes about 28 KB of message
+READ_LIMIT = 4 * 1024 * 1024
+ID = re.compile(r"[A-Za-z0-9_=:.@!%+\-]{1,512}")
+EMAIL = re.compile(r"[^@\s<>,;\"']{1,64}@[A-Za-z0-9.-]{1,200}\.[A-Za-z]{2,24}")
+WHEN = re.compile(r"\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2})?)?(Z|[+-]\d{2}:\d{2})?")
+ZONE = re.compile(r"[A-Za-z0-9_/ +.\-]{1,60}")
+FOLDERS = ("inbox", "sentitems", "drafts", "archive", "deleteditems")
+DENIED = frozenset({"ErrorAccessDenied", "Authorization_RequestDenied", "AccessDenied",
+                    "ErrorInsufficientPermissionsToDelegate", "Forbidden"})
+REFUSED = {
+    "ErrorItemNotFound": "Microsoft has no item with that id. Use an id from a list or a search",
+    "ResourceNotFound": "Microsoft has nothing at that id. Use an id from a list or a search",
+    "ErrorInvalidIdMalformed": "That id isn't one Microsoft gave. Use an id from a list or a search",
+    "ErrorQuotaExceeded": "Your mailbox is full",
+    "ErrorMessageSizeExceeded": "The message is too big to send. Shorten it",
+}
+
+
+ADDRESSES = {"type": "array", "items": {"type": "string"}, "minItems": 1, "maxItems": 20,
+             "description": "Email addresses."}
+WHEN_FIELD = {"type": "string", "description": "A date or a date and time, such as 2026-10-20 or 2026-10-20T14:00:00Z."}
+TOOLS = (
+    tool_spec("list_mail", "List Outlook mail",
+              "Your Outlook messages, newest first: each one's id, subject, sender, time, read state and a preview. "
+              "Give query to search instead (Outlook's search words work: from:sam, subject:invoice); a search is "
+              "ordered by match.",
+              {"folder": {"type": "string", "enum": list(FOLDERS), "description": "inbox if left out. Not used by a "
+                          "search, which covers all folders."},
+               "query": {"type": "string", "description": "Words to search for."},
+               "limit": count_schema(LIMIT_TOP, 10)}),
+    tool_spec("read_message", "Read an Outlook message",
+              "One message's sender, recipients, subject, time and text, from an id that list_mail gave.",
+              {"id": {"type": "string", "description": "The message's id."}}, required=("id",)),
+    tool_spec("list_events", "List my calendar events",
+              "Your calendar between two times, in time order: each event's id, subject, start, end (UTC), place, "
+              "organizer and attendees.",
+              {"start": WHEN_FIELD | {"description": "From when. Now if left out."},
+               "end": WHEN_FIELD | {"description": "Until when. 7 days after start if left out."},
+               "limit": count_schema(LIMIT_TOP, 25)}),
+    tool_spec("create_event", "Create a calendar event",
+              "Add an event to your calendar. With attendees, Outlook emails them an invitation as you.",
+              {"subject": {"type": "string"}, "start": {"type": "string",
+                                                        "description": "Local time, 2026-10-20T14:00:00."},
+               "end": {"type": "string", "description": "Local time, 2026-10-20T15:00:00."},
+               "timezone": {"type": "string", "description": "A time zone name such as "
+                            "Europe/London; UTC if left out."},
+               "attendees": ADDRESSES, "location": {"type": "string"}, "body": {"type": "string"}},
+              required=("subject", "start", "end"), read_only=False),
+    tool_spec("search_files", "Search OneDrive files",
+              "Your OneDrive files and folders matching words in their name or content: each one's id, name, link, "
+              "size and time changed.",
+              {"query": {"type": "string", "description": "What to search for."}, "limit": count_schema(LIMIT_TOP, 10)},
+              required=("query",)),
+    tool_spec("list_contacts", "List my contacts",
+              "Your Outlook contacts: each one's name, email addresses, company and phone. Give query to search them.",
+              {"query": {"type": "string", "description": "A name or an address to search for."},
+               "limit": count_schema(LIMIT_TOP, 25)}),
+    tool_spec("list_chats", "List my Teams chats",
+              "Your Teams chats, most recently active first: each one's id, topic, kind and last activity.",
+              {"limit": count_schema(LIMIT_TOP, 20)}),
+    tool_spec("read_chat", "Read a Teams chat",
+              "A Teams chat's latest messages, newest first: each one's sender, time and text.",
+              {"chat_id": {"type": "string", "description": "A chat's id from list_chats."},
+               "limit": count_schema(LIMIT_TOP, 20)},
+              required=("chat_id",)),
+    tool_spec("send_mail", "Send an email",
+              "Send an email as you from Outlook, in plain text. A copy goes in Sent Items.",
+              {"to": ADDRESSES, "cc": ADDRESSES, "subject": {"type": "string"}, "body": {"type": "string"}},
+              required=("to", "subject", "body"), read_only=False),
+    tool_spec("send_chat_message", "Send a Teams chat message",
+              "Post a message as you in a Teams chat, in plain text.",
+              {"chat_id": {"type": "string", "description": "A chat's id from list_chats."},
+               "text": {"type": "string"}},
+              required=("chat_id", "text"), read_only=False),
+)
+WRITES = frozenset(t["name"] for t in TOOLS if not t["annotations"]["readOnlyHint"])
+
+
+def connect(*, token=None, timeout=mcp.CONNECT_TIMEOUT, name=NAME, call=None):
+    """A ready GraphSession for ``token``. AuthNeeded without one, or when Microsoft refuses it."""
+    session = GraphSession(token, name=name, call=call)
+    session.initialize(timeout=timeout)
+    return session
+
+
+class GraphSession(ApiSession):
+    """The MCP session's surface (client.Session) over Microsoft Graph."""
+
+    NAME, TOOLS = NAME, TOOLS
+
+    def _api(self, method, path, deadline, query=None, body=None, headers=None):
+        """Graph's JSON answer ({} for a 2xx with none) or a ``Refusal``. Raises AuthNeeded, NotSent and, for a write,
+        OutcomeUnknown (a 5xx or no answer: it may have happened, and it's never sent again)."""
+        if not self.token:
+            raise mcp.AuthNeeded(f"{self.name} isn't signed in.")
+        write = method != "GET"
+        url = f"{API}{path}" + (f"?{urlencode(query, quote_via=quote)}" if query else "")
+        send = {"Authorization": f"Bearer {self.token}", "Accept": "application/json", "User-Agent": webhook.USER_AGENT,
+                **(headers or {})}
+        data = None
+        if body is not None:
+            data = json.dumps(body, ensure_ascii=False).encode()
+            send["Content-Type"] = "application/json"
+        try:
+            reply = self.call(method, url, data, send, timeout=max(1.0, deadline - time.monotonic()),
+                              read_limit=READ_LIMIT)
+        except net.NetError as error:
+            if error.unsent:
+                raise mcp.NotSent(error.message) from None
+            if write:
+                raise mcp.OutcomeUnknown(f"{error.message} It may have gone through: check Microsoft 365 before you do "
+                                         "it again.") from None
+            raise mcp.OutcomeUnknown(error.message) from None
+        if reply.status == 429:
+            wait = reply.retry_after if str(reply.retry_after or "").isdigit() else "a few"
+            return Refusal(f"Microsoft asked Mobster to wait {wait} seconds. Try again then.")
+        if reply.status >= 500:
+            if write:
+                raise mcp.OutcomeUnknown(f"Microsoft answered {reply.status}. It may have gone through: check "
+                                         "Microsoft 365 before you do it again.")
+            return Refusal(f"Microsoft answered {reply.status}. Try again in a minute.")
+        try:
+            answer = json.loads(reply.body.decode("utf-8")) if reply.body else {}
+        except (ValueError, UnicodeDecodeError):
+            answer = None
+        if 200 <= reply.status < 300:
+            if isinstance(answer, dict):
+                return answer
+            # A write Microsoft answered 2xx happened, whatever its body says; a read has nothing to show.
+            return {} if write else Refusal("Microsoft's answer couldn't be read. Try again in a minute.")
+        error = answer.get("error") if isinstance(answer, dict) else None
+        code = str(error.get("code") if isinstance(error, dict) else "")[:60]
+        if reply.status == 401:
+            raise mcp.AuthNeeded(f"Microsoft signed Mobster out ({code or 401}). Sign in to {self.name} again in "
+                                 "Settings › Connectors.")
+        if reply.status == 403 or code in DENIED:
+            return Refusal(f"Microsoft refused ({code or 403}). Your {self.name} sign-in can't do this: sign in again "
+                           f"in Settings › Connectors and allow what Microsoft asks, or ask your admin.")
+        if code in REFUSED:
+            return Refusal(f"Microsoft refused ({code}). {REFUSED[code]}.")
+        said = re.sub(r"\s+", " ", str(error.get("message") or "") if isinstance(error, dict) else "")[:200]
+        return Refusal(f"Microsoft refused ({code or reply.status})." + (f" {said}" if said else ""))
+
+    def initialize(self, timeout=mcp.CONNECT_TIMEOUT):
+        """GET /me: the token works (it needs only User.Read). AuthNeeded or NotSent when it doesn't."""
+        answer = self._api("GET", "/me", time.monotonic() + timeout, {"$select": "displayName,userPrincipalName"})
+        if isinstance(answer, Refusal):
+            raise mcp.NotSent(answer.message)
+        self.server_info = {"name": NAME, "user": str(answer.get("userPrincipalName") or "")[:100]}
+        self.ready = True
+        return {"serverInfo": self.server_info}
+
+    def ping(self, timeout=mcp.PING_TIMEOUT):
+        if not self.ready:
+            raise mcp.NotSent(f"{self.name} isn't connected.")
+        answer = self._api("GET", "/me", time.monotonic() + timeout, {"$select": "id"})
+        if isinstance(answer, Refusal):
+            raise mcp.NotSent(answer.message)
+        return True
+
+    def _list_mail(self, args, deadline):
+        top = _limit(args.get("limit"), 10)
+        select = "id,subject,from,receivedDateTime,isRead,bodyPreview,webLink"
+        query = args.get("query")
+        if query is not None:
+            words = " ".join(required_text(query, "query", 300).replace('"', " ").split())
+            answer = self._api("GET", "/me/messages", deadline,
+                               {"$search": f'"{words}"', "$top": top, "$select": select})
+        else:
+            folder = _choice(args.get("folder"), FOLDERS, "folder")
+            answer = self._api("GET", f"/me/mailFolders/{folder}/messages", deadline,
+                               {"$top": top, "$orderby": "receivedDateTime desc", "$select": select})
+        if isinstance(answer, Refusal):
+            return answer
+        return {"messages": [{"id": short(m.get("id"), 512), "subject": short(m.get("subject"), 300),
+                              "from": _address(m.get("from")), "received": short(m.get("receivedDateTime"), 40),
+                              "read": bool(m.get("isRead")), "preview": short(m.get("bodyPreview"), 300),
+                              "link": short(m.get("webLink"), 500)}
+                             for m in _items(answer)],
+                "more": "@odata.nextLink" in answer}
+
+    def _read_message(self, args, deadline):
+        ident = _id(args.get("id"), "id")
+        answer = self._api("GET", f"/me/messages/{quote(ident, safe='')}", deadline,
+                           {"$select": "id,subject,from,toRecipients,ccRecipients,receivedDateTime,body,webLink"},
+                           headers={"Prefer": 'outlook.body-content-type="text"'})
+        if isinstance(answer, Refusal):
+            return answer
+        body = answer.get("body") if isinstance(answer.get("body"), dict) else {}
+        return {"id": short(answer.get("id"), 512), "subject": short(answer.get("subject"), 300),
+                "from": _address(answer.get("from")), "to": [_address(r) for r in answer.get("toRecipients") or ()],
+                "cc": [_address(r) for r in answer.get("ccRecipients") or ()],
+                "received": short(answer.get("receivedDateTime"), 40), "text": short(body.get("content"), BODY_CHARS),
+                "link": short(answer.get("webLink"), 500)}
+
+    def _list_events(self, args, deadline):
+        start = _when(args.get("start"), "start") or datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        end = _when(args.get("end"), "end")
+        if end is None:
+            first = datetime.fromisoformat(_utc(start).replace("Z", "+00:00"))
+            end = (first + timedelta(days=7)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        answer = self._api("GET", "/me/calendarView", deadline,
+                           {"startDateTime": _utc(start), "endDateTime": _utc(end),
+                            "$top": _limit(args.get("limit"), 25), "$orderby": "start/dateTime",
+                            "$select": "id,subject,start,end,location,organizer,attendees,webLink,isCancelled"},
+                           headers={"Prefer": 'outlook.timezone="UTC"'})
+        if isinstance(answer, Refusal):
+            return answer
+        return {"events": [{"id": short(e.get("id"), 512), "subject": short(e.get("subject"), 300),
+                            "start": short((e.get("start") or {}).get("dateTime"), 40),
+                            "end": short((e.get("end") or {}).get("dateTime"), 40),
+                            "place": short((e.get("location") or {}).get("displayName"), 200),
+                            "organizer": _address(e.get("organizer")),
+                            "attendees": [_address(a) for a in (e.get("attendees") or ())[:20]],
+                            "cancelled": bool(e.get("isCancelled")), "link": short(e.get("webLink"), 500)}
+                           for e in _items(answer)],
+                "more": "@odata.nextLink" in answer}
+
+    def _search_files(self, args, deadline):
+        words = required_text(args.get("query"), "query", 300).replace("'", "''")
+        answer = self._api("GET", f"/me/drive/root/search(q='{quote(words, safe='')}')", deadline,
+                           {"$top": _limit(args.get("limit"), 10),
+                            "$select": "id,name,webUrl,size,lastModifiedDateTime,file,folder"})
+        if isinstance(answer, Refusal):
+            return answer
+        return {"files": [{"id": short(f.get("id"), 512), "name": short(f.get("name"), 300),
+                           "kind": "folder" if f.get("folder") else "file", "size": f.get("size")
+                           if isinstance(f.get("size"), int) else None,
+                           "modified": short(f.get("lastModifiedDateTime"), 40), "link": short(f.get("webUrl"), 500)}
+                          for f in _items(answer)],
+                "more": "@odata.nextLink" in answer}
+
+    def _list_contacts(self, args, deadline):
+        query = {"$top": _limit(args.get("limit"), 25),
+                 "$select": "id,displayName,emailAddresses,companyName,mobilePhone"}
+        if args.get("query") is not None:
+            query["$search"] = '"' + " ".join(
+                required_text(args["query"], "query", 200).replace('"', " ").split()) + '"'
+        answer = self._api("GET", "/me/contacts", deadline, query)
+        if isinstance(answer, Refusal):
+            return answer
+        return {"contacts": [{"id": short(c.get("id"), 512), "name": short(c.get("displayName"), 200),
+                              "emails": [short(a.get("address"), 200) for a in (c.get("emailAddresses") or ())[:5]
+                                         if isinstance(a, dict)],
+                              "company": short(c.get("companyName"), 200), "phone": short(c.get("mobilePhone"), 40)}
+                             for c in _items(answer)],
+                "more": "@odata.nextLink" in answer}
+
+    def _list_chats(self, args, deadline):
+        answer = self._api("GET", "/me/chats", deadline, {"$top": _limit(args.get("limit"), 20),
+                                                           "$orderby": "lastMessagePreview/createdDateTime desc",
+                                                           "$select": "id,topic,chatType,lastUpdatedDateTime"})
+        if isinstance(answer, Refusal):
+            return answer
+        return {"chats": [{"id": short(c.get("id"), 512), "topic": short(c.get("topic"), 200),
+                           "kind": short(c.get("chatType"), 20), "updated": short(c.get("lastUpdatedDateTime"), 40)}
+                          for c in _items(answer)],
+                "more": "@odata.nextLink" in answer}
+
+    def _read_chat(self, args, deadline):
+        chat = _id(args.get("chat_id"), "chat_id")
+        answer = self._api("GET", f"/me/chats/{quote(chat, safe='')}/messages", deadline,
+                           {"$top": _limit(args.get("limit"), 20)})
+        if isinstance(answer, Refusal):
+            return answer
+        found = []
+        for m in _items(answer):
+            sender = (((m.get("from") or {}).get("user") or {}).get("displayName") if isinstance(m.get("from"), dict)
+                      else None)
+            body = m.get("body") if isinstance(m.get("body"), dict) else {}
+            found.append({"id": short(m.get("id"), 80), "from": short(sender, 200),
+                          "time": short(m.get("createdDateTime"), 40),
+                          "text": short(re.sub(r"<[^>]+>", "", str(body.get("content") or ""))
+                                         if body.get("contentType") == "html"
+                                         else body.get("content"), TEXT_CHARS)})
+        return {"chatId": chat, "messages": found, "more": "@odata.nextLink" in answer}
+
+    def _send_mail(self, args, deadline):
+        message = {"subject": required_text(args.get("subject"), "subject", 300),
+                   "body": {"contentType": "Text", "content": required_text(args.get("body"), "body", 100_000)},
+                   "toRecipients": _recipients(args.get("to"), "to", required=True)}
+        copied = _recipients(args.get("cc"), "cc")
+        if copied:
+            message["ccRecipients"] = copied
+        answer = self._api("POST", "/me/sendMail", deadline, body={"message": message, "saveToSentItems": True})
+        return answer if isinstance(answer, Refusal) else {"sent": True}
+
+    def _create_event(self, args, deadline):
+        zone = args.get("timezone", "UTC")
+        if not isinstance(zone, str) or not ZONE.fullmatch(zone):
+            raise ValueError("timezone is a time zone name such as Europe/London")
+        event = {"subject": required_text(args.get("subject"), "subject", 300),
+                 "start": {"dateTime": _local(args.get("start"), "start"), "timeZone": zone},
+                 "end": {"dateTime": _local(args.get("end"), "end"), "timeZone": zone}}
+        if args.get("location") is not None:
+            event["location"] = {"displayName": required_text(args["location"], "location", 200)}
+        if args.get("body") is not None:
+            event["body"] = {"contentType": "Text", "content": required_text(args["body"], "body", 20_000)}
+        guests = _recipients(args.get("attendees"), "attendees")
+        if guests:
+            event["attendees"] = [{**g, "type": "required"} for g in guests]
+        answer = self._api("POST", "/me/events", deadline, body=event)
+        return answer if isinstance(answer, Refusal) else {"created": True, "id": short(answer.get("id"), 512),
+                                                           "link": short(answer.get("webLink"), 500)}
+
+    def _send_chat_message(self, args, deadline):
+        chat = _id(args.get("chat_id"), "chat_id")
+        text = required_text(args.get("text"), "text", SEND_CHARS)
+        answer = self._api("POST", f"/me/chats/{quote(chat, safe='')}/messages", deadline,
+                           body={"body": {"contentType": "text", "content": text}})
+        return (answer if isinstance(answer, Refusal)
+                else {"posted": True, "chatId": chat, "id": short(answer.get("id"), 80)})
+
+
+def _items(answer):
+    return [item for item in answer.get("value") or () if isinstance(item, dict)]
+
+
+def _address(value):
+    box = value.get("emailAddress") if isinstance(value, dict) else None
+    if not isinstance(box, dict):
+        return None
+    return {"name": short(box.get("name"), 200), "address": short(box.get("address"), 200)}
+
+
+def _id(value, field):
+    text = required_text(value, field, 512)
+    if not ID.fullmatch(text):
+        raise ValueError(f"{field} is an id that a list or a search gave")
+    return text
+
+
+def _limit(value, default):
+    if value is None:
+        return default
+    if type(value) is not int or not 1 <= value <= LIMIT_TOP:
+        raise ValueError(f"limit is a whole number from 1 to {LIMIT_TOP}")
+    return value
+
+
+def _choice(value, choices, field):
+    if value is None:
+        return choices[0]
+    if value not in choices:
+        raise ValueError(f"{field} is {' or '.join(choices)}")
+    return value
+
+
+def _recipients(value, field, required=False):
+    if value is None and not required:
+        return []
+    if not isinstance(value, list) or not value or len(value) > 20 or not all(isinstance(a, str) for a in value):
+        raise ValueError(f"{field} is a list of 1 to 20 email addresses")
+    found = [a.strip() for a in value]
+    if not all(EMAIL.fullmatch(a) for a in found):
+        raise ValueError(f"{field} has an address that isn't an email address")
+    return [{"emailAddress": {"address": a}} for a in found]
+
+
+def _when(value, field):
+    if value is None:
+        return None
+    if not isinstance(value, str) or not WHEN.fullmatch(value.strip()):
+        raise ValueError(f"{field} is a date or a date and time, such as 2026-10-20T14:00:00Z")
+    return value.strip()
+
+
+def _utc(value):
+    """A date or time as Graph's calendarView wants it: with a zone (UTC when it has none)."""
+    text = value if len(value) > 10 else value + "T00:00:00"
+    return text if re.search(r"(Z|[+-]\d{2}:\d{2})$", text) else text + "Z"
+
+
+def _local(value, field):
+    if not isinstance(value, str) or not re.fullmatch(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?", value.strip()):
+        raise ValueError(f"{field} is a local time such as 2026-10-20T14:00:00")
+    return value.strip()

mobile_agent/connectors/imports.py

@@ -0,0 +1,170 @@
+"""Import the MCP servers you already set up in Claude Desktop, Claude Code, Cursor or Codex: Settings ›
+Connectors lists each one with an Add button (GET /api/connectors/imports), and Add makes it a connector (POST
+/api/connectors/imports) without retyping its command, URL or keys."""
+
+import json
+import os
+from pathlib import Path
+
+from ..integrations import clients as agent_clients
+from ..integrations import jsonc, textedit
+from ..secret_filter import redact
+from . import client as mcp
+
+SOURCES = (("claude-desktop", agent_clients.ClaudeDesktop), ("claude-code", agent_clients.ClaudeCode),
+           ("cursor", agent_clients.Cursor), ("codex", agent_clients.Codex))
+MAX_SERVERS = 60              # per file
+MAX_BYTES = 4_000_000         # a config larger than this is skipped (~/.claude.json can grow; it holds history too)
+SELF = ("mobster", "mobster-agent")
+
+
+def _read(path):
+    try:
+        if not path.is_file() or path.stat().st_size > MAX_BYTES:
+            return None
+        return path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return None
+
+
+def _servers(client, path):
+    """{name: entry} from one app's file, or {} when it has none or can't be read."""
+    text = _read(path)
+    if text is None:
+        return {}
+    try:
+        if isinstance(client, agent_clients.Codex):
+            servers = textedit.toml_loads(text).get("mcp_servers")
+        else:
+            try:
+                data = json.loads(text)      # fast for a large ~/.claude.json
+            except ValueError:
+                data = jsonc.loads(text)     # comments and trailing commas (Cursor allows them)
+            servers = data
+            for key in client.container:
+                servers = servers.get(key) if isinstance(servers, dict) else None
+    except (ValueError, jsonc.JsoncError, textedit.EditError):
+        return {}
+    if not isinstance(servers, dict):
+        return {}
+    return {str(k): v for k, v in list(servers.items())[:MAX_SERVERS] if isinstance(v, dict)}
+
+
+def _is_mobster(name, entry):
+    if name.casefold() in SELF:
+        return True
+    command = entry.get("command")
+    if isinstance(command, str) and os.path.basename(command) in SELF:
+        return True
+    args = entry.get("args") if isinstance(entry.get("args"), list) else []
+    return "mobile_agent" in args and "mcp" in args
+
+
+def _token_of(entry):
+    """A bearer token from an entry's headers (Authorization: Bearer …), else None; and whether other headers were left
+    out."""
+    headers = entry.get("headers") if isinstance(entry.get("headers"), dict) else {}
+    token, others = None, False
+    for key, value in headers.items():
+        if str(key).casefold() == "authorization" and isinstance(value, str) and value.startswith("Bearer "):
+            token = value[7:].strip() or None
+        else:
+            others = True
+    if isinstance(entry.get("bearer_token"), str):   # Codex's inline form
+        token = entry["bearer_token"].strip() or token
+    return token, others
+
+
+def describe(entry):
+    """What Add would make of ``entry``: {"transport", "command", "args", "url", "envNames", "token", "headers",
+    "problem"}."""
+    command, url = entry.get("command"), entry.get("url") or entry.get("serverUrl")
+    kind = str(entry.get("type") or entry.get("transport") or "").casefold()
+    out = {"transport": None, "command": None, "args": [], "url": None, "envNames": [], "token": False,
+           "headers": False, "problem": None}
+    if isinstance(command, str) and command.strip():
+        args = entry.get("args") if isinstance(entry.get("args"), list) else []
+        env = entry.get("env") if isinstance(entry.get("env"), dict) else {}
+        out.update(transport="stdio", command=command.strip(), args=[str(a) for a in args],
+                   envNames=sorted(str(k) for k in env))
+        return out
+    if isinstance(url, str) and url.strip():
+        out["url"] = url.strip()
+        if kind == "sse" or url.rstrip("/").endswith("/sse"):
+            out["problem"] = "It uses SSE, an older MCP transport Mobster doesn't speak. Use the server's /mcp URL."
+            return out
+        try:
+            mcp.validate_url(url)
+        except ValueError as error:
+            out["problem"] = f"{error}."
+            return out
+        token, others = _token_of(entry)
+        out.update(transport="http", token=bool(token), headers=others)
+        return out
+    out["problem"] = "It has no command or URL Mobster can use."
+    return out
+
+
+def found(env=None):
+    """Every server the other apps have, as (source id, source name, name, entry) tuples, Mobster left out."""
+    env = env or agent_clients.Env.current()
+    out = []
+    for source, cls in SOURCES:
+        client = cls()
+        for path in client.paths(env):
+            for name, entry in _servers(client, Path(path)).items():
+                if not _is_mobster(name, entry):
+                    out.append((source, client.name, name, entry))
+    return out
+
+
+def public(found_servers, connectors):
+    """The list for GET /api/connectors/imports. ``connectors``: the existing rows (to say which are added). It never
+    carries a value: env values and tokens stay on this Mac and go straight to the Keychain on Add."""
+    rows = []
+    for source, source_name, name, entry in found_servers:
+        info = describe(entry)
+        added = next((c for c in connectors if (info["transport"] == "stdio" and c["transport"] == "stdio" and
+                                                os.path.basename(c.get("command") or "") ==
+                                                os.path.basename(info["command"] or "") and
+                                                list(c.get("args") or []) == info["args"])
+                      or (info["transport"] == "http" and c.get("url") and info["url"] and
+                          mcp.hint(c["url"]) == mcp.hint(info["url"]))), None)
+        rows.append({
+            "source": source, "sourceName": source_name, "key": name[:80], "name": suggested_name(name),
+            "transport": info["transport"],
+            "command": os.path.basename(info["command"]) if info["command"] else None,
+            "args": [redact(a)[:200] for a in info["args"][:40]],
+            "url": mcp.hint(info["url"]) if info["url"] and not info["problem"] else None,
+            "envNames": info["envNames"][:20], "token": info["token"], "headers": info["headers"],
+            "problem": info["problem"], "added": added["id"] if added else None})
+    return rows
+
+
+def suggested_name(key):
+    """A connector name from a config's key: "brave-search" stays, cut to 40 characters."""
+    text = " ".join(str(key).split()) or "Server"
+    return text[:40]
+
+
+def body_for(found_servers, source, key, name=None):
+    """The POST /api/connectors body for one found server, with its secrets (env values, a header's bearer token) read
+    now from the app's own file."""
+    match = next((entry for src, _, k, entry in found_servers if src == source and k == key), None)
+    if match is None:
+        raise ValueError("That server isn't in the app's settings any more. Look again")
+    info = describe(match)
+    if info["problem"]:
+        raise ValueError(info["problem"].rstrip("."))
+    body = {"name": name or suggested_name(key)}
+    if info["transport"] == "stdio":
+        env = match.get("env") if isinstance(match.get("env"), dict) else {}
+        body.update(command=info["command"], args=info["args"])
+        if env:
+            body["env"] = {str(k): str(v) for k, v in env.items()}
+    else:
+        body["url"] = info["url"]
+        token, _ = _token_of(match)
+        if token:
+            body["token"] = token
+    return body

mobile_agent/connectors/issue.py

@@ -0,0 +1,66 @@
+"""File a finished result as an issue through a connected tracker (GitHub, Linear or Jira): one tool call of the
+connector the person already connected, through the same ConnectorService.call a workflow's connector step uses."""
+
+import re
+
+# preset -> [(tool, the arguments for it)], the first tool the connector offers wins. ``target`` is what only the
+# person knows (GitHub's owner and repo, Linear's team, Jira's cloudId and projectKey); the title and text are ours.
+TRACKERS = {
+    "github": (("issue_write", lambda t, title, text: {"method": "create", **t, "title": title, "body": text}),
+               ("create_issue", lambda t, title, text: {**t, "title": title, "body": text})),
+    "linear": (("save_issue", lambda t, title, text: {**t, "title": title, "description": text}),
+               ("create_issue", lambda t, title, text: {**t, "title": title, "description": text})),
+    "jira": (("createJiraIssue", lambda t, title, text: {"issueTypeName": "Bug", **t, "summary": title,
+                                                         "description": text}),),
+}
+TARGET_KEYS = {"owner", "repo", "team", "teamId", "project", "projectId", "cloudId", "projectKey", "issueTypeName",
+               "labels"}
+URL = re.compile(r"https://[^\s\"'<>)]+")
+
+
+def trackers(rows):
+    """The enabled connectors that are one of the trackers, in the order they were added."""
+    return [row for row in rows if row.get("enabled") and row.get("preset") in TRACKERS]
+
+
+def pick(rows, wanted):
+    """The tracker connector ``wanted`` names (its id, name or preset), else the only one connected.
+    Returns (row, None) or (None, (code, message)) when no suitable one is connected."""
+    found = trackers(rows)
+    if not found:
+        return None, ("no_tracker", "No issue tracker is connected. Connect GitHub, Linear or Jira in Settings › "
+                                    "Connectors, then file the issue.")
+    if wanted:
+        wanted = str(wanted).lower()
+        found = [row for row in found if wanted in (row["id"].lower(), row["name"].lower(), row["preset"])]
+        if not found:
+            return None, ("no_tracker", f"{wanted} isn't a connected issue tracker. Pick one that is connected.")
+    if len(found) > 1:
+        return None, ("tracker_ambiguous", "Several issue trackers are connected: " +
+                      ", ".join(row["name"] for row in found) + ". Name the one to use.")
+    return found[0], None
+
+
+def tool_for(row, target, title, text):
+    """(tool, arguments) for the first create-issue tool the connector offers, else None."""
+    offered = {tool["name"] for tool in row.get("tools") or ()}
+    for tool, build in TRACKERS[row["preset"]]:
+        if tool in offered:
+            return tool, build(target, title, text)
+    return None
+
+
+def clean_target(value):
+    if value is None:
+        return {}
+    if not isinstance(value, dict) or set(value) - TARGET_KEYS:
+        raise ValueError("target holds only " + ", ".join(sorted(TARGET_KEYS)))
+    if not all(isinstance(item, (str, list)) for item in value.values()):
+        raise ValueError("Every target value is text (labels is a list)")
+    return dict(value)
+
+
+def link_of(text):
+    """The first https link in the tracker's answer (the issue's address), or None."""
+    found = URL.search(text or "")
+    return found.group(0).rstrip(".,") if found else None