mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/completion.py

@@ -0,0 +1,267 @@
+"""`mobster completion zsh|bash|fish`: tab completion, generated from the command line's own parser.
+
+The script is written from ``build_parser()`` when you ask for it, so it always matches this build's commands and
+options, and nothing here costs another command any start-up time. Device names, past task IDs and conversation
+IDs complete from `mobster completion --values devices|tasks|threads`, which reads the same lists `mobster devices`
+and `mobster history` do.
+"""
+
+import argparse
+import re
+import sys
+
+VALUE_SOURCES = {"device": "devices", "resume": "tasks", "thread": "threads"}
+PATH_DESTS = {"env_file", "out", "output", "junit", "html", "app", "check", "state_db", "data_dir"}
+
+
+def run(args):
+    if getattr(args, "values", None):
+        return print_values(args.values)
+    if not args.shell:
+        print("mobster completion: name a shell: zsh, bash or fish. Example: mobster completion zsh",
+              file=sys.stderr)
+        return 2
+    from .cli_parser import build_parser
+    tree = describe(build_parser())
+    text = {"zsh": zsh, "bash": bash, "fish": fish}[args.shell](tree)
+    try:
+        sys.stdout.write(text)
+        sys.stdout.flush()
+    except BrokenPipeError:
+        pass
+    return 0
+
+
+def print_values(kind):
+    """One value per line, for the scripts' dynamic completion. Never fails loudly: a shell is waiting."""
+    try:
+        if kind == "devices":
+            from . import devices
+            for item in devices.discover(probe=False):
+                print(item["name"])
+        elif kind == "tasks":
+            from .history import read_history
+            from .paths import default_history_db
+            for record in read_history(default_history_db(), 30):
+                if record.get("id"):
+                    print(record["id"])
+        elif kind == "threads":
+            import json
+
+            from .threads.recent import path
+            try:
+                for value in json.loads(path().read_text()).values():
+                    print(value)
+            except (OSError, ValueError):
+                pass
+    except Exception:  # noqa: BLE001
+        pass
+    return 0
+
+
+def _visible(action):
+    return action.help != argparse.SUPPRESS
+
+
+def describe(parser):
+    """{"options": [...], "commands": {name: {"help", "options", "commands", "positionals"}}} from a parser."""
+    from .help_topics import visible
+
+    def options(target):
+        out = []
+        for action in target._actions:
+            if not action.option_strings or not _visible(action):
+                continue
+            takes = action.nargs != 0 and not isinstance(action, (argparse._StoreTrueAction,
+                                                                   argparse._StoreFalseAction,
+                                                                   argparse._HelpAction, argparse._VersionAction,
+                                                                   argparse._CountAction))
+            source = VALUE_SOURCES.get(action.dest)
+            if takes and action.choices:
+                source = "choices:" + " ".join(str(c) for c in action.choices)
+            elif takes and source is None and (action.dest in PATH_DESTS or action.type is not None and
+                                               getattr(action.type, "__name__", "") == "path_type"):
+                source = "files"
+            out.append({"flags": list(action.option_strings), "help": action.help or "", "takes": takes,
+                        "metavar": (action.metavar if isinstance(action.metavar, str) else None)
+                        or action.dest.upper(), "source": source})
+        return out
+
+    def node(target, top=False):
+        subs = next((a for a in target._actions if isinstance(a, argparse._SubParsersAction)), None)
+        commands = {}
+        if subs is not None:
+            helps = {a.dest: a.help for a in subs._choices_actions}
+            for name, child in subs.choices.items():
+                if top and not visible(name):
+                    continue
+                if name not in helps and not top:
+                    continue
+                entry = node(child)
+                entry["help"] = helps.get(name) or ""
+                commands[name] = entry
+        positionals = [a for a in target._actions if not a.option_strings and _visible(a)
+                       and not isinstance(a, argparse._SubParsersAction)]
+        choices = []
+        for action in positionals:
+            if action.choices:
+                choices += [str(c) for c in action.choices]
+        return {"options": options(target), "commands": commands, "choices": choices}
+    tree = node(parser, top=True)
+    # The commands in the order `mobster --help` lists them, then any a private build adds.
+    from .help_topics import GROUPS, MORE
+    order = [name for _, names in GROUPS for name in names] + list(MORE)
+    tree["commands"] = dict(sorted(tree["commands"].items(),
+                                   key=lambda item: order.index(item[0]) if item[0] in order else len(order)))
+    return tree
+
+
+def _zsh_text(text):
+    # Inside zsh's single quotes nothing escapes a quote, so an apostrophe is written as ’.
+    return re.sub(r"([\[\]:\\])", r"\\\1", text.replace("`", "").replace("'", "’")).replace("\n", " ")[:120]
+
+
+def _zsh_option(option):
+    flags = option["flags"]
+    help_text = _zsh_text(option["help"])
+    action = ""
+    if option["takes"]:
+        source = option["source"]
+        if source == "files":
+            completer = "_files"
+        elif source and source.startswith("choices:"):
+            completer = "(" + source.split(":", 1)[1] + ")"
+        elif source in ("devices", "tasks", "threads"):
+            completer = f"_mobster_values {source}"
+        else:
+            completer = " "
+        action = f":{_zsh_text(option['metavar'].lower())}:{completer}"
+    if len(flags) > 1:
+        exclusive = " ".join(flags)
+        return f"'({exclusive})'{{{','.join(flags)}}}'[{help_text}]{action}'"
+    return f"'{flags[0]}[{help_text}]{action}'"
+
+
+def zsh(tree):
+    lines = ["#compdef mobster", "# mobster completion zsh: generated from this build's parser.", "",
+             "_mobster_values() {", "  local -a values",
+             '  values=("${(@f)$(mobster completion --values $1 2>/dev/null)}")',
+             "  compadd -a values", "}", ""]
+
+    def function(name, entry):
+        commands = entry["commands"]
+        body = [f"{name}() {{", "  local curcontext=\"$curcontext\" state line", "  typeset -A opt_args"]
+        specs = [_zsh_option(option) for option in entry["options"]]
+        if commands:
+            body.append("  local -a commands")
+            body.append("  commands=(")
+            for sub, child in commands.items():
+                body.append(f"    '{sub}:{_zsh_text(child.get('help') or '')}'")
+            body.append("  )")
+            specs += ["'1: :->command'", "'*:: :->args'"]
+        elif entry["choices"]:
+            specs.append(f"'1: :({' '.join(entry['choices'])})'")
+            specs.append("'*:argument:_default'")
+        else:
+            specs.append("'*:argument:_default'")
+        body.append("  _arguments -C -s \\")
+        body += [f"    {spec} \\" for spec in specs[:-1]] + [f"    {specs[-1]}"]
+        if commands:
+            body.append("  case $state in")
+            body.append("    command) _describe -t commands 'mobster command' commands ;;")
+            body.append("    args)")
+            body.append("      case $line[1] in")
+            for sub in commands:
+                body.append(f"        {sub}) {name}_{sub.replace('-', '_')} ;;")
+            body.append("      esac ;;")
+            body.append("  esac")
+        body.append("}")
+        body.append("")
+        out = body
+        for sub, child in commands.items():
+            out += function(f"{name}_{sub.replace('-', '_')}", child)
+        return out
+    lines += function("_mobster", tree)
+    lines += ['if [ "$funcstack[1]" = "_mobster" ]; then', '  _mobster "$@"', "else",
+              "  compdef _mobster mobster", "fi", ""]
+    return "\n".join(lines)
+
+
+def bash(tree):
+    lines = ["# mobster completion bash: generated from this build's parser.", "_mobster() {",
+             "  local cur prev words cword", "  cur=\"${COMP_WORDS[COMP_CWORD]}\"",
+             "  prev=\"${COMP_WORDS[COMP_CWORD-1]}\"",
+             "  local command=\"\" sub=\"\"", "  local i",
+             "  for ((i = 1; i < COMP_CWORD; i++)); do",
+             "    case \"${COMP_WORDS[i]}\" in -*) ;; *) if [ -z \"$command\" ]; then command=\"${COMP_WORDS[i]}\"; "
+             "elif [ -z \"$sub\" ]; then sub=\"${COMP_WORDS[i]}\"; fi ;; esac", "  done",
+             "  case \"$prev\" in",
+             "    --device) COMPREPLY=($(compgen -W \"$(mobster completion --values devices 2>/dev/null)\" -- "
+             "\"$cur\")); return ;;",
+             "    --resume) COMPREPLY=($(compgen -W \"$(mobster completion --values tasks 2>/dev/null)\" -- \"$cur\"));"
+             " return ;;",
+             "    --thread) COMPREPLY=($(compgen -W \"$(mobster completion --values threads 2>/dev/null)\" -- "
+             "\"$cur\")); return ;;",
+             "    --env-file|--out|--output|--junit|--html) COMPREPLY=($(compgen -f -- \"$cur\")); return ;;",
+             "  esac", "  local words_for=\"\""]
+    top = " ".join(list(tree["commands"]) + [f for o in tree["options"] for f in o["flags"]])
+    lines.append("  if [ -z \"$command\" ]; then words_for=\"" + top + "\"")
+    lines.append("  else")
+    lines.append("    case \"$command\" in")
+    for name, entry in tree["commands"].items():
+        flags = " ".join(f for o in entry["options"] for f in o["flags"])
+        subs = " ".join(list(entry["commands"]) + entry["choices"])
+        if entry["commands"]:
+            lines.append(f"      {name}) if [ -z \"$sub\" ]; then words_for=\"{subs} {flags}\"; else case \"$sub\" in")
+            for sub, child in entry["commands"].items():
+                child_flags = " ".join(f for o in child["options"] for f in o["flags"])
+                lines.append(f"        {sub}) words_for=\"{' '.join(child['choices'])} {child_flags}\" ;;")
+            lines.append("        esac; fi ;;")
+        else:
+            lines.append(f"      {name}) words_for=\"{subs} {flags}\" ;;")
+    lines += ["    esac", "  fi", "  COMPREPLY=($(compgen -W \"$words_for\" -- \"$cur\"))", "}",
+              "complete -o default -F _mobster mobster", ""]
+    return "\n".join(lines)
+
+
+def _fish_text(text):
+    return text.replace("\\", "\\\\").replace("'", "\\'").replace("\n", " ")[:120]
+
+
+def fish(tree):
+    lines = ["# mobster completion fish: generated from this build's parser.", "complete -c mobster -f"]
+    names = " ".join(tree["commands"])
+    for name, entry in tree["commands"].items():
+        lines.append(f"complete -c mobster -n 'not __fish_seen_subcommand_from {names}' -a {name} "
+                     f"-d '{_fish_text(entry.get('help') or '')}'")
+
+    def option_lines(condition, options):
+        out = []
+        for option in options:
+            parts = []
+            for flag in option["flags"]:
+                parts.append(f"-l {flag[2:]}" if flag.startswith("--") else f"-s {flag[1:]}")
+            extra = ""
+            if option["takes"]:
+                source = option["source"]
+                if source == "files":
+                    extra = " -r -F"
+                elif source and source.startswith("choices:"):
+                    extra = f" -x -a '{source.split(':', 1)[1]}'"
+                elif source in ("devices", "tasks", "threads"):
+                    extra = f" -x -a '(mobster completion --values {source} 2>/dev/null)'"
+                else:
+                    extra = " -x"
+            out.append(f"complete -c mobster -n '{condition}' {' '.join(parts)}{extra} "
+                       f"-d '{_fish_text(option['help'])}'")
+        return out
+    lines += option_lines(f"not __fish_seen_subcommand_from {names}", tree["options"])
+    for name, entry in tree["commands"].items():
+        condition = f"__fish_seen_subcommand_from {name}"
+        lines += option_lines(condition, entry["options"])
+        for sub, child in entry["commands"].items():
+            lines.append(f"complete -c mobster -n '{condition}' -a {sub} -d '{_fish_text(child.get('help') or '')}'")
+            lines += option_lines(f"{condition}; and __fish_seen_subcommand_from {sub}", child["options"])
+        if entry["choices"]:
+            lines.append(f"complete -c mobster -n '{condition}' -a '{' '.join(entry['choices'])}'")
+    return "\n".join(lines) + "\n"

mobile_agent/compose.py

@@ -0,0 +1,48 @@
+"""Composition root: the driver for a run target, and best-effort shutdown."""
+
+from . import harness_api
+from .drivers import build_driver
+
+
+def build_target_driver(*, wda_url=None, session=None, expected_bundle=None, connection=None, app_names=None,
+                        labeller=None, icon_memory=None, **options):
+    if connection == "mirroring":
+        from . import mirroring
+        if not mirroring.enabled():
+            raise ValueError(f"The iPhone Mirroring connection is experimental: set {mirroring.ENV_FLAG}=1 to use it")
+        return build_driver("mirroring", app_names=app_names, labeller=labeller, icon_memory=icon_memory)
+    if connection == "cable_bt":
+        from . import cable_bt
+        if not cable_bt.enabled():
+            raise ValueError(f"The Cable + Bluetooth connection is experimental: set {cable_bt.ENV_FLAG}=1 to use it")
+        return build_driver("cable_bt", app_names=app_names, labeller=labeller, icon_memory=icon_memory, **options)
+    if connection not in (None, "wda"):
+        raise ValueError(f"Unknown connection {connection!r}")
+    if wda_url:
+        driver = build_driver("wda", url=wda_url, session=session)
+        driver.configure()
+        return driver
+    options = {key: value for key, value in options.items() if value is not None}
+    target_driver = harness_api.hooks().target_driver
+    if options and target_driver is not None:
+        return target_driver(expected_bundle=expected_bundle, **options)
+    raise ValueError("A run needs --wda-url (and optionally --session)")
+
+
+def _closer(client, name):
+    try:
+        return getattr(client, name, None)
+    except Exception:
+        return None
+
+
+def close_all(*clients):
+    for client in clients:
+        if client is None:
+            continue
+        for closer in (_closer(client, "close"), _closer(_closer(client, "http"), "close")):
+            if callable(closer):
+                try:
+                    closer()
+                except Exception:
+                    pass

mobile_agent/config.py

@@ -0,0 +1,114 @@
+"""Typed run budgets."""
+
+from pathlib import Path
+from typing import NamedTuple
+
+
+class EnvFile(NamedTuple):
+    """What ``load_env_file`` did."""
+
+    loaded: list
+    warnings: list
+
+
+def missing_env_file(path):
+    """The warning for an env file that doesn't exist: one sentence naming it (~ for the home folder)."""
+    shown = str(path)
+    home = str(Path.home())
+    if shown == home or shown.startswith(home + "/"):
+        shown = "~" + shown[len(home):]
+    return f"{shown} does not exist; no keys or settings were loaded from it"
+
+
+def load_env_file(path, missing_ok=False):
+    """Load KEY=VALUE lines into the environment. Variables already set win; a bad line is a warning, never a stop."""
+    import os
+
+    from . import env_secrets
+    values, warnings = _parse_env_file(path, missing_ok)
+    loaded = []
+    # Settings can choose the secret store (MOBSTER_VAULT=file). App secrets come only from its locked read,
+    # never this plaintext snapshot, which may precede a key replacement or logout.
+    for key, value in values.items():
+        if key not in env_secrets.SECRET_NAMES and key not in os.environ:
+            os.environ[key] = value
+            loaded.append(key)
+    secrets, problems = env_secrets.secrets_for(path, values)
+    warnings += problems
+    if not env_secrets.applies(path):
+        secrets = {key: value for key, value in values.items() if key in env_secrets.SECRET_NAMES}
+    for key, value in secrets.items():
+        if key not in os.environ:
+            os.environ[key] = value
+            loaded.append(key)
+    return EnvFile(loaded, warnings)
+
+
+def read_env_values(path):
+    """{NAME: value} for the file's valid lines, without touching the environment ({} when it can't be read)."""
+    return _parse_env_file(path, missing_ok=True)[0]
+
+
+def _parse_env_file(path, missing_ok):
+    import re
+    values, warnings = {}, []
+    name = Path(path).name
+    try:
+        data = Path(path).read_bytes()
+    except FileNotFoundError:
+        if not missing_ok:
+            warnings.append(missing_env_file(path))
+        return values, warnings
+    except OSError as error:
+        warnings.append(f"{name} could not be read ({type(error).__name__}); no settings were loaded from it")
+        return values, warnings
+    for number, raw in enumerate(data.removeprefix(b"\xef\xbb\xbf").splitlines(), 1):
+        try:
+            line = raw.decode("utf-8").strip()
+        except UnicodeDecodeError:
+            warnings.append(f"{name} line {number} is not UTF-8 text; skipped it")
+            continue
+        if not line or line.startswith("#"):
+            continue
+        if "=" not in line:
+            warnings.append(f"{name} line {number} is not NAME=value; skipped it")
+            continue
+        key, value = (part.strip() for part in line.split("=", 1))
+        key = key.removeprefix("export ").strip()
+        if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", key):
+            warnings.append(f"{name} line {number} has a name with characters other than letters, digits "
+                            "and _; skipped it")
+            continue
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in "'\"":
+            value = value[1:-1]
+        if "\x00" in value:
+            warnings.append(f"{name} line {number} contains a null character; skipped it")
+            continue
+        values.setdefault(key, value)  # the first line for a name wins, as it did when each line set the environment
+    return values, warnings
+
+
+# Where each key and setting this process loaded came from: {name: "env-file" | "mac-app"}. A name set in the shell
+# is not here. doctor and `mobster login status` read it to say "from Mobster for Mac".
+SOURCES = {}
+
+
+def app_env_file():
+    """The file Mobster for Mac (and `mobster login`) keep keys and settings in: agent.env in the data folder, 0600."""
+    from .paths import user_data_dir
+    return user_data_dir() / "agent.env"
+
+
+def load_env_layers(env_file=None):
+    """Load an explicit --env-file, then the keys Mobster for Mac saved, never over a variable already set."""
+    warnings = []
+    if env_file:
+        loaded = load_env_file(env_file)
+        SOURCES.update({name: "env-file" for name in loaded.loaded})
+        warnings += loaded.warnings
+    path = app_env_file()
+    if env_file is None or Path(env_file).expanduser().resolve() != path.resolve():
+        loaded = load_env_file(path, missing_ok=True)
+        SOURCES.update({name: "mac-app" for name in loaded.loaded})
+        # The app's own file is never the user's to fix line by line: its bad lines are skipped quietly.
+    return warnings

mobile_agent/connectors/__init__.py

@@ -0,0 +1 @@
+"""Connectors: the agent uses tools of other services (MCP servers) during a task."""

mobile_agent/connectors/api_session.py

@@ -0,0 +1,76 @@
+"""What the connectors that answer MCP calls with a service's own API share (graph_api.py, slack_api.py): the tool
+descriptor, the argument checks, ``Refusal``, and the session surface the connector service drives (client.Session's:
+initialize, ping, list_tools, call_tool, close)."""
+
+import json
+import time
+
+from ..outlets import net
+from . import client as mcp
+
+
+class Refusal:
+    """The service (or the arguments) said no before anything happened: the tool's error result."""
+
+    def __init__(self, message):
+        self.message = message
+
+
+def tool_spec(name, title, description, properties, required=(), read_only=True):
+    return {"name": name, "title": title, "description": description,
+            "inputSchema": {"type": "object", "properties": properties, "required": list(required),
+                            "additionalProperties": False},
+            "annotations": {"title": title, "readOnlyHint": read_only, "destructiveHint": False,
+                            "openWorldHint": not read_only}}
+
+
+def count_schema(top, default):
+    return {"type": "integer", "minimum": 1, "maximum": top, "description": f"At most {top}; {default} if left out."}
+
+
+def short(value, limit):
+    return str(value)[:limit] if value is not None else None
+
+
+def required_text(value, field, limit):
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{field} is required")
+    if len(value) > limit:
+        raise ValueError(f"{field} is longer than {limit} characters")
+    return value.strip()
+
+
+class ApiSession:
+    """A session over a service's API."""
+
+    NAME = TOOLS = None
+
+    def __init__(self, token, name=None, call=None):
+        self.token, self.name = token, name or self.NAME
+        self.call = call or net.call
+        self.ready, self.tools_changed = False, False
+        self.server_info, self.instructions = {}, ""
+
+    def list_tools(self, timeout=mcp.LIST_TIMEOUT):
+        return [json.loads(json.dumps(spec)) for spec in self.TOOLS]
+
+    def close(self):
+        self.ready = False
+
+    def call_tool(self, name, arguments, timeout=mcp.CALL_TIMEOUT):
+        """The tool's result ({"content", "structuredContent"?, "isError"?}), as client.Session.call_tool."""
+        if not self.ready:
+            raise mcp.NotSent(f"{self.name} isn't connected.")
+        method = getattr(self, f"_{name}", None) if name in {t["name"] for t in self.TOOLS} else None
+        if method is None:
+            raise mcp.ServerError(f"{self.name} has no tool called {name}.")
+        arguments = arguments if isinstance(arguments, dict) else {}
+        deadline = time.monotonic() + timeout
+        try:
+            found = method(arguments, deadline)
+        except ValueError as error:
+            found = Refusal(str(error))
+        if isinstance(found, Refusal):
+            return {"content": [{"type": "text", "text": found.message}], "isError": True}
+        return {"content": [{"type": "text", "text": json.dumps(found, ensure_ascii=False)}],
+                "structuredContent": found}

mobile_agent/connectors/callback_page.py

@@ -0,0 +1,146 @@
+"""The page your browser shows when a sign-in comes back to this Mac (oauth.SignIn's listener): Mobster's app icon and
+the service's own mark, joined by a dotted line, then one line that says what happened."""
+
+import base64
+import hashlib
+import html
+import re
+
+from .. import brand
+from ..brand_fonts import FONT_FACES
+from .marks import DARK, LIGHT, NAMES
+
+APP_LINK = "mobster://connectors"
+BACK = "Mobster is back in front. You can close this tab."
+# The success page waits for its line to finish drawing (about 600 ms) before Mobster comes forward.
+HAND_BACK = (f'setTimeout(function () {{ location.href = "{APP_LINK}" }}, '
+             f'matchMedia("(prefers-reduced-motion: reduce)").matches ? 0 : 900)')
+
+# Mobster's app icon, drawn from the mark (brand.MARK): the Night tile, the felt slabs and the violet row between them.
+_SLABS = re.findall(r"M[^M]*", re.search(r' d="([^"]+)"', brand.MARK["light"]).group(1))
+_TILE = ('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><rect width="512" height="512" fill="{night}"/>'
+         '<g transform="translate(256 256) scale(.7) translate(-256 -256)">{paths}</g></svg>').format(
+    night=brand.DARK["paper"],
+    paths="".join(f'<path d="{d}" fill="{brand.LIGHT["violet-solid"] if index == 1 else brand.LIGHT["sunken"]}"/>'
+                for index, d in enumerate(_SLABS)))
+_SANS = "".join(face for face in re.findall(r"@font-face \{.*?\}", FONT_FACES) if '"Mobster Sans"' in face)
+
+
+def _data(svg):
+    return "data:image/svg+xml;base64," + base64.b64encode(svg.encode()).decode()
+
+
+def mark_of(name):
+    """The service's mark, by any name it goes by ("Google Drive", "monday.com"), as the tile's picture: the mark on the
+    tile's square (docs/brand/marks, scripts/gen_agent_marks.py), with its version for a dark page where it has one."""
+    key = NAMES.get(re.sub(r"[^a-z0-9]+", "-", (name or "").lower()).strip("-"))
+    if key is None:
+        return None
+    img = f'<img src="{_data(LIGHT[key])}" alt="">'
+    if key not in DARK:
+        return img
+    return f'<picture><source srcset="{_data(DARK[key])}" media="(prefers-color-scheme: dark)">{img}</picture>'
+
+
+STYLE = """
+/* A desktop page at desktop widths, as Remote's: Mobster at the gutter (32, 16 on a phone), then one centred 640 px
+   column with a 32 px title; a phone gets the same column at its own width. */
+body { margin: 0; min-height: 100vh; display: grid; grid-template-rows: auto 1fr; background: var(--paper);
+  color: var(--ink); font: 400 16px/24px var(--font-sans); -webkit-font-smoothing: antialiased; }
+.top { display: flex; align-items: center; min-height: 72px; padding: 16px 32px; }
+.brand { display: inline-flex; align-items: center; gap: 8px; font-size: 17px; font-weight: 500; letter-spacing: -.01em; }
+.brand img { display: block; width: 28px; height: 28px; border-radius: 23%; }
+main { place-self: center; display: grid; justify-items: center; width: min(640px, calc(100vw - 32px)); padding: 48px 0;
+  text-align: center; }
+.link { display: flex; align-items: center; gap: 12px; margin-bottom: 32px; }
+.tile { position: relative; flex: none; display: grid; place-items: center; width: 80px; height: 80px;
+  border-radius: 23%; overflow: hidden; background: var(--surface); color: var(--ink-2); font-size: 32px; font-weight: 500; }
+.tile img, .tile picture { display: block; width: 100%; height: 100%; }
+.tile::after { content: ""; position: absolute; inset: 0; border-radius: inherit; box-shadow: inset 0 0 0 1px rgb(24 24 24 / .08); }
+.run { display: flex; gap: 8px; }
+.run i { width: 4px; height: 4px; border-radius: 50%; background: var(--ink-4); }
+.knot { display: grid; place-items: center; width: 24px; height: 24px; border-radius: 50%; }
+.knot svg { display: block; }
+[data-state="ok"] .run i { background: var(--green); }
+[data-state="ok"] .knot { background: var(--green); color: var(--paper); }
+[data-state="error"] .knot { background: var(--coral); color: var(--paper); }
+/* Not allowed: the line breaks where the check would be, and its last dots fade into the gap. */
+[data-state="denied"] .knot, [data-state="pick"] .knot { visibility: hidden; }
+[data-state="denied"] .run:first-of-type i:last-child, [data-state="denied"] .run:last-of-type i:first-child { opacity: .35; }
+h1 { margin: 0; font-size: 32px; line-height: 40px; font-weight: 500; letter-spacing: -.025em; text-wrap: balance; }
+p { margin: 8px auto 0; max-width: 60ch; color: var(--ink-2); text-wrap: pretty; }
+/* The title and the line take the column's width, centred inside it, so a short one doesn't shrink the page. */
+main > h1, main > p { justify-self: stretch; }
+a { display: inline-flex; align-items: center; height: 40px; margin-top: 32px; padding: 0 16px; border-radius: 999px;
+  background: var(--surface); box-shadow: var(--shadow-button-secondary); color: var(--ink); font-weight: 500;
+  letter-spacing: -.011em; text-decoration: none; transition: background-color 150ms var(--ease-standard); }
+a:hover { background: var(--card-hover); }
+a:focus-visible { outline: 2px solid var(--violet-solid); outline-offset: 2px; }
+@media (prefers-color-scheme: dark) { .tile::after { box-shadow: inset 0 0 0 1px rgb(255 255 255 / .1); } }
+@media (max-width: 639px) { .top { padding: 16px; } h1 { font-size: 24px; line-height: 32px; letter-spacing: -.022em; }
+  .tile { width: 64px; height: 64px; font-size: 28px; } .link { margin-bottom: 24px; } }
+/* Connected: the dots arrive from each icon toward the middle, 50 ms apart, then the check grows in and draws. */
+@media (prefers-reduced-motion: no-preference) {
+  [data-state="ok"] .run i { animation: dot 160ms var(--ease-out) both; }
+  [data-state="ok"] .run:first-of-type i:nth-child(2), [data-state="ok"] .run:last-of-type i:nth-child(3) { animation-delay: 50ms; }
+  [data-state="ok"] .run:first-of-type i:nth-child(3), [data-state="ok"] .run:last-of-type i:nth-child(2) { animation-delay: 100ms; }
+  [data-state="ok"] .run:first-of-type i:nth-child(4), [data-state="ok"] .run:last-of-type i:nth-child(1) { animation-delay: 150ms; }
+  [data-state="ok"] .knot { animation: knot 240ms var(--ease-out) 260ms both; }
+  [data-state="ok"] .knot path { stroke-dasharray: 16; animation: tick 200ms var(--ease-out) 400ms both; }
+}
+@keyframes dot { from { opacity: 0; transform: scale(.4); background: var(--ink-4); } }
+@keyframes knot { from { opacity: 0; transform: scale(.6); } }
+@keyframes tick { from { stroke-dashoffset: 16; } }
+"""  # noqa: E501
+
+GLYPHS = {
+    "ok": '<path d="m7.5 12.5 3 3 6-6.5" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" '
+          'stroke-linejoin="round"/>',
+    "error": '<path d="M12 7.5v5" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>'
+             '<circle cx="12" cy="16.25" r="1.25" fill="currentColor"/>',
+    "denied": "",
+    "pick": "",
+}
+
+
+def render(state, name, message):
+    """The page for ``state`` ("ok", "denied" or "error") about the connector called ``name``, with its mark when the
+    name is a service's (a preset keeps its service's name). ``name`` and ``message`` are never markup."""
+    if state == "ok":
+        message = BACK
+    title = {"ok": f"Connected to {name}", "denied": f"{name} isn’t connected"}.get(state,
+                                                                                    f"Mobster couldn’t connect {name}")
+    return document(state, name, title, message, script=HAND_BACK if state == "ok" else None)
+
+
+def document(state, name, title, message, *, script=None, nonce=None, actions="", style="", referrer="no-referrer"):
+    """The page: Mobster's icon and ``name``'s mark joined in ``state``, then ``title`` and ``message`` (text, never
+    markup), ``actions`` (markup) beside Open Mobster, and ``script`` inline, with ``nonce`` when the page's CSP names
+    one."""
+    # The app's typography: a curly apostrophe, also in a message the service or the listener wrote.
+    title, message = (text.replace("'", "’") for text in (title, message))
+    theirs = mark_of(name) or html.escape((name or "?").strip()[:1].upper())
+    dots = '<span class="run">' + "<i></i>" * 4 + "</span>"
+    link = (f'<div class="link" aria-hidden="true"><span class="tile"><img src="{_data(_TILE)}" alt=""></span>{dots}'
+            '<span class="knot"><svg width="24" height="24" viewBox="0 0 24 '
+            f'24">{GLYPHS.get(state, GLYPHS["error"])}</svg></span>{dots}<span class="tile">{theirs}</span></div>')
+    attribute = f' nonce="{nonce}"' if nonce else ""
+    script = f"<script{attribute}>{script}</script>" if script else ""
+    back = f'<a href="{APP_LINK}">Open Mobster</a>'
+    return ('<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,'
+            'initial-scale=1"><meta name="color-scheme" content="light dark"><meta '
+            f'name="referrer" content="{referrer}">'
+            f"<title>{html.escape(title)}</title><style>{_SANS}{brand.STYLESHEET}{STYLE}{style}</style>"
+            f'<header class="top"><span class="brand"><img src="{_data(_TILE)}" alt="">Mobster</span></header>'
+            f'<main data-state="{state if state in GLYPHS else "error"}" '
+            f'aria-live="polite">{link}<h1>{html.escape(title)}</h1><p>{html.escape(message)}</p>'
+            f'{f"<div class=actions>{actions}{back}</div>" if actions else back}</main>'
+            f"{script}</html>")
+
+
+def csp():
+    """The page's Content-Security-Policy: nothing from outside, inline styles and data: pictures and fonts, and the
+    hand-back script by its hash."""
+    digest = base64.b64encode(hashlib.sha256(HAND_BACK.encode()).digest()).decode()
+    return ("default-src 'none'; style-src 'unsafe-inline'; img-src data:; font-src data:; script-src "
+            f"'sha256-{digest}'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'")