modelmux-cli 0.1.0__py3-none-any.whl

modelmux_cli/__init__.py

@@ -0,0 +1,8 @@
+"""modelmux-cli: set up, log in to and run ModelMux."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("modelmux-cli")
+except PackageNotFoundError:  # pragma: no cover - running from a source tree
+    __version__ = "0.0.0"

modelmux_cli/__main__.py

@@ -0,0 +1,7 @@
+"""``python -m modelmux_cli``."""
+
+import sys
+
+from modelmux_cli.main import main
+
+sys.exit(main())

modelmux_cli/_shared/providers/claude.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "../schema/provider.schema.json",
+  "schema_version": 1,
+  "name": "claude",
+  "display_name": "Claude Code",
+  "driver": "claude",
+  "default_port": 8101,
+  "volume": "claude-home",
+  "home": "/home/modelmux/driver-home",
+  "example_model": "sonnet",
+  "login": {
+    "default_method": "browser",
+    "methods": {
+      "browser": {
+        "description": "Claude subscription: open a link, sign in, paste the code back",
+        "command": ["claude", "auth", "login"]
+      },
+      "console": {
+        "description": "Anthropic Console (API billing): open a link, sign in, paste the code back",
+        "command": ["claude", "auth", "login", "--console"]
+      }
+    },
+    "link_pattern": "https://\\S+",
+    "timeout_seconds": 600
+  },
+  "status": {
+    "command": ["claude", "auth", "status"],
+    "logged_in_exit_code": 0
+  },
+  "logout": {
+    "command": ["claude", "auth", "logout"]
+  },
+  "docs_url": "https://docs.anthropic.com/en/docs/claude-code"
+}

modelmux_cli/_shared/providers/codex.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "../schema/provider.schema.json",
+  "schema_version": 1,
+  "name": "codex",
+  "display_name": "OpenAI Codex",
+  "driver": "codex",
+  "default_port": 8102,
+  "volume": "codex-home",
+  "home": "/home/modelmux/driver-home",
+  "example_model": "gpt-6.1-sol",
+  "login": {
+    "default_method": "device",
+    "methods": {
+      "device": {
+        "description": "ChatGPT account: open a link and enter the one-time code shown",
+        "command": ["codex", "login", "--device-auth"]
+      },
+      "api-key": {
+        "description": "OpenAI API key, read from your terminal without echo",
+        "command": ["codex", "login", "--with-api-key"],
+        "secret_stdin": "OpenAI API key"
+      }
+    },
+    "link_pattern": "https://\\S+",
+    "timeout_seconds": 900
+  },
+  "status": {
+    "command": ["codex", "login", "status"],
+    "logged_in_exit_code": 0
+  },
+  "logout": {
+    "command": ["codex", "logout"]
+  },
+  "docs_url": "https://developers.openai.com/codex/cli"
+}

modelmux_cli/_shared/release.json

@@ -0,0 +1,4 @@
+{
+  "version": "0.1.0",
+  "image": "ghcr.io/smit153/modelmux@sha256:1edfd02f98bf739c874fa0db043bdbd46d907ac41d2bc30fb7f5b8b311381b72"
+}

modelmux_cli/_shared/schema/provider.schema.json

@@ -0,0 +1,81 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/smit153/modelmux/shared/schema/provider.schema.json",
+  "title": "ModelMux provider definition",
+  "description": "How the ModelMux CLI runs, logs in and checks one provider. Language-neutral: every CLI implementation reads these files.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema_version", "name", "display_name", "driver", "default_port", "volume", "home",
+    "example_model", "login", "status", "logout"
+  ],
+  "properties": {
+    "$schema": {"type": "string"},
+    "schema_version": {"const": 1},
+    "name": {"$ref": "#/$defs/identifier", "description": "Used on the command line: modelmux login <name>"},
+    "display_name": {"type": "string", "minLength": 1, "maxLength": 64},
+    "driver": {"$ref": "#/$defs/identifier", "description": "The server's MODELMUX_DRIVER value"},
+    "default_port": {"type": "integer", "minimum": 1024, "maximum": 65535},
+    "volume": {
+      "type": "string",
+      "pattern": "^[a-z0-9][a-z0-9_.-]{0,62}$",
+      "description": "Login volume name, unique per provider (prefixed with the compose project name)"
+    },
+    "home": {"type": "string", "pattern": "^/", "description": "HOME inside the container; the volume is mounted here"},
+    "example_model": {"type": "string", "minLength": 1, "maxLength": 64},
+    "login": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["default_method", "methods", "link_pattern", "timeout_seconds"],
+      "properties": {
+        "default_method": {"$ref": "#/$defs/identifier"},
+        "methods": {
+          "type": "object",
+          "minProperties": 1,
+          "propertyNames": {"$ref": "#/$defs/identifier"},
+          "additionalProperties": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["description", "command"],
+            "properties": {
+              "description": {"type": "string", "minLength": 1},
+              "command": {"$ref": "#/$defs/command"},
+              "secret_stdin": {
+                "type": "string",
+                "minLength": 1,
+                "description": "If set, prompt for this secret without echo and pass it on stdin"
+              }
+            }
+          }
+        },
+        "link_pattern": {"type": "string", "minLength": 1, "description": "Regex that finds the login link in the CLI's output"},
+        "timeout_seconds": {"type": "integer", "minimum": 30, "maximum": 3600}
+      }
+    },
+    "status": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["command", "logged_in_exit_code"],
+      "properties": {
+        "command": {"$ref": "#/$defs/command"},
+        "logged_in_exit_code": {"type": "integer"}
+      }
+    },
+    "logout": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["command"],
+      "properties": {"command": {"$ref": "#/$defs/command"}}
+    },
+    "docs_url": {"type": "string", "pattern": "^https://"}
+  },
+  "$defs": {
+    "identifier": {"type": "string", "pattern": "^[a-z][a-z0-9-]{0,31}$"},
+    "command": {
+      "type": "array",
+      "minItems": 1,
+      "description": "argv run inside a helper container; the first item is the entrypoint. Never a shell string.",
+      "items": {"type": "string", "pattern": "^[A-Za-z0-9._=/-]+$"}
+    }
+  }
+}

modelmux_cli/_shared/templates/compose-service.json

@@ -0,0 +1,12 @@
+{
+  "read_only": true,
+  "tmpfs": ["/tmp:rw,noexec,nosuid,nodev,size=512m"],
+  "cap_drop": ["ALL"],
+  "security_opt": ["no-new-privileges:true"],
+  "user": "10001:10001",
+  "pids_limit": 256,
+  "mem_limit": "2g",
+  "cpus": 2,
+  "restart": "on-failure:3",
+  "labels": {"io.modelmux.managed": "true"}
+}

modelmux_cli/_shared/templates/config/curl.json

@@ -0,0 +1,8 @@
+{
+  "description": "curl request",
+  "per": "provider",
+  "key_style": "shell",
+  "header": "",
+  "entry": "# {{display_name}}\ncurl {{base_url}}/chat/completions \\\n  -H \"Authorization: Bearer {{key}}\" \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"model\": \"{{model}}\", \"messages\": [{\"role\": \"user\", \"content\": \"Hello!\"}]}'\n\n",
+  "footer": ""
+}

modelmux_cli/_shared/templates/config/env.json

@@ -0,0 +1,8 @@
+{
+  "description": "Environment variables (.env)",
+  "per": "provider",
+  "key_style": "env",
+  "header": "MODELMUX_API_KEY={{key}}\n",
+  "entry": "MODELMUX_{{PROVIDER}}_BASE_URL={{base_url}}\nMODELMUX_{{PROVIDER}}_MODEL={{model}}\n",
+  "footer": ""
+}

modelmux_cli/_shared/templates/config/langchain.json

@@ -0,0 +1,8 @@
+{
+  "description": "LangChain ChatOpenAI",
+  "per": "provider",
+  "key_style": "python",
+  "header": "import os\n\nfrom langchain_openai import ChatOpenAI\n",
+  "entry": "\n# {{display_name}}\n{{provider_var}} = ChatOpenAI(\n    model=\"{{model}}\",\n    base_url=\"{{base_url}}\",\n    api_key={{key}},\n    use_responses_api=False,  # ModelMux implements Chat Completions\n)\nprint({{provider_var}}.invoke(\"Hello!\").content)\n",
+  "footer": ""
+}

modelmux_cli/_shared/templates/config/litellm.json

@@ -0,0 +1,8 @@
+{
+  "description": "LiteLLM proxy config.yaml (model_list)",
+  "per": "model",
+  "key_style": "litellm",
+  "header": "model_list:\n",
+  "entry": "  - model_name: {{provider}}-{{model}}\n    litellm_params:\n      model: openai/{{model}}\n      api_base: {{base_url}}\n      api_key: {{key}}\n",
+  "footer": ""
+}

modelmux_cli/_shared/templates/config/openai-python.json

@@ -0,0 +1,8 @@
+{
+  "description": "OpenAI Python SDK",
+  "per": "provider",
+  "key_style": "python",
+  "header": "import os\n\nfrom openai import OpenAI\n",
+  "entry": "\n# {{display_name}}\n{{provider_var}} = OpenAI(base_url=\"{{base_url}}\", api_key={{key}})\nreply = {{provider_var}}.chat.completions.create(\n    model=\"{{model}}\",\n    messages=[{\"role\": \"user\", \"content\": \"Hello!\"}],\n)\nprint(reply.choices[0].message.content)\n",
+  "footer": ""
+}

modelmux_cli/clientconfig.py

@@ -0,0 +1,87 @@
+"""Render client config snippets from ``shared/templates/config/<target>.json``."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from modelmux_cli.errors import CliError
+from modelmux_cli.providers import shared_dir
+
+KEY_ENV = "MODELMUX_API_KEY"
+TARGETS = ("litellm", "openai-python", "langchain", "curl", "env")
+
+# How each target refers to the key: (by reference, when revealed).
+_KEY_STYLES: dict[str, tuple[str, Any]] = {
+    "litellm": (f"os.environ/{KEY_ENV}", lambda key: key),
+    "python": (f'os.environ["{KEY_ENV}"]', json.dumps),
+    "shell": (f"${KEY_ENV}", lambda key: key),
+    "env": ("", lambda key: key),
+}
+_PLACEHOLDER = re.compile(r"\{\{(\w+)\}\}")
+
+
+@dataclass(frozen=True)
+class Template:
+    name: str
+    description: str
+    per: str
+    key_style: str
+    header: str
+    entry: str
+    footer: str
+
+
+@dataclass(frozen=True)
+class Target:
+    provider: str
+    display_name: str
+    base_url: str
+    models: tuple[str, ...]
+
+
+def load_template(name: str) -> Template:
+    path = shared_dir() / "templates" / "config" / f"{name}.json"
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        template = Template(name=name, **{k: data[k] for k in (
+            "description", "per", "key_style", "header", "entry", "footer")})  # fmt: skip
+    except (OSError, ValueError, KeyError, TypeError):
+        raise CliError(f"The {name!r} config template is missing or invalid.",
+                       hint="Please report this bug.") from None  # fmt: skip
+    if template.per not in {"provider", "model"} or template.key_style not in _KEY_STYLES:
+        raise CliError(f"The {name!r} config template is invalid.", hint="Please report this bug.")
+    return template
+
+
+def _fill(text: str, values: dict[str, str]) -> str:
+    def replace(match: re.Match[str]) -> str:
+        if match.group(1) not in values:
+            raise CliError(f"Unknown placeholder {match.group(0)} in a config template.",
+                           hint="Please report this bug.")  # fmt: skip
+        return values[match.group(1)]
+
+    return _PLACEHOLDER.sub(replace, text)
+
+
+def render(template: Template, targets: list[Target], api_key: str | None) -> str:
+    """``api_key`` None means: refer to $MODELMUX_API_KEY instead of the value."""
+    reference, literal = _KEY_STYLES[template.key_style]
+    key = reference if api_key is None else literal(api_key)
+    parts = [_fill(template.header, {"key": key})]
+    for target in targets:
+        models = target.models if template.per == "model" else target.models[:1]
+        for model in models:
+            parts.append(_fill(template.entry, {
+                "provider": target.provider,
+                "PROVIDER": target.provider.upper().replace("-", "_"),
+                "provider_var": target.provider.replace("-", "_"),
+                "display_name": target.display_name,
+                "model": model,
+                "base_url": target.base_url,
+                "key": key,
+            }))  # fmt: skip
+    parts.append(_fill(template.footer, {"key": key}))
+    return "".join(parts).rstrip("\n") + "\n"

modelmux_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""One module per command. Each exposes ``run(args, console) -> exit code``."""

modelmux_cli/commands/basic.py

@@ -0,0 +1,75 @@
+"""``modelmux down``, ``logs`` and ``status``."""
+
+from __future__ import annotations
+
+import argparse
+
+from modelmux_cli import health
+from modelmux_cli.console import Console
+from modelmux_cli.context import make_context
+from modelmux_cli.errors import CliError
+from modelmux_cli.stack import resolve_image, service_name
+
+NOT_SET_UP = "ModelMux is not set up on this machine yet."
+
+
+def down(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    if not ctx.stack.compose_file.exists():
+        console.success("ModelMux is not running.")
+        return 0
+    ctx.stack.compose("down", timeout=120)
+    console.success("Stopped ModelMux. Your logins are kept.")
+    return 0
+
+
+def logs(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    stack = ctx.stack
+    if not stack.compose_file.exists():
+        raise CliError(NOT_SET_UP, hint="Start it with: modelmux up")
+    services = [service_name(ctx.providers[args.provider])] if args.provider else []
+    follow = ["--follow"] if args.follow else []
+    return ctx.docker.passthrough(
+        "compose", "-p", "modelmux", "-f", str(stack.compose_file),
+        "logs", "--no-log-prefix" if args.provider else "--timestamps",
+        "--tail", str(max(args.tail, 0)), *follow, *services,
+    )  # fmt: skip
+
+
+def status(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    ctx.docker.check_available()
+    stack = ctx.stack
+    states = stack.states()
+    try:
+        image: str | None = resolve_image(ctx.config)
+    except CliError:
+        image = None
+
+    rows = [("PROVIDER", "CONTAINER", "LOGIN", "HEALTH", "URL")]
+    for name, provider in sorted(ctx.providers.items()):
+        state = states.get(service_name(provider))
+        port = ctx.config.port(name)
+        container = state.state if state else "not started"
+        login = "?" if image is None else ("yes" if stack.logged_in(provider, image) else "no")
+        if state and state.state == "running":
+            healthy = "ready" if health.ready(port) else "starting"
+        else:
+            healthy = "-"
+        url = f"{health.base_url(port)}/v1" if healthy == "ready" else "-"
+        rows.append((name, container, login, healthy, url))
+
+    widths = [max(len(row[i]) for row in rows) for i in range(len(rows[0]))]
+    for row in rows:
+        console.print("  ".join(cell.ljust(widths[i]) for i, cell in enumerate(row)).rstrip())
+
+    if image is None:
+        console.step("No server image chosen yet: run 'modelmux up' first.")
+    for name, provider in sorted(ctx.providers.items()):
+        state = states.get(service_name(provider))
+        if state and state.state in {"exited", "dead"}:
+            console.step(
+                f"{provider.display_name} has stopped. If its login expired: modelmux login {name}"
+            )
+    return 0

modelmux_cli/commands/config_cmd.py

@@ -0,0 +1,65 @@
+"""``modelmux key show`` and ``modelmux config <target>``."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from modelmux_cli import health
+from modelmux_cli.clientconfig import KEY_ENV, Target, load_template, render
+from modelmux_cli.console import Console
+from modelmux_cli.context import make_context
+from modelmux_cli.errors import CliError
+from modelmux_cli.providers import get_provider
+from modelmux_cli.secrets_store import ApiKey, read_api_key
+
+
+def _key(home: Path) -> ApiKey:
+    key = read_api_key(home)
+    if key is None:
+        raise CliError("ModelMux is not set up yet, so there is no API key.",
+                       hint="Run: modelmux up")  # fmt: skip
+    return key
+
+
+def key_show(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    key = _key(ctx.home)
+    console.reveal(key.value)
+    console.note("Treat this like a password. Clients send it as: Authorization: Bearer <key>")
+    return 0
+
+
+def models_for(port: int, api_key: str) -> list[str]:
+    status, body = health.get_json(port, "/v1/models", api_key=api_key)
+    if status != 200 or not isinstance(body, dict) or not isinstance(body.get("data"), list):
+        return []
+    return [m["id"] for m in body["data"] if isinstance(m, dict) and isinstance(m.get("id"), str)]
+
+
+def config(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    template = load_template(args.target)
+    key = _key(ctx.home)
+    names = [args.provider] if args.provider else sorted(ctx.providers)
+    targets = []
+    for name in names:
+        provider = get_provider(name)
+        port = ctx.config.port(name)
+        models = models_for(port, key.value)
+        if not models:
+            models = [provider.example_model]
+            console.note(f"{provider.display_name} is not running; using its example model "
+                         f"'{provider.example_model}'.")  # fmt: skip
+        targets.append(Target(name, provider.display_name, f"{health.base_url(port)}/v1",
+                              tuple(models)))  # fmt: skip
+    text = render(template, targets, key.value if args.reveal_key else None)
+    if args.reveal_key:
+        console.reveal(text.rstrip("\n"))
+    else:
+        console.print(text.rstrip("\n"))
+        if template.key_style != "env":
+            console.note(f"Set {KEY_ENV} first: export {KEY_ENV}=$(modelmux key show)")
+        else:
+            console.note("Add the key yourself (modelmux key show), or use --reveal-key.")
+    return 0

modelmux_cli/commands/doctor.py

@@ -0,0 +1,190 @@
+"""``modelmux doctor``: diagnose common problems, each with a suggested fix."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import stat
+from dataclasses import dataclass, field
+
+from modelmux_cli import __version__, health, updates
+from modelmux_cli.console import Console
+from modelmux_cli.context import Context, make_context
+from modelmux_cli.errors import CliError, DockerError
+from modelmux_cli.ports import port_free
+from modelmux_cli.providers import Provider
+from modelmux_cli.secrets_store import SECRETS_FILE, read_api_key
+from modelmux_cli.stack import resolve_image, service_name
+
+
+@dataclass
+class Report:
+    console: Console
+    failures: int = 0
+    warnings: int = 0
+    lines: list[str] = field(default_factory=list)
+
+    def ok(self, text: str) -> None:
+        self.console.success(text)
+
+    def warn(self, text: str, hint: str | None = None) -> None:
+        self.warnings += 1
+        self.console.warn(text + (f"\n    {hint}" if hint else ""))
+
+    def fail(self, text: str, hint: str | None = None) -> None:
+        self.failures += 1
+        self.console.error(text, hint)
+
+
+def startup_failure_reason(ctx: Context, provider: Provider) -> str | None:
+    """The server's own reason for refusing to start, from its recent logs."""
+    result = ctx.stack.compose(
+        "logs", "--no-log-prefix", "--tail", "200", service_name(provider), check=False
+    )
+    reason = None
+    for line in result.stdout.splitlines():
+        try:
+            entry = json.loads(line)
+        except ValueError:
+            continue
+        if isinstance(entry, dict) and entry.get("event") == "probe_failed":
+            value = entry.get("reason")
+            reason = value if isinstance(value, str) else reason
+    return reason
+
+
+def check_docker(ctx: Context, report: Report) -> bool:
+    try:
+        version = ctx.docker.check_available()
+    except DockerError as exc:
+        report.fail(exc.message, exc.hint)
+        return False
+    report.ok(f"Docker {version} is running, with Compose v2")
+    return True
+
+
+def check_network_and_version(report: Report) -> None:
+    if updates.registry_reachable():
+        report.ok("The image registry (ghcr.io) is reachable")
+    else:
+        report.warn(
+            "Cannot reach ghcr.io (needed to download the server image)",
+            "Check your connection or proxy (HTTPS_PROXY, and Docker's proxy settings).",
+        )
+    latest = updates.latest_version()
+    if latest is None:
+        report.warn("Could not check PyPI for a newer modelmux-cli")
+    elif updates.newer_available(__version__, latest):
+        report.warn(f"modelmux-cli {latest} is available (you have {__version__})",
+                    updates.UPGRADE_HINT)  # fmt: skip
+    else:
+        report.ok(f"modelmux-cli {__version__} is the latest version")
+
+
+def check_files(ctx: Context, report: Report) -> bool:
+    key_path = ctx.home / SECRETS_FILE
+    if not key_path.exists():
+        report.fail("ModelMux is not set up on this machine yet", "Run: modelmux up")
+        return False
+    if os.name == "posix":
+        for path, mode in ((ctx.home, 0o700), (key_path, 0o600)):
+            if stat.S_IMODE(path.stat().st_mode) != mode:
+                report.fail(
+                    f"{path} is readable by other users", f"Fix it: chmod {mode:o} '{path}'"
+                )
+                return True
+    report.ok(f"Settings and API key are in {ctx.home}")
+    return True
+
+
+def port_conflict(ctx: Context, provider: Provider, report: Report) -> bool:
+    port = ctx.config.port(provider.name)
+    if port_free(port):
+        return False
+    report.fail(
+        f"{provider.display_name}: port {port} is used by another program",
+        f"Choose another: modelmux up --port {provider.name}=<port>",
+    )
+    return True
+
+
+def stopped_hint(provider: Provider, reason: str | None) -> str:
+    if reason and "auth" in reason:
+        return f"The login has expired or was revoked: modelmux login {provider.name} --force"
+    if reason and any(word in reason for word in ("version", "flag", "feature", "config key")):
+        return "The CLI inside the image is not supported: modelmux upgrade"
+    return f"See its logs: modelmux logs {provider.name}"
+
+
+def check_running(ctx: Context, provider: Provider, api_key: str, report: Report) -> None:
+    name, display = provider.name, provider.display_name
+    port = ctx.config.port(name)
+    if not health.ready(port):
+        report.warn(f"{display}: running but not ready yet", f"Watch it: modelmux logs {name} -f")
+        return
+    status, _ = health.get_json(port, "/v1/models", api_key=api_key)
+    if status == 200:
+        report.ok(f"{display}: logged in, running and answering at {health.base_url(port)}/v1")
+    elif status == 401:
+        report.fail(
+            f"{display}: the server does not accept the saved API key",
+            "Recreate it with the current key: modelmux up",
+        )
+    else:
+        report.fail(
+            f"{display}: the API did not answer correctly (HTTP {status})",
+            f"See its logs: modelmux logs {name}",
+        )
+
+
+def check_provider(
+    ctx: Context, provider: Provider, image: str, api_key: str, report: Report
+) -> None:
+    display = provider.display_name
+    if not ctx.stack.logged_in(provider, image):
+        report.warn(f"{display}: not logged in", f"Run: modelmux login {provider.name}")
+        port_conflict(ctx, provider, report)
+        return
+    state = ctx.stack.states().get(service_name(provider))
+    if state is None:
+        if not port_conflict(ctx, provider, report):
+            report.warn(f"{display}: logged in but not running", "Start it: modelmux up")
+        return
+    if state.state != "running":
+        reason = startup_failure_reason(ctx, provider)
+        detail = f" ({reason})" if reason else ""
+        report.fail(f"{display}: the server stopped{detail}", stopped_hint(provider, reason))
+        return
+    check_running(ctx, provider, api_key, report)
+
+
+def run(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    report = Report(console)
+    docker_ok = check_docker(ctx, report)
+    check_network_and_version(report)
+    set_up = check_files(ctx, report)
+    if docker_ok and set_up:
+        try:
+            image = resolve_image(ctx.config)
+        except CliError as exc:
+            report.fail(exc.message, exc.hint)
+        else:
+            if ctx.stack.image_present(image):
+                report.ok(f"Server image {image} is present")
+            else:
+                report.warn(f"Server image {image} is not downloaded yet", "Run: modelmux up")
+            key = read_api_key(ctx.home)
+            for provider in sorted(ctx.providers.values(), key=lambda p: p.name):
+                check_provider(ctx, provider, image, key.value if key else "", report)
+
+    console.print()
+    if report.failures:
+        console.error(f"{report.failures} problem(s) found.")
+        return 1
+    if report.warnings:
+        console.success(f"No problems, {report.warnings} note(s).")
+    else:
+        console.success("Everything looks good.")
+    return 0