modelmux-cli 0.1.0__py3-none-any.whl

modelmux_cli/commands/login.py

@@ -0,0 +1,190 @@
+"""``modelmux login <provider>``: guided login, then a real test.
+
+The provider's own login command runs in a short-lived, hardened helper
+container with only that provider's login volume. On Linux and macOS it runs
+on a pseudo-terminal so the login link can be spotted and opened in the
+browser while the user still types or pastes codes directly into the CLI.
+On Windows (or with ``--raw``) the user's console is attached directly.
+
+Keystrokes, pasted codes and API keys are never stored or logged.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import getpass
+import os
+import secrets
+import signal
+import sys
+import threading
+import webbrowser
+from collections.abc import Callable, Iterator
+
+from modelmux_cli import health
+from modelmux_cli.commands import up as up_module
+from modelmux_cli.console import Console
+from modelmux_cli.context import Context, make_context
+from modelmux_cli.errors import CliError, DockerError, UsageError
+from modelmux_cli.providers import LoginMethod, Provider, get_provider
+from modelmux_cli.redact import register_secret
+from modelmux_cli.stack import resolve_image, service_name
+from modelmux_cli.terminal import LinkScanner
+
+SECRET_LOGIN_TIMEOUT = 120.0
+
+# Replaceable in tests.
+open_browser: Callable[[str], bool] = webbrowser.open
+read_secret: Callable[[str], str] = getpass.getpass
+
+
+def use_pty(args: argparse.Namespace) -> bool:
+    return os.name == "posix" and not args.raw
+
+
+def choose_method(provider: Provider, requested: str | None) -> LoginMethod:
+    name = requested or provider.default_login_method
+    if name not in provider.login_methods:
+        options = ", ".join(f"{m.name} ({m.description})" for m in provider.login_methods.values())
+        raise UsageError(
+            f"{provider.display_name} has no login method {name!r}.", hint=f"Choose: {options}"
+        )
+    return provider.login_methods[name]
+
+
+def ensure_running_and_tested(ctx: Context, provider: Provider) -> None:
+    """(Re)start the provider and wait for /health/ready: the server's startup
+    check makes one tiny real request, so ready means the login works."""
+    port = ctx.config.port(provider.name)
+    state = ctx.stack.states().get(service_name(provider))
+    if state is not None and state.state == "running" and health.ready(port):
+        ctx.console.success(f"{provider.display_name} is running at {health.base_url(port)}/v1")
+    else:
+        up_module.check_ports(ctx, [provider])
+        ctx.stack.compose(
+            "up", "-d", "--force-recreate", service_name(provider),
+            timeout=up_module.COMPOSE_UP_TIMEOUT,
+        )  # fmt: skip
+        up_module.start_and_wait(ctx, provider)
+    ctx.console.success(f"{provider.display_name} is logged in and tested.")
+    ctx.console.step("Configure your tools: modelmux config litellm (or openai-python, langchain)")
+
+
+def _link_handler(
+    provider: Provider, console: Console, no_browser: bool
+) -> Callable[[bytes], bytes | None]:
+    scanner = LinkScanner(provider.link_pattern)
+
+    def on_output(data: bytes) -> bytes | None:
+        link = scanner.feed(data)
+        if link is None:
+            return None
+        if no_browser:
+            return b"\r\n-> Open the link above in your browser.\r\n"
+        opened = False
+        try:
+            opened = open_browser(link)
+        except (webbrowser.Error, OSError):  # no usable browser here
+            opened = False
+        if opened:
+            return b"\r\n-> Opened your browser. If it did not open, use the link above.\r\n"
+        return b"\r\n-> Could not open a browser here: open the link above yourself.\r\n"
+
+    return on_output
+
+
+@contextlib.contextmanager
+def cancel_on_signals() -> Iterator[None]:
+    """Treat SIGTERM and SIGHUP (terminal closed) like Ctrl+C while logging in,
+    so the helper container is always removed and the user sees "Cancelled."."""
+    if sys.platform == "win32" or threading.current_thread() is not threading.main_thread():
+        yield
+        return
+
+    def interrupt(_signum: int, _frame: object) -> None:
+        raise KeyboardInterrupt
+
+    previous = {sig: signal.signal(sig, interrupt) for sig in (signal.SIGTERM, signal.SIGHUP)}
+    try:
+        yield
+    finally:
+        for sig, handler in previous.items():
+            signal.signal(sig, handler)
+
+
+def _interactive_login(
+    ctx: Context, provider: Provider, method: LoginMethod, image: str, args: argparse.Namespace
+) -> int:
+    name = f"modelmux-login-{provider.name}-{secrets.token_hex(4)}"
+    run_args = ctx.stack.helper_args(provider, image, method.command, ("-it", "--name", name))
+    try:
+        with cancel_on_signals():
+            if use_pty(args):
+                return ctx.docker.run_pty(
+                    *run_args,
+                    on_output=_link_handler(provider, ctx.console, args.no_browser),
+                    timeout=provider.login_timeout,
+                )
+            ctx.console.step(
+                "Follow the instructions below; open the link they show in your browser."
+            )
+            return ctx.docker.passthrough(*run_args, timeout=provider.login_timeout)
+    except (TimeoutError, DockerError) as exc:
+        _remove(ctx, name)
+        if isinstance(exc, DockerError) and "in time" not in exc.message:
+            raise
+        raise CliError(
+            "The login timed out.", hint=f"Start again: modelmux login {provider.name}"
+        ) from None
+    except KeyboardInterrupt:
+        _remove(ctx, name)
+        raise
+
+
+def _secret_login(ctx: Context, provider: Provider, method: LoginMethod, image: str) -> int:
+    prompt = method.secret_stdin or "Secret"
+    secret = read_secret(f"{prompt} (input is hidden): ").strip()
+    if not secret:
+        raise UsageError(f"No {prompt} entered.")
+    register_secret(secret)
+    run_args = ctx.stack.helper_args(provider, image, method.command, ("-i",))
+    return ctx.docker.run(
+        *run_args, input_text=secret + "\n", check=False, timeout=SECRET_LOGIN_TIMEOUT
+    ).returncode
+
+
+def _remove(ctx: Context, container: str) -> None:
+    ctx.docker.run("rm", "-f", container, check=False)
+
+
+def run(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    provider = get_provider(args.provider)
+    method = choose_method(provider, args.method)
+    image = resolve_image(ctx.config)
+    up_module.prepare(ctx, image)
+    stack = ctx.stack
+
+    if not args.force and stack.logged_in(provider, image):
+        console.success(
+            f"{provider.display_name} is already logged in (use --force to log in again)."
+        )
+        ensure_running_and_tested(ctx, provider)
+        return 0
+
+    console.step(f"Logging in to {provider.display_name}: {method.description}.")
+    if method.secret_stdin:
+        _secret_login(ctx, provider, method, image)
+    else:
+        _interactive_login(ctx, provider, method, image, args)
+    console.print()
+    if not stack.logged_in(provider, image):
+        raise CliError(
+            f"The {provider.display_name} login did not complete.",
+            hint=f"Try again: modelmux login {provider.name} (add --raw to see only the "
+            "provider's own output).",
+        )
+    console.success(f"Logged in to {provider.display_name}.")
+    ensure_running_and_tested(ctx, provider)
+    return 0

modelmux_cli/commands/logout.py

@@ -0,0 +1,53 @@
+"""``modelmux logout <provider>``: stop it and delete its saved login."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Callable
+
+from modelmux_cli.console import Console
+from modelmux_cli.context import make_context
+from modelmux_cli.errors import CliError, UsageError
+from modelmux_cli.providers import get_provider
+from modelmux_cli.stack import resolve_image, service_name, volume_name
+
+# Replaceable in tests.
+ask: Callable[[str], str] = input
+
+
+def confirm(question: str) -> bool:
+    if not sys.stdin.isatty():
+        raise UsageError(
+            "Logout needs confirmation.", hint="Add --yes to confirm when not in a terminal."
+        )
+    return ask(f"{question} [y/N] ").strip().lower() in {"y", "yes"}
+
+
+def run(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    provider = get_provider(args.provider)
+    stack = ctx.stack
+    if not stack.volume_exists(provider):
+        console.success(f"{provider.display_name} is not logged in; nothing to remove.")
+        return 0
+    if not args.yes and not confirm(f"Remove the saved {provider.display_name} login?"):
+        console.step("Nothing changed.")
+        return 0
+
+    if stack.compose_file.exists():
+        stack.compose("rm", "--stop", "--force", service_name(provider), check=False)
+    try:
+        image: str | None = resolve_image(ctx.config)
+    except CliError:
+        image = None
+    if image is not None:
+        # Best effort: lets the provider revoke the token, not just forget it.
+        result = ctx.docker.run(
+            *stack.helper_args(provider, image, provider.logout_command), check=False, timeout=60
+        )
+        if not result.ok:
+            console.detail("The provider's own logout did not succeed; removing the login anyway.")
+    ctx.docker.run("volume", "rm", volume_name(provider))
+    console.success(f"Logged out of {provider.display_name} and removed its saved login.")
+    return 0

modelmux_cli/commands/up.py

@@ -0,0 +1,157 @@
+"""``modelmux up``: prepare everything and start the logged-in providers."""
+
+from __future__ import annotations
+
+import argparse
+
+from modelmux_cli import health
+from modelmux_cli.config import save_config
+from modelmux_cli.console import Console
+from modelmux_cli.context import Context, make_context
+from modelmux_cli.errors import CliError, UsageError
+from modelmux_cli.paths import ensure_private_dir
+from modelmux_cli.ports import port_free
+from modelmux_cli.providers import Provider
+from modelmux_cli.secrets_store import ensure_api_key
+from modelmux_cli.stack import build_compose, resolve_image, service_name, write_compose
+
+READY_TIMEOUT = 240.0
+POLL_INTERVAL = 2.0
+COMPOSE_UP_TIMEOUT = 300.0
+
+
+def parse_port_overrides(values: list[str], known: set[str]) -> dict[str, int]:
+    ports: dict[str, int] = {}
+    for value in values:
+        name, sep, raw = value.partition("=")
+        if not sep or name not in known or not raw.isdigit() or not 1024 <= int(raw) <= 65535:
+            raise UsageError(
+                f"Invalid --port {value!r}.",
+                hint="Use --port <provider>=<1024-65535>, e.g. claude=9101.",
+            )
+        ports[name] = int(raw)
+    return ports
+
+
+def apply_settings(ctx: Context, args: argparse.Namespace) -> str:
+    """Validate and remember --image / --port; return the image to run."""
+    config = ctx.config
+    image = resolve_image(config, args.image)
+    ports = parse_port_overrides(args.port or [], set(ctx.providers))
+    changed = bool(ports) or (args.image is not None and args.image != config.image)
+    config.ports.update(ports)
+    if args.image is not None:
+        config.image = args.image
+    used = [config.port(name) for name in ctx.providers]
+    if len(used) != len(set(used)):
+        raise UsageError(
+            "Two providers are set to the same port.", hint="Choose different --port values."
+        )
+    if changed:
+        save_config(ctx.home, config)
+    return image
+
+
+def start_and_wait(ctx: Context, provider: Provider) -> None:
+    console, stack = ctx.console, ctx.stack
+    service = service_name(provider)
+    port = ctx.config.port(provider.name)
+
+    def stopped() -> bool:
+        state = stack.states().get(service)
+        return state is not None and state.state in {"exited", "dead"}
+
+    console.step(f"Starting {provider.display_name} (it checks its login, about 10-30 s)...")
+    if not health.wait_until(
+        lambda: health.ready(port), timeout=READY_TIMEOUT, interval=POLL_INTERVAL,
+        should_stop=stopped,
+    ):  # fmt: skip
+        if stopped():
+            raise CliError(
+                f"{provider.display_name} stopped while starting.",
+                hint=f"Its login may have expired: modelmux login {provider.name}. "
+                f"Details: modelmux logs {provider.name}",
+            )
+        raise CliError(
+            f"{provider.display_name} did not become ready in time.",
+            hint=f"See what it is doing: modelmux logs {provider.name}",
+        )
+    console.success(f"{provider.display_name} is running at {health.base_url(port)}/v1")
+
+
+def prepare(ctx: Context, image: str) -> None:
+    """Docker, API key, compose file, image and login volumes: all idempotent."""
+    console, stack = ctx.console, ctx.stack
+    console.step("Checking Docker...")
+    ctx.docker.check_available()
+    ensure_private_dir(ctx.home)
+    key = ensure_api_key(ctx.home)
+    if key.created:
+        console.success("Created an API key for your clients (see it with: modelmux key show).")
+    write_compose(ctx.home, build_compose(ctx.providers, ctx.config, image, key.path))
+    if not stack.image_present(image):
+        console.step(f"Downloading the ModelMux server image {image} (first time only, ~1.4 GB)...")
+        stack.ensure_image(image)
+    for provider in ctx.providers.values():
+        stack.ensure_volume(provider)
+
+
+def check_ports(ctx: Context, providers: list[Provider]) -> None:
+    states = ctx.stack.states()
+    for provider in providers:
+        running = states.get(service_name(provider))
+        port = ctx.config.port(provider.name)
+        if (running is None or running.state != "running") and not port_free(port):
+            raise CliError(
+                f"Port {port} for {provider.display_name} is already in use by another program.",
+                hint=f"Pick another port: modelmux up --port {provider.name}=<port>, "
+                "or run 'modelmux doctor'.",
+            )
+
+
+def run(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    providers = ctx.providers
+    unknown = [name for name in args.providers if name not in providers]
+    if unknown:
+        raise UsageError(
+            f"Unknown provider {unknown[0]!r}.",
+            hint=f"Choose from: {', '.join(sorted(providers))}.",
+        )
+    image = apply_settings(ctx, args)
+    prepare(ctx, image)
+
+    targets = [providers[name] for name in (args.providers or sorted(providers))]
+    console.step("Checking logins...")
+    logged_in = {p.name: ctx.stack.logged_in(p, image) for p in targets}
+    missing = [p for p in targets if not logged_in[p.name]]
+    if args.providers and missing:
+        raise CliError(
+            f"{missing[0].display_name} is not logged in yet.",
+            hint=f"Log in first: modelmux login {missing[0].name}",
+        )
+    to_start = [p for p in targets if logged_in[p.name]]
+    if not to_start:
+        console.success("ModelMux is set up. No provider is logged in yet.")
+        console.step(f"Next: modelmux login {targets[0].name}")
+        return 0
+
+    check_ports(ctx, to_start)
+    states = ctx.stack.states()
+    was_running = {
+        p.name for p in to_start
+        if (s := states.get(service_name(p))) is not None and s.state == "running"
+    }  # fmt: skip
+    ctx.stack.compose("up", "-d", *(service_name(p) for p in to_start), timeout=COMPOSE_UP_TIMEOUT)
+    for provider in to_start:
+        port = ctx.config.port(provider.name)
+        if provider.name in was_running and health.ready(port):
+            console.success(
+                f"{provider.display_name} is already running at {health.base_url(port)}/v1"
+            )
+        else:
+            start_and_wait(ctx, provider)
+    for provider in missing:
+        console.step(f"{provider.display_name} is not logged in: modelmux login {provider.name}")
+    console.step("Configure your tools: modelmux config litellm (or openai-python, langchain)")
+    return 0

modelmux_cli/commands/upgrade.py

@@ -0,0 +1,50 @@
+"""``modelmux upgrade``: run the server image that matches this CLI, keeping logins.
+
+The image version follows the CLI version: a newer server comes with a newer
+modelmux-cli. This command makes sure the image pinned for the installed CLI
+(or an explicit ``--image``) is present, recreates the providers that were
+running, and says when a newer CLI is available.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from modelmux_cli import __version__, updates
+from modelmux_cli.commands import up as up_module
+from modelmux_cli.config import save_config
+from modelmux_cli.console import Console
+from modelmux_cli.context import make_context
+from modelmux_cli.stack import resolve_image, service_name
+
+
+def run(args: argparse.Namespace, console: Console) -> int:
+    ctx = make_context(console)
+    image = resolve_image(ctx.config, args.image)
+    if args.image is not None and args.image != ctx.config.image:
+        ctx.config.image = args.image
+        save_config(ctx.home, ctx.config)
+
+    states = ctx.stack.states() if ctx.stack.compose_file.exists() else {}
+    up_module.prepare(ctx, image)  # downloads the image if needed, rewrites compose.yaml
+    console.success(f"Server image: {image}")
+
+    running = [
+        p for p in sorted(ctx.providers.values(), key=lambda p: p.name)
+        if (s := states.get(service_name(p))) is not None and s.state == "running"
+    ]  # fmt: skip
+    if running:
+        ctx.stack.compose(
+            "up", "-d", *(service_name(p) for p in running), timeout=up_module.COMPOSE_UP_TIMEOUT
+        )
+        for provider in running:
+            up_module.start_and_wait(ctx, provider)
+        console.success("Upgraded. Logins were kept.")
+    else:
+        console.success("Nothing was running; the next 'modelmux up' uses this image.")
+
+    latest = updates.latest_version()
+    if updates.newer_available(__version__, latest):
+        console.step(f"modelmux-cli {latest} is available (you have {__version__}). "
+                     f"It comes with a newer server: {updates.UPGRADE_HINT}")  # fmt: skip
+    return 0

modelmux_cli/config.py

@@ -0,0 +1,78 @@
+"""The CLI's settings (``config.json``): ports, and an optional image override.
+
+Everything has a default, so the file only exists once something is changed
+or ``modelmux up`` runs. A damaged file is reported, never silently replaced.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from modelmux_cli.errors import CliError
+from modelmux_cli.files import write_private
+from modelmux_cli.paths import ensure_private_dir
+from modelmux_cli.providers import load_providers
+
+CONFIG_FILE = "config.json"
+CONFIG_VERSION = 1
+
+
+@dataclass
+class Config:
+    ports: dict[str, int] = field(default_factory=dict)
+    image: str | None = None  # explicit override; None means "the image pinned for this CLI"
+
+    def port(self, provider: str) -> int:
+        if provider in self.ports:
+            return self.ports[provider]
+        return load_providers()[provider].default_port
+
+
+class ConfigFileError(CliError):
+    def __init__(self, path: Path, problem: str) -> None:
+        super().__init__(
+            f"Your ModelMux settings file is damaged ({problem}).",
+            hint=f"Fix or delete {path} and run the command again.",
+        )
+
+
+def _parse(path: Path, data: Any) -> Config:
+    if not isinstance(data, dict) or data.get("version") != CONFIG_VERSION:
+        raise ConfigFileError(path, "unknown format version")
+    ports = data.get("ports", {})
+    if not isinstance(ports, dict):
+        raise ConfigFileError(path, "'ports' must be an object")
+    known = load_providers()
+    for name, port in ports.items():
+        if name not in known:
+            raise ConfigFileError(path, f"unknown provider {name!r} in 'ports'")
+        if not isinstance(port, int) or isinstance(port, bool) or not 1 <= port <= 65535:
+            raise ConfigFileError(path, f"invalid port for {name!r}")
+    image = data.get("image")
+    if image is not None and not isinstance(image, str):
+        raise ConfigFileError(path, "'image' must be a string")
+    return Config(ports=dict(ports), image=image)
+
+
+def load_config(directory: Path) -> Config:
+    path = directory / CONFIG_FILE
+    if not path.exists():
+        return Config()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        raise ConfigFileError(path, "not valid JSON") from None
+    return _parse(path, data)
+
+
+def save_config(directory: Path, config: Config) -> Path:
+    ensure_private_dir(directory)
+    path = directory / CONFIG_FILE
+    data: dict[str, Any] = {"version": CONFIG_VERSION, "ports": dict(sorted(config.ports.items()))}
+    if config.image is not None:
+        data["image"] = config.image
+    write_private(path, json.dumps(data, indent=2) + "\n")
+    return path

modelmux_cli/console.py

@@ -0,0 +1,112 @@
+"""Terminal output: short, friendly lines with ✓ / ✗ markers.
+
+Colour is used only on a real terminal, never when ``NO_COLOR`` is set or
+``TERM=dumb``. Symbols fall back to ASCII when the terminal encoding cannot
+show them (older Windows consoles).
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import TextIO
+
+from modelmux_cli.redact import redact
+
+_RESET = "\033[0m"
+_STYLES = {"ok": "\033[32m", "error": "\033[31m", "warn": "\033[33m", "dim": "\033[2m",
+           "bold": "\033[1m"}  # fmt: skip
+_SYMBOLS = {"ok": ("✓", "OK"), "error": ("✗", "X"), "warn": ("!", "!"), "step": ("→", ">")}
+
+
+def _enable_windows_ansi() -> bool:
+    """Turn on ANSI escape handling in the Windows console (Windows 10+)."""
+    if sys.platform != "win32":
+        return True
+    try:
+        import ctypes  # noqa: PLC0415 - Windows only
+
+        kernel32 = ctypes.windll.kernel32
+        handle = kernel32.GetStdHandle(-11)  # STD_OUTPUT_HANDLE
+        mode = ctypes.c_uint32()
+        if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            return False
+        return bool(kernel32.SetConsoleMode(handle, mode.value | 0x0004))
+    except (AttributeError, OSError):
+        return False
+
+
+def _can_encode(stream: TextIO, text: str) -> bool:
+    try:
+        text.encode(stream.encoding or "ascii")
+    except (UnicodeEncodeError, LookupError):
+        return False
+    return True
+
+
+class Console:
+    def __init__(
+        self,
+        out: TextIO | None = None,
+        err: TextIO | None = None,
+        *,
+        verbose: bool = False,
+        color: bool | None = None,
+    ) -> None:
+        self.out = out or sys.stdout
+        self.err = err or sys.stderr
+        self.verbose = verbose
+        if color is None:
+            color = (
+                self.out.isatty()
+                and "NO_COLOR" not in os.environ
+                and os.environ.get("TERM") != "dumb"
+                and _enable_windows_ansi()
+            )
+        self.color = color
+        self.unicode = _can_encode(self.out, "✓✗→")
+
+    def _style(self, kind: str, text: str) -> str:
+        return f"{_STYLES[kind]}{text}{_RESET}" if self.color else text
+
+    def _symbol(self, kind: str) -> str:
+        fancy, plain = _SYMBOLS[kind]
+        return fancy if self.unicode else plain
+
+    def _line(self, stream: TextIO, text: str) -> None:
+        stream.write(redact(text) + "\n")
+        stream.flush()
+
+    # ------------------------------------------------------------ public API
+
+    def print(self, text: str = "") -> None:
+        """Plain output (command results, config snippets)."""
+        self._line(self.out, text)
+
+    def success(self, text: str) -> None:
+        self._line(self.out, f"{self._style('ok', self._symbol('ok'))} {text}")
+
+    def step(self, text: str) -> None:
+        self._line(self.out, f"{self._style('dim', self._symbol('step'))} {text}")
+
+    def warn(self, text: str) -> None:
+        self._line(self.err, f"{self._style('warn', self._symbol('warn'))} {text}")
+
+    def error(self, text: str, hint: str | None = None) -> None:
+        self._line(self.err, f"{self._style('error', self._symbol('error'))} {text}")
+        if hint:
+            self._line(self.err, f"  {self._style('dim', hint)}")
+
+    def note(self, text: str) -> None:
+        """A hint on stderr, so stdout stays clean for piping (``config > file``)."""
+        self._line(self.err, f"{self._style('dim', self._symbol('step'))} {text}")
+
+    def reveal(self, text: str) -> None:
+        """Print WITHOUT redaction. Only for an explicit user request to see a secret."""
+        self.out.write(text + "\n")
+        self.out.flush()
+
+    def detail(self, text: str) -> None:
+        """Only shown with --verbose."""
+        if self.verbose:
+            self._line(self.err, self._style("dim", f"  {text}"))

modelmux_cli/context.py

@@ -0,0 +1,41 @@
+"""Everything a command needs, built in one place (and replaceable in tests)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from functools import cached_property
+from pathlib import Path
+
+from modelmux_cli.config import Config, load_config
+from modelmux_cli.console import Console
+from modelmux_cli.docker import Docker
+from modelmux_cli.paths import config_dir
+from modelmux_cli.providers import Provider, load_providers
+from modelmux_cli.stack import Stack
+
+
+def make_docker(console: Console) -> Docker:
+    return Docker(console)
+
+
+@dataclass
+class Context:
+    console: Console
+    docker: Docker
+    home: Path = field(default_factory=config_dir)
+
+    @cached_property
+    def config(self) -> Config:
+        return load_config(self.home)
+
+    @cached_property
+    def providers(self) -> dict[str, Provider]:
+        return load_providers()
+
+    @cached_property
+    def stack(self) -> Stack:
+        return Stack(self.docker, self.home)
+
+
+def make_context(console: Console) -> Context:
+    return Context(console, make_docker(console))