modelmux-cli 0.1.0__py3-none-any.whl

modelmux_cli/providers.py

@@ -0,0 +1,168 @@
+"""Provider definitions, loaded from the shared JSON files.
+
+The files are validated strictly here (no dependency needed); the test suite
+additionally validates them against ``shared/schema/provider.schema.json``.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from functools import cache
+from pathlib import Path
+from typing import Any
+
+from modelmux_cli.errors import CliError, UsageError
+
+_IDENTIFIER = re.compile(r"^[a-z][a-z0-9-]{0,31}$")
+_VOLUME = re.compile(r"^[a-z0-9][a-z0-9_.-]{0,62}$")
+_ARG = re.compile(r"^[A-Za-z0-9._=/-]+$")
+
+
+@dataclass(frozen=True)
+class LoginMethod:
+    name: str
+    description: str
+    command: tuple[str, ...]
+    secret_stdin: str | None = None
+
+
+@dataclass(frozen=True)
+class Provider:
+    name: str
+    display_name: str
+    driver: str
+    default_port: int
+    volume: str
+    home: str
+    example_model: str
+    login_methods: dict[str, LoginMethod]
+    default_login_method: str
+    link_pattern: re.Pattern[str]
+    login_timeout: int
+    status_command: tuple[str, ...]
+    logged_in_exit_code: int
+    logout_command: tuple[str, ...]
+    docs_url: str | None
+
+
+def shared_dir() -> Path:
+    """The bundled shared data, or the repository's /shared when run from source."""
+    here = Path(__file__).resolve().parent
+    bundled = here / "_shared"
+    if bundled.is_dir():
+        return bundled
+    return here.parents[3] / "shared"  # cli/python/src/modelmux_cli -> repo root
+
+
+class ProviderFileError(CliError):
+    def __init__(self, path: Path, problem: str) -> None:
+        super().__init__(
+            f"Provider definition {path.name} is invalid: {problem}",
+            hint="This is a packaging bug; please report it.",
+        )
+
+
+def _require(data: dict[str, Any], key: str, kind: type, path: Path) -> Any:
+    value = data.get(key)
+    # bool is a subclass of int; never accept true/false where a number is expected.
+    if not isinstance(value, kind) or (isinstance(value, bool) and kind is not bool):
+        raise ProviderFileError(path, f"'{key}' must be a {kind.__name__}")
+    return value
+
+
+def _command(value: Any, path: Path, where: str) -> tuple[str, ...]:
+    if (
+        not isinstance(value, list)
+        or not value
+        or not all(isinstance(a, str) and _ARG.fullmatch(a) for a in value)
+    ):
+        raise ProviderFileError(path, f"'{where}' must be a non-empty list of plain arguments")
+    return tuple(value)
+
+
+def _parse(path: Path) -> Provider:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as exc:
+        raise ProviderFileError(path, f"cannot be read ({type(exc).__name__})") from None
+    if not isinstance(data, dict) or data.get("schema_version") != 1:
+        raise ProviderFileError(path, "unsupported schema_version")
+
+    name = _require(data, "name", str, path)
+    if not _IDENTIFIER.fullmatch(name) or path.stem != name:
+        raise ProviderFileError(path, "'name' must be an identifier matching the file name")
+    volume = _require(data, "volume", str, path)
+    if not _VOLUME.fullmatch(volume):
+        raise ProviderFileError(path, "'volume' is not a valid volume name")
+    home = _require(data, "home", str, path)
+    if not home.startswith("/"):
+        raise ProviderFileError(path, "'home' must be an absolute container path")
+    port = _require(data, "default_port", int, path)
+    if not 1024 <= port <= 65535:
+        raise ProviderFileError(path, "'default_port' must be between 1024 and 65535")
+
+    login = _require(data, "login", dict, path)
+    methods: dict[str, LoginMethod] = {}
+    for method_name, method in _require(login, "methods", dict, path).items():
+        if not _IDENTIFIER.fullmatch(method_name) or not isinstance(method, dict):
+            raise ProviderFileError(path, f"invalid login method {method_name!r}")
+        secret = method.get("secret_stdin")
+        methods[method_name] = LoginMethod(
+            name=method_name,
+            description=_require(method, "description", str, path),
+            command=_command(method.get("command"), path, f"login.methods.{method_name}"),
+            secret_stdin=secret if isinstance(secret, str) else None,
+        )
+    default_method = _require(login, "default_method", str, path)
+    if default_method not in methods:
+        raise ProviderFileError(path, "'login.default_method' is not one of the methods")
+    try:
+        link_pattern = re.compile(_require(login, "link_pattern", str, path))
+    except re.error:
+        raise ProviderFileError(path, "'login.link_pattern' is not a valid regex") from None
+
+    status = _require(data, "status", dict, path)
+    logout = _require(data, "logout", dict, path)
+    docs_url = data.get("docs_url")
+    return Provider(
+        name=name,
+        display_name=_require(data, "display_name", str, path),
+        driver=_require(data, "driver", str, path),
+        default_port=port,
+        volume=volume,
+        home=home,
+        example_model=_require(data, "example_model", str, path),
+        login_methods=methods,
+        default_login_method=default_method,
+        link_pattern=link_pattern,
+        login_timeout=_require(login, "timeout_seconds", int, path),
+        status_command=_command(status.get("command"), path, "status.command"),
+        logged_in_exit_code=_require(status, "logged_in_exit_code", int, path),
+        logout_command=_command(logout.get("command"), path, "logout.command"),
+        docs_url=docs_url if isinstance(docs_url, str) else None,
+    )
+
+
+@cache
+def load_providers(directory: Path | None = None) -> dict[str, Provider]:
+    directory = directory or shared_dir() / "providers"
+    providers = {p.name: p for p in map(_parse, sorted(directory.glob("*.json")))}
+    if not providers:
+        raise CliError(
+            "No provider definitions found.", hint="This is a packaging bug; please report it."
+        )
+    volumes = [p.volume for p in providers.values()]
+    if len(volumes) != len(set(volumes)):
+        raise CliError("Two providers share a login volume.", hint="Please report this bug.")
+    return providers
+
+
+def get_provider(name: str) -> Provider:
+    providers = load_providers()
+    if name not in providers:
+        raise UsageError(
+            f"Unknown provider {name!r}.", hint=f"Choose one of: {', '.join(sorted(providers))}."
+        )
+    return providers[name]

modelmux_cli/redact.py

@@ -0,0 +1,35 @@
+"""Mask secrets in anything the CLI prints (including --verbose output)."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+
+MASK = "[REDACTED]"
+
+_PATTERNS = (
+    (re.compile(r"(?i)\b(bearer)\s+[A-Za-z0-9._~+/=-]+"), r"\1 " + MASK),
+    (re.compile(r"\bsk-[A-Za-z0-9_-]{8,}"), MASK),
+    (re.compile(r"\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]*"), MASK),
+    # The server's key list: only values that look like keys, not "$(...)" hints.
+    (re.compile(r"\b(MODELMUX_API_KEYS=)[A-Za-z0-9_,-]{16,}"), r"\1" + MASK),
+)
+
+_secrets: set[str] = set()
+
+
+def register_secret(*values: str) -> None:
+    """Mask these exact values everywhere from now on (e.g. the server API key)."""
+    _secrets.update(v for v in values if len(v) >= 8)
+
+
+def registered() -> Iterable[str]:
+    return frozenset(_secrets)
+
+
+def redact(text: str) -> str:
+    for secret in sorted(_secrets, key=len, reverse=True):
+        text = text.replace(secret, MASK)
+    for pattern, replacement in _PATTERNS:
+        text = pattern.sub(replacement, text)
+    return text

modelmux_cli/release.py

@@ -0,0 +1,40 @@
+"""The release this CLI belongs to, from ``shared/release.json``.
+
+The release workflow writes the server image pinned by digest
+(``ghcr.io/smit153/modelmux@sha256:...``) into that file before building, so
+every CLI implementation (Python today, Node later) runs the same image. In a
+development checkout ``image`` is null: pass ``--image`` instead.
+"""
+
+from __future__ import annotations
+
+import json
+from functools import cache
+from typing import Any
+
+from modelmux_cli.errors import CliError
+from modelmux_cli.providers import shared_dir
+
+
+@cache
+def release_data() -> dict[str, Any]:
+    path = shared_dir() / "release.json"
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        raise CliError(
+            "The release data is missing or damaged.", hint="Please report this bug."
+        ) from None
+    if not isinstance(data, dict) or not isinstance(data.get("version"), str):
+        raise CliError("The release data is invalid.", hint="Please report this bug.")
+    image = data.get("image")
+    if image is not None and not (isinstance(image, str) and "@sha256:" in image):
+        raise CliError(
+            "The pinned server image is not pinned by digest.", hint="Please report this bug."
+        )
+    return data
+
+
+def pinned_image() -> str | None:
+    image = release_data().get("image")
+    return image if isinstance(image, str) else None

modelmux_cli/secrets_store.py

@@ -0,0 +1,71 @@
+"""The API key clients use to call ModelMux (not a provider credential).
+
+Generated once with ``secrets``, stored in ``secrets.env`` with mode 0600 in
+the format compose reads as an env file. The value is registered for
+redaction as soon as it is loaded, so it never appears in output unless the
+user explicitly asks for it (``modelmux key show``).
+"""
+
+from __future__ import annotations
+
+import re
+import secrets
+from dataclasses import dataclass
+from pathlib import Path
+
+from modelmux_cli.errors import CliError
+from modelmux_cli.files import tighten, write_private
+from modelmux_cli.paths import ensure_private_dir
+from modelmux_cli.redact import register_secret
+
+SECRETS_FILE = "secrets.env"
+VARIABLE = "MODELMUX_API_KEYS"
+KEY_BYTES = 32  # token_urlsafe(32) -> 43 characters; the server requires >= 32
+_LINE = re.compile(rf"^{VARIABLE}=([A-Za-z0-9_-]{{32,}})$")
+
+
+@dataclass(frozen=True)
+class ApiKey:
+    value: str
+    path: Path
+    created: bool = False
+    permissions_fixed: bool = False
+
+
+class SecretsFileError(CliError):
+    def __init__(self, path: Path) -> None:
+        super().__init__(
+            "The saved ModelMux API key is unreadable or damaged.",
+            hint=f"Delete {path} and run 'modelmux up' to create a new key "
+            "(clients using the old key will need the new one).",
+        )
+
+
+def read_api_key(directory: Path) -> ApiKey | None:
+    path = directory / SECRETS_FILE
+    if not path.exists():
+        return None
+    fixed = tighten(path)
+    try:
+        lines = [ln.strip() for ln in path.read_text(encoding="utf-8").splitlines() if ln.strip()]
+    except OSError:
+        raise SecretsFileError(path) from None
+    match = _LINE.fullmatch(lines[0]) if len(lines) == 1 else None
+    if match is None:
+        raise SecretsFileError(path)
+    value = match.group(1)
+    register_secret(value)
+    return ApiKey(value, path, permissions_fixed=fixed)
+
+
+def ensure_api_key(directory: Path) -> ApiKey:
+    """Return the saved key, creating one on first use."""
+    existing = read_api_key(directory)
+    if existing is not None:
+        return existing
+    ensure_private_dir(directory)
+    value = secrets.token_urlsafe(KEY_BYTES)
+    register_secret(value)
+    path = directory / SECRETS_FILE
+    write_private(path, f"{VARIABLE}={value}\n")
+    return ApiKey(value, path, created=True)

modelmux_cli/stack.py

@@ -0,0 +1,217 @@
+"""The ModelMux containers on this machine: image, compose file, login volumes.
+
+All containers belong to the compose project ``modelmux``. Each provider has
+one service (``modelmux-<provider>``) and one *external* login volume
+(``modelmux_<provider>-home``) that only ``modelmux logout`` deletes.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from modelmux_cli import release
+from modelmux_cli.config import Config
+from modelmux_cli.docker import PULL_TIMEOUT, Docker
+from modelmux_cli.errors import CliError, DockerError, UsageError
+from modelmux_cli.files import write_private
+from modelmux_cli.providers import Provider, shared_dir
+
+PROJECT = "modelmux"
+COMPOSE_FILE = "compose.yaml"  # JSON content; YAML is a superset of JSON
+CONTAINER_PORT = 8000
+# tmpfs mount spec inside helper containers (not a host path)
+CONTAINER_TMP = "/tmp:rw,noexec,nosuid,nodev,size=64m"  # noqa: S108
+_IMAGE_REF = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._/:@-]{0,254}$")
+
+
+def volume_name(provider: Provider) -> str:
+    return f"{PROJECT}_{provider.volume}"
+
+
+def service_name(provider: Provider) -> str:
+    return f"{PROJECT}-{provider.name}"
+
+
+def resolve_image(config: Config, override: str | None = None) -> str:
+    """The image to run: --image, then the saved override, then the pinned release image."""
+    image = override or config.image or release.pinned_image()
+    if image is None:
+        raise UsageError(
+            "This development build of modelmux has no pinned server image.",
+            hint="Pass one explicitly, e.g. --image modelmux:dev (it is remembered).",
+        )
+    if not _IMAGE_REF.fullmatch(image):
+        raise UsageError(f"{image!r} is not a valid image reference.")
+    return image
+
+
+def service_template() -> dict[str, Any]:
+    path = shared_dir() / "templates" / "compose-service.json"
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise CliError("The compose template is invalid.", hint="Please report this bug.")
+    return data
+
+
+def build_compose(
+    providers: dict[str, Provider], config: Config, image: str, secrets_file: Path
+) -> dict[str, Any]:
+    template = service_template()
+    services: dict[str, Any] = {}
+    volumes: dict[str, Any] = {}
+    for name, provider in sorted(providers.items()):
+        services[service_name(provider)] = {
+            **template,
+            "image": image,
+            "environment": {"MODELMUX_DRIVER": provider.driver},
+            "env_file": [str(secrets_file)],
+            "volumes": [f"{provider.volume}:{provider.home}"],
+            "ports": [f"127.0.0.1:{config.port(name)}:{CONTAINER_PORT}"],
+            "networks": [PROJECT],
+            "labels": {**template.get("labels", {}), "io.modelmux.provider": name},
+        }
+        volumes[provider.volume] = {"external": True, "name": volume_name(provider)}
+    return {
+        "name": PROJECT,
+        "services": services,
+        "volumes": volumes,
+        "networks": {PROJECT: {"driver": "bridge"}},
+    }
+
+
+def write_compose(directory: Path, compose: dict[str, Any]) -> Path:
+    path = directory / COMPOSE_FILE
+    header = "# Generated by modelmux. Do not edit: changes are overwritten by 'modelmux up'.\n"
+    write_private(path, header + json.dumps(compose, indent=2) + "\n")
+    return path
+
+
+@dataclass(frozen=True)
+class ServiceState:
+    service: str
+    state: str  # running, exited, restarting, created, ...
+    health: str  # healthy, unhealthy, starting, or ""
+    exit_code: int | None
+
+
+class Stack:
+    def __init__(self, docker: Docker, home: Path) -> None:
+        self.docker = docker
+        self.home = home
+
+    @property
+    def compose_file(self) -> Path:
+        return self.home / COMPOSE_FILE
+
+    # ------------------------------------------------------------ image
+
+    def image_present(self, image: str) -> bool:
+        return self.docker.run("image", "inspect", image, check=False).ok
+
+    def ensure_image(self, image: str) -> bool:
+        """Pull ``image`` if it is not present. Returns True if it was pulled."""
+        if self.image_present(image):
+            return False
+        try:
+            self.docker.run("pull", image, timeout=PULL_TIMEOUT)
+        except DockerError as exc:
+            if "/" in image.split("@", maxsplit=1)[0]:
+                raise
+            # A local-only name such as modelmux:dev.
+            raise DockerError(
+                f"The image {image} is not on this machine and could not be downloaded.",
+                hint=f"Build it first: docker build -f docker/Dockerfile -t {image} .",
+            ) from exc
+        return True
+
+    # ------------------------------------------------------------ volumes
+
+    def volume_exists(self, provider: Provider) -> bool:
+        return self.docker.run("volume", "inspect", volume_name(provider), check=False).ok
+
+    def ensure_volume(self, provider: Provider) -> None:
+        if not self.volume_exists(provider):
+            self.docker.run(
+                "volume", "create",
+                "--label", "io.modelmux.managed=true",
+                "--label", f"io.modelmux.provider={provider.name}",
+                volume_name(provider),
+            )  # fmt: skip
+
+    # ------------------------------------------------------------ helper containers
+
+    def helper_args(
+        self,
+        provider: Provider,
+        image: str,
+        command: tuple[str, ...],
+        extra: tuple[str, ...] = (),
+    ) -> list[str]:
+        """``docker run`` arguments for a short-lived, hardened helper container.
+
+        ``extra`` adds run options such as ``-it`` or ``--name``.
+        """
+        return [
+            "run", "--rm", *extra,
+            "--read-only", "--tmpfs", CONTAINER_TMP,
+            "--cap-drop", "ALL", "--security-opt", "no-new-privileges:true",
+            "--user", "10001:10001",
+            "--label", "io.modelmux.managed=true",
+            "-v", f"{volume_name(provider)}:{provider.home}",
+            "-e", f"HOME={provider.home}",
+            "--entrypoint", command[0],
+            image, *command[1:],
+        ]  # fmt: skip
+
+    def logged_in(self, provider: Provider, image: str) -> bool:
+        if not self.volume_exists(provider):
+            return False
+        result = self.docker.run(
+            *self.helper_args(provider, image, provider.status_command), check=False, timeout=90
+        )
+        return result.returncode == provider.logged_in_exit_code
+
+    # ------------------------------------------------------------ compose
+
+    def compose(self, *args: str, **kwargs: Any) -> Any:
+        return self.docker.compose(PROJECT, self.compose_file, *args, **kwargs)
+
+    def states(self) -> dict[str, ServiceState]:
+        """Current containers of the project, by service name. Empty if none."""
+        if not self.compose_file.exists():
+            return {}
+        result = self.compose("ps", "--all", "--format", "json", check=False)
+        if not result.ok:
+            return {}
+        return parse_ps(result.stdout)
+
+
+def parse_ps(output: str) -> dict[str, ServiceState]:
+    """``docker compose ps --format json`` output: one object per line, or one array."""
+    text = output.strip()
+    if not text:
+        return {}
+    try:
+        items = (
+            json.loads(text)
+            if text.startswith("[")
+            else [json.loads(line) for line in text.splitlines() if line.strip()]
+        )
+    except ValueError:
+        return {}
+    states: dict[str, ServiceState] = {}
+    for item in items:
+        if not isinstance(item, dict) or not isinstance(item.get("Service"), str):
+            continue
+        code = item.get("ExitCode")
+        states[item["Service"]] = ServiceState(
+            service=item["Service"],
+            state=str(item.get("State", "")),
+            health=str(item.get("Health", "")),
+            exit_code=code if isinstance(code, int) else None,
+        )
+    return states

modelmux_cli/terminal.py

@@ -0,0 +1,44 @@
+"""Find the login link in a provider CLI's terminal output.
+
+Output arrives in arbitrary chunks and contains escape sequences: colours
+(CSI) and OSC 8 hyperlinks, which carry the URL a second time. Escapes are
+removed from a rolling buffer, and a link is only reported once it is
+complete, i.e. followed by whitespace, so a URL split across reads is never
+opened half-finished.
+"""
+
+from __future__ import annotations
+
+import re
+
+_OSC = re.compile(rb"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)")
+_CSI = re.compile(rb"\x1b\[[0-9;?]*[ -/]*[@-~]")
+_OTHER_ESC = re.compile(rb"\x1b[@-Z\\-_]")
+_BUFFER_LIMIT = 64 * 1024
+
+
+def strip_escapes(data: bytes) -> str:
+    data = _OSC.sub(b"", data)
+    data = _CSI.sub(b"", data)
+    data = _OTHER_ESC.sub(b"", data)
+    return data.decode("utf-8", "replace")
+
+
+class LinkScanner:
+    def __init__(self, pattern: re.Pattern[str]) -> None:
+        self.pattern = pattern
+        self._raw = b""
+        self.link: str | None = None
+
+    def feed(self, data: bytes) -> str | None:
+        """Add output. Returns the link the first time a complete one is seen."""
+        if self.link is not None:
+            return None
+        self._raw = (self._raw + data)[-_BUFFER_LIMIT:]
+        text = strip_escapes(self._raw)
+        for match in self.pattern.finditer(text):
+            end = match.end()
+            if end < len(text) and text[end].isspace():
+                self.link = match.group(0)
+                return self.link
+        return None

modelmux_cli/updates.py

@@ -0,0 +1,50 @@
+"""Network checks used only by ``doctor`` and ``upgrade`` (never in the background).
+
+Both honour the usual proxy variables (HTTPS_PROXY / NO_PROXY) via urllib.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import urllib.error
+import urllib.request
+
+PYPI_URL = "https://pypi.org/pypi/modelmux-cli/json"
+REGISTRY_URL = "https://ghcr.io/v2/"
+UPGRADE_HINT = "pipx upgrade modelmux-cli   (or: uvx --from modelmux-cli@latest modelmux)"
+_RELEASE = re.compile(r"^\d+(\.\d+)*$")
+
+
+def parse_version(value: str) -> tuple[int, ...] | None:
+    """Plain releases only ("1.2.3"); pre-releases and local versions are ignored."""
+    return tuple(int(part) for part in value.split(".")) if _RELEASE.fullmatch(value) else None
+
+
+def latest_version(timeout: float = 5.0) -> str | None:
+    """The newest modelmux-cli on PyPI, or None if it cannot be checked."""
+    try:
+        with urllib.request.urlopen(PYPI_URL, timeout=timeout) as response:
+            data = json.loads(response.read())
+    except (urllib.error.URLError, OSError, ValueError):
+        return None
+    version = data.get("info", {}).get("version") if isinstance(data, dict) else None
+    return version if isinstance(version, str) else None
+
+
+def newer_available(current: str, latest: str | None) -> bool:
+    if latest is None:
+        return False
+    now, new = parse_version(current), parse_version(latest)
+    return now is not None and new is not None and new > now
+
+
+def registry_reachable(timeout: float = 5.0) -> bool:
+    """Can we reach the image registry? Any HTTP answer (even 401) counts."""
+    try:
+        with urllib.request.urlopen(REGISTRY_URL, timeout=timeout):
+            return True
+    except urllib.error.HTTPError:
+        return True
+    except (urllib.error.URLError, OSError):
+        return False

modelmux_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.5
+Name: modelmux-cli
+Version: 0.1.0
+Summary: Set up, log in to and run ModelMux: AI coding CLIs as an OpenAI-compatible API
+Project-URL: Homepage, https://github.com/smit153/modelmux
+Project-URL: Source, https://github.com/smit153/modelmux
+Project-URL: Issues, https://github.com/smit153/modelmux/issues
+License-Expression: Apache-2.0
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# modelmux-cli
+
+Set up, log in to and run [ModelMux](https://github.com/smit153/modelmux):
+AI coding CLIs (Claude Code, Codex) as a secure, OpenAI-compatible API on your
+own machine.
+
+```bash
+pipx install modelmux-cli      # or: uvx --from modelmux-cli modelmux
+modelmux up                    # set up Docker containers, start logged-in providers
+modelmux login claude          # guided login (opens your browser), then a real test
+modelmux config litellm        # ready-to-paste config for LiteLLM, OpenAI SDK, LangChain...
+```
+
+Other commands: `status`, `logs`, `doctor`, `upgrade`, `logout`, `key show`, `down`.
+
+- Requires Docker with Compose v2 (Docker Desktop on macOS and Windows) and
+  Python 3.10+. No other dependencies.
+- Each CLI release runs the server image built in the same release, pinned by
+  digest.
+- Logins live in per-provider Docker volumes; the API key is generated
+  locally and stored with owner-only permissions.
+
+Full documentation: <https://github.com/smit153/modelmux/blob/main/docs/CLI.md>