mad-cli 0.4.0__py3-none-any.whl

mad_cli/commands/keys.py

@@ -0,0 +1,126 @@
+"""``mad keys set|list|remove`` — manage credentials / API keys in ``.env``.
+
+Thin adapter over :mod:`mad_cli.core.usecases.keys`. A key is a *builtin*
+(``github``, ``claude-oauth``, …), whose value fans out to one or more env vars,
+or a raw *custom* ``[A-Z][A-Z0-9_]*`` variable. ``claude-oauth`` also materialises
+the container credentials file. Values are always masked when shown.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.table import Table
+
+from mad_cli.commands._adapt import fail, resolve_or_die
+from mad_cli.core.instance import Instance
+from mad_cli.core.usecases import keys as uc
+from mad_cli.core.usecases.errors import UseCaseError, ValidationError
+from mad_cli.ui.console import console, error, info, ok, warn
+from mad_cli.ui.prompts import PromptRequiredError, ask
+
+keys_app = typer.Typer(
+    no_args_is_help=True,
+    add_completion=False,
+    help="Manage API keys and tokens stored in an instance's .env.",
+)
+
+_INSTANCE_OPTION = typer.Option(
+    None, "--instance", "-i", help="Instance name (optional when exactly one instance exists)."
+)
+
+
+def _restart_hint(instance: Instance) -> None:
+    info(f"Restart the instance to apply: mad restart {instance.name}")
+
+
+def _prompt_value(prompt: str, *, secret: bool) -> str:
+    try:
+        return ask(prompt, secret=secret)
+    except PromptRequiredError as exc:
+        error("A value is required. Pass it as an argument or run in an interactive terminal.")
+        raise typer.Exit(1) from exc
+
+
+@keys_app.command("set")
+def set_key(
+    key: str = typer.Argument(
+        ..., help="Builtin key id (e.g. github, claude-oauth) or a custom VAR name."
+    ),
+    value: str | None = typer.Argument(None, help="Value to store. Omit to be prompted."),
+    instance: str | None = _INSTANCE_OPTION,
+) -> None:
+    """Store a builtin key (fanned out to its env vars) or a custom variable."""
+    inst = resolve_or_die(instance)
+    if value is None:
+        try:
+            prompt, secret = uc.key_prompt(key)
+        except ValidationError as exc:
+            fail(exc)
+        value = _prompt_value(prompt, secret=secret)
+
+    try:
+        res = uc.set_key(inst, key, value)
+    except UseCaseError as exc:
+        fail(exc)
+
+    if res.credentials_path is not None:
+        ok(f"Claude credentials → {res.credentials_path}")
+    if res.builtin:
+        ok(f"Set {res.id} ({', '.join(res.env_vars)}) on {inst.name}.")
+    else:
+        ok(f"Set {res.id} on {inst.name}.")
+    _restart_hint(inst)
+
+
+@keys_app.command("list")
+def list_keys(instance: str | None = _INSTANCE_OPTION) -> None:
+    """Show which builtin keys are set (masked) plus any custom secret vars."""
+    inst = resolve_or_die(instance)
+    view = uc.list_keys(inst)
+
+    table = Table(title=f"Keys — {inst.name}")
+    table.add_column("Key", style="bold cyan", no_wrap=True)
+    table.add_column("Env vars")
+    table.add_column("Status")
+    table.add_column("Value")
+    for status in view.builtins:
+        table.add_row(
+            status.id,
+            ", ".join(status.env_vars),
+            "set" if status.is_set else "unset",
+            status.masked,
+        )
+    console.print(table)
+
+    if view.custom:
+        ctable = Table(title="Custom secrets")
+        ctable.add_column("Env var", style="bold", no_wrap=True)
+        ctable.add_column("Value")
+        for secret in view.custom:
+            ctable.add_row(secret.key, secret.masked)
+        console.print(ctable)
+
+
+@keys_app.command("remove")
+def remove_key(
+    key: str = typer.Argument(..., help="Builtin key id or custom VAR name to remove."),
+    instance: str | None = _INSTANCE_OPTION,
+) -> None:
+    """Remove a builtin key's env vars (or a custom variable) from ``.env``."""
+    inst = resolve_or_die(instance)
+    try:
+        res = uc.remove_key(inst, key)
+    except UseCaseError as exc:
+        fail(exc)
+
+    if not res.existed:
+        warn(f"{res.id} is not set on {inst.name}; nothing to remove.")
+        return
+
+    if res.builtin:
+        ok(f"Removed {res.id} ({', '.join(res.env_vars)}) from {inst.name}.")
+    else:
+        ok(f"Removed {res.id} from {inst.name}.")
+    if res.credentials_left is not None:
+        warn(f"Claude credentials file left in place on disk: {res.credentials_left}")
+    _restart_hint(inst)

mad_cli/commands/lifecycle.py

@@ -0,0 +1,69 @@
+"""``mad start|stop|restart|status|logs|shell [INSTANCE]`` — container lifecycle.
+
+Thin adapter over :mod:`mad_cli.core.usecases.lifecycle`. ``INSTANCE`` is optional:
+when omitted it resolves to the single configured instance; with zero the user is
+pointed at ``mad install``, with several the ambiguity is reported. ``logs`` and
+``shell`` attach the caller's TTY and stay here (no HTTP equivalent).
+"""
+
+from __future__ import annotations
+
+import typer
+
+from mad_cli.commands._adapt import resolve_or_die
+from mad_cli.core.compose import ComposeRunner
+from mad_cli.core.usecases import lifecycle as uc
+from mad_cli.ui.console import console, header, info, ok, run_step, warn
+
+_INSTANCE_ARG = typer.Argument(
+    None, help="Instance name (optional when exactly one instance exists)."
+)
+
+
+def start(instance: str | None = _INSTANCE_ARG) -> None:
+    """Build if needed, start the instance, and wait for it to become healthy."""
+    inst = resolve_or_die(instance)
+    header(f"Starting {inst.name}")
+    res = run_step("Building and starting…", lambda: uc.start(inst))
+    if res.healthy:
+        ok(f"{inst.name} is up — {res.url}" if res.url else f"{inst.name} is up.")
+    else:
+        warn(f"{inst.name} started but is not healthy yet. Check `mad status` and `mad logs`.")
+
+
+def stop(instance: str | None = _INSTANCE_ARG) -> None:
+    """Stop the instance and remove its containers."""
+    inst = resolve_or_die(instance)
+    run_step(f"Stopping {inst.name}…", lambda: uc.stop(inst))
+    ok(f"{inst.name} stopped.")
+
+
+def restart(instance: str | None = _INSTANCE_ARG) -> None:
+    """Restart the instance's containers."""
+    inst = resolve_or_die(instance)
+    run_step(f"Restarting {inst.name}…", lambda: uc.restart(inst))
+    ok(f"{inst.name} restarted.")
+
+
+def status(instance: str | None = _INSTANCE_ARG) -> None:
+    """Show container state, a health summary and the instance URL."""
+    inst = resolve_or_die(instance)
+    header(f"Status — {inst.name}")
+    res = uc.status(inst)
+    if res.ps_text.strip():
+        console.print(res.ps_text)
+    info(f"Health: {res.health}")
+    if res.url:
+        info(f"URL: {res.url}")
+
+
+def logs(instance: str | None = _INSTANCE_ARG) -> None:
+    """Follow the instance's container logs."""
+    inst = resolve_or_die(instance)
+    ComposeRunner(inst).logs(follow=True)
+
+
+def shell(instance: str | None = _INSTANCE_ARG) -> None:
+    """Open an interactive shell inside the running container."""
+    inst = resolve_or_die(instance)
+    ComposeRunner(inst).shell()

mad_cli/commands/profiles.py

@@ -0,0 +1,238 @@
+"""``mad profiles create|list|show|delete|apply`` — named environment profiles.
+
+A *profile* is a reusable, named set of ``.env`` values (credentials + tuning,
+never instance identity) stored under ``config_root()/profiles/<name>.env``. Use
+it to stamp consistent config across instances: ``mad profiles apply`` overlays a
+profile onto an existing instance's ``.env``, and ``mad install --profile`` feeds
+a profile's values as the wizard's defaults.
+
+The engine lives in :mod:`mad_cli.core.profiles`; this module is the Typer
+surface, so it never touches the filesystem directly.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+
+import typer
+from rich.table import Table
+
+from mad_cli.commands._common import is_secret_key
+from mad_cli.core.envfile import EnvFile
+from mad_cli.core.instance import InstanceNotFoundError, get_instance
+from mad_cli.core.keyspec import mask
+from mad_cli.core.profiles import (
+    IDENTITY_KEYS,
+    ProfileNotFoundError,
+    delete_profile,
+    list_profiles,
+    load_profile,
+    save_profile,
+)
+from mad_cli.ui.console import console, error, info, ok, warn
+from mad_cli.ui.prompts import confirm
+
+profiles_app = typer.Typer(
+    no_args_is_help=True,
+    add_completion=False,
+    help="Manage reusable named environment profiles (credentials + tuning).",
+)
+
+# A profile variable name: a shell env-var name (leading underscore allowed so
+# keys like _CLAUDE_OAUTH_TOKEN round-trip).
+_ENV_KEY_RE = re.compile(r"[A-Z_][A-Z0-9_]*")
+
+# Module-level singleton for the repeatable --set option (a mutable-typed default
+# may not be an inline call — flake8-bugbear B008).
+_SET_OPTION = typer.Option(
+    None,
+    "--set",
+    metavar="KEY=VALUE",
+    help="Set a KEY=VALUE pair in the profile (repeatable).",
+)
+
+
+def _interactive() -> bool:
+    """True only when stdin is a TTY, so a prompt will not block."""
+    try:
+        return sys.stdin.isatty()
+    except (ValueError, OSError):
+        return False
+
+
+def _split_set(item: str) -> tuple[str, str]:
+    """Split a ``KEY=VALUE`` --set entry, validating the key, or exit."""
+    key, sep, value = item.partition("=")
+    key = key.strip()
+    if not sep or not key:
+        error(f"invalid --set {item!r}: expected KEY=VALUE.")
+        raise typer.Exit(1)
+    if not _ENV_KEY_RE.fullmatch(key):
+        error(f"invalid key {key!r}: must match [A-Z_][A-Z0-9_]* (an env-var name).")
+        raise typer.Exit(1)
+    return key, value
+
+
+def _resolve_profile(name: str) -> EnvFile:
+    """Load profile ``name`` to an :class:`EnvFile`, or exit with a hint."""
+    try:
+        return load_profile(name)
+    except ProfileNotFoundError as exc:
+        error(f"Profile {name!r} not found. Run `mad profiles list` to see available profiles.")
+        raise typer.Exit(1) from exc
+
+
+def _display(key: str, value: str, *, reveal: bool) -> str:
+    """Mask a secret-looking value unless ``reveal`` is set."""
+    if reveal or not value or not is_secret_key(key):
+        return value
+    return mask(value)
+
+
+def _print_env(title: str, env: EnvFile, *, reveal: bool) -> None:
+    """Print a profile's variables as a table (secret-looking values masked)."""
+    table = Table(title=title)
+    table.add_column("Key", style="bold cyan", no_wrap=True)
+    table.add_column("Value")
+    for key in env.keys():  # noqa: SIM118 — EnvFile.keys() is its contract API, not a dict
+        table.add_row(key, _display(key, env.get(key) or "", reveal=reveal))
+    console.print(table)
+
+
+def _prompt_pairs(env: EnvFile) -> None:
+    """Interactive mini-loop to add KEY=VALUE pairs to a new profile."""
+    if not confirm("Add environment variables now?", default=False):
+        return
+    while True:
+        key = console.input("[cyan]?[/cyan] Variable name (empty to finish): ").strip()
+        if not key:
+            break
+        if not _ENV_KEY_RE.fullmatch(key):
+            warn(f"invalid key {key!r}: must match [A-Z_][A-Z0-9_]*.")
+            continue
+        # Hide the value only when the key looks like a secret.
+        value = console.input(f"[cyan]?[/cyan] Value for {key}: ", password=is_secret_key(key))
+        env.set(key, value)
+        if not confirm("Add another?", default=False):
+            break
+
+
+@profiles_app.command("create")
+def create(
+    name: str = typer.Argument(..., help="Profile name ([a-z0-9][a-z0-9-]*)."),
+    from_instance: str | None = typer.Option(
+        None,
+        "--from-instance",
+        help="Seed the profile from an instance's .env (identity keys excluded).",
+    ),
+    set_: list[str] | None = _SET_OPTION,
+) -> None:
+    """Create a profile, empty or seeded from an instance, plus optional KEY=VALUEs."""
+    if name in list_profiles():
+        error(f"Profile {name!r} already exists. Delete it first or pick another name.")
+        raise typer.Exit(1)
+
+    env = EnvFile.empty()
+
+    if from_instance is not None:
+        try:
+            source = get_instance(from_instance)
+        except InstanceNotFoundError as exc:
+            error(f"Instance {from_instance!r} not found. Run `mad list` to see instances.")
+            raise typer.Exit(1) from exc
+        for key in source.env.keys():  # noqa: SIM118 — EnvFile.keys() is its contract API
+            if key in IDENTITY_KEYS:
+                continue
+            value = source.env.get(key)
+            if value is not None:
+                env.set(key, value)
+
+    for item in set_ or []:
+        key, value = _split_set(item)
+        env.set(key, value)
+
+    if _interactive():
+        _prompt_pairs(env)
+
+    try:
+        path = save_profile(name, env)
+    except ValueError as exc:  # invalid name
+        error(str(exc))
+        raise typer.Exit(1) from exc
+
+    ok(f"Created profile {name!r} ({len(env.keys())} variable(s)) → {path}")
+    if env.keys():
+        _print_env(f"Profile — {name}", env, reveal=False)
+    info(f"Apply it to an instance with: mad profiles apply {name} <instance>")
+
+
+@profiles_app.command("list")
+def list_(  # noqa: A001 — command name; the Typer name is "list"
+) -> None:
+    """List every stored profile with its variable count."""
+    names = list_profiles()
+    if not names:
+        info("No profiles yet. Create one with `mad profiles create NAME`.")
+        return
+    table = Table(title="Profiles")
+    table.add_column("Profile", style="bold cyan", no_wrap=True)
+    table.add_column("Variables", justify="right")
+    for name in names:
+        env = load_profile(name)
+        table.add_row(name, str(len(env.keys())))
+    console.print(table)
+
+
+@profiles_app.command("show")
+def show(
+    name: str = typer.Argument(..., help="Profile to display."),
+    reveal: bool = typer.Option(False, "--reveal", help="Show secret values in full."),
+) -> None:
+    """Print a profile's variables (secret-looking values masked)."""
+    env = _resolve_profile(name)
+    if not env.keys():
+        info(f"Profile {name!r} is empty.")
+        return
+    _print_env(f"Profile — {name}", env, reveal=reveal)
+
+
+@profiles_app.command("delete")
+def delete(
+    name: str = typer.Argument(..., help="Profile to delete."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Delete a profile (asks for confirmation unless --yes)."""
+    if name not in list_profiles():
+        error(f"Profile {name!r} not found. Run `mad profiles list` to see available profiles.")
+        raise typer.Exit(1)
+    if not yes and not confirm(f"Delete profile {name!r}?", default=False):
+        info("Aborted; nothing was deleted.")
+        return
+    delete_profile(name)
+    ok(f"Deleted profile {name!r}.")
+
+
+@profiles_app.command("apply")
+def apply(
+    name: str = typer.Argument(..., help="Profile to apply."),
+    instance: str = typer.Argument(..., help="Instance to overlay the profile onto."),
+) -> None:
+    """Overlay a profile's variables onto an instance's ``.env``."""
+    profile = _resolve_profile(name)
+    try:
+        inst = get_instance(instance)
+    except InstanceNotFoundError as exc:
+        error(f"Instance {instance!r} not found. Run `mad list` to see available instances.")
+        raise typer.Exit(1) from exc
+
+    applied = 0
+    for key in profile.keys():  # noqa: SIM118 — EnvFile.keys() is its contract API
+        value = profile.get(key)
+        if value is not None:
+            inst.env.set(key, value)
+            applied += 1
+    inst.env.save()
+
+    ok(f"Applied {applied} variable(s) from profile {name!r} to instance {inst.name!r}.")
+    info(f"Restart the instance to apply: mad restart {inst.name}")

mad_cli/commands/service.py

@@ -0,0 +1,220 @@
+"""``mad serve`` and ``mad service install|uninstall|status|update`` — service mode.
+
+``serve`` runs the HTTP API in the foreground (uvicorn). ``service`` manages a
+boot-persistent background service: a systemd **user** unit on Linux, a launchd
+LaunchAgent on macOS. When the ``server`` extra is not importable, ``service
+install`` auto-provisions a dedicated venv under ``config_root()/server-venv`` and
+points the unit at it — the base CLI never needs FastAPI installed.
+
+Thin adapter over :mod:`mad_cli.core.usecases.service`. Activating the unit
+(``systemctl`` / ``launchctl``) happens only for a real install; ``--render-to``
+writes the file and touches nothing on the live system (used by tests and the E2E).
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import subprocess
+from pathlib import Path
+
+import typer
+
+from mad_cli import __version__
+from mad_cli.commands._adapt import fail
+from mad_cli.core.paths import config_root
+from mad_cli.core.usecases import service as uc
+from mad_cli.core.usecases.errors import UseCaseError
+from mad_cli.ui.console import error, header, info, ok, warn
+
+service_app = typer.Typer(
+    no_args_is_help=True,
+    add_completion=False,
+    help="Install/manage the mad HTTP API as a boot-persistent background service.",
+)
+
+_HOST_OPTION = typer.Option(uc.DEFAULT_HOST, "--host", help="Bind address (default: 127.0.0.1).")
+_PORT_OPTION = typer.Option(uc.DEFAULT_PORT, "--port", help="Bind port (default: 7373).")
+_WHEEL_OPTION = typer.Option(
+    None,
+    "--wheel",
+    "--from",
+    help="Provision the server venv from this local wheel/sdist instead of PyPI.",
+)
+_RENDER_TO_OPTION = typer.Option(
+    None,
+    "--render-to",
+    help="Write the unit/plist to PATH and stop — do not touch systemctl/launchctl.",
+)
+
+
+def _warn_public_bind(host: str) -> None:
+    if uc.is_loopback(host):
+        return
+    bar = "!" * 68
+    warn(bar)
+    warn(f"Binding to {host} exposes the mad API BEYOND localhost.")
+    warn("Anyone who can reach this address and holds the bearer token can control")
+    warn("your instances (start/stop, config, keys). Put it behind a firewall/VPN.")
+    warn(bar)
+
+
+def _platform() -> str:
+    return platform.system().lower()
+
+
+# ── mad serve ─────────────────────────────────────────────────────────────────
+def serve(host: str = _HOST_OPTION, port: int = _PORT_OPTION) -> None:
+    """Run the HTTP API in the foreground (Ctrl-C to stop)."""
+    uc.ensure_api_token()  # create the token file on first run
+    _warn_public_bind(host)
+
+    if uc.server_deps_available():
+        import uvicorn  # noqa: PLC0415 — optional dependency, imported on demand
+
+        from mad_cli.server import create_app  # lazy: only when the extra is present
+
+        app = create_app()
+        header("mad API")
+        info(f"Listening on http://{host}:{port}")
+        info(f"Bearer token: {uc.api_token_path()} (send as `Authorization: Bearer <token>`)")
+        uvicorn.run(app, host=host, port=port, log_level="info")
+        return
+
+    if uc.server_venv_exists():
+        argv = uc.serve_argv([str(uc.server_venv_mad())], host, port)
+        info("The server extra is not in this environment — handing off to the dedicated venv.")
+        os.execv(argv[0], argv)  # replace this process; never returns
+        return
+
+    error(
+        "The HTTP API needs the 'server' extra. Install it with "
+        "`pip install 'mad-cli[server]'`, or run `mad service install` "
+        "(it auto-provisions a dedicated environment for you)."
+    )
+    raise typer.Exit(1)
+
+
+# ── mad service install / uninstall / status / update ─────────────────────────
+def _activate(platform_name: str, unit_path: Path) -> None:
+    """Enable + start the freshly installed service (real installs only)."""
+    if platform_name == "linux":
+        try:
+            subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)
+            subprocess.run(
+                ["systemctl", "--user", "enable", "--now", uc.SYSTEMD_UNIT_NAME], check=True
+            )
+        except (OSError, subprocess.SubprocessError) as exc:
+            warn(f"Could not activate the systemd unit automatically: {exc}")
+            return
+        ok("Enabled and started (systemctl --user enable --now).")
+        info(
+            "To survive logout/reboot without an active session, run: loginctl enable-linger $USER"
+        )
+    elif platform_name == "darwin":
+        try:
+            subprocess.run(["launchctl", "load", str(unit_path)], check=True)
+        except (OSError, subprocess.SubprocessError) as exc:
+            warn(f"Could not load the LaunchAgent automatically: {exc}")
+            return
+        ok("Loaded (launchctl load).")
+
+
+@service_app.command("install")
+def install(
+    host: str = _HOST_OPTION,
+    port: int = _PORT_OPTION,
+    wheel: Path | None = _WHEEL_OPTION,
+    render_to: Path | None = _RENDER_TO_OPTION,
+) -> None:
+    """Render the service file (and provision the server venv if needed)."""
+    uc.ensure_api_token()
+    system = _platform()
+
+    header("Provisioning the server runtime")
+    try:
+        launcher, bootstrapped = uc.ensure_server_runtime(wheel=wheel)
+    except UseCaseError as exc:
+        fail(exc)
+    if bootstrapped:
+        ok(f"Server venv ready → {uc.server_venv_dir()}")
+    else:
+        info("Using the current environment's `mad` (the server extra is already installed).")
+
+    exec_args = uc.serve_argv(launcher, host, port)
+    try:
+        rendered = uc.render_service(platform=system, exec_args=exec_args, config_dir=config_root())
+    except UseCaseError as exc:
+        fail(exc)
+
+    target = render_to if render_to is not None else rendered.default_path
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(rendered.content, encoding="utf-8")
+    ok(f"Service file → {target}")
+
+    if render_to is not None:
+        info("Rendered only (--render-to) — systemctl/launchctl were not touched.")
+        return
+    _activate(rendered.platform, rendered.default_path)
+
+
+@service_app.command("uninstall")
+def uninstall() -> None:
+    """Stop and remove the installed service file."""
+    system = _platform()
+    try:
+        rendered_path = uc.systemd_unit_path() if system == "linux" else uc.launchd_plist_path()
+    except Exception:  # noqa: BLE001 - defensive; unsupported platform
+        info("No supported service manager on this platform.")
+        return
+    if not rendered_path.exists():
+        info("No service file installed; nothing to remove.")
+        return
+    if system == "linux":
+        try:
+            subprocess.run(
+                ["systemctl", "--user", "disable", "--now", uc.SYSTEMD_UNIT_NAME], check=False
+            )
+        except (OSError, subprocess.SubprocessError) as exc:
+            warn(f"Could not stop the unit: {exc}")
+    elif system == "darwin":
+        try:
+            subprocess.run(["launchctl", "unload", str(rendered_path)], check=False)
+        except (OSError, subprocess.SubprocessError) as exc:
+            warn(f"Could not unload the LaunchAgent: {exc}")
+    rendered_path.unlink()
+    ok(f"Removed {rendered_path}. The server venv (if any) was left in place.")
+
+
+@service_app.command("status")
+def status() -> None:
+    """Report the service file, the server venv and version alignment."""
+    system = _platform()
+    path = uc.systemd_unit_path() if system == "linux" else uc.launchd_plist_path()
+    header("mad service status")
+    info(f"Platform: {system}")
+    info(f"Service file: {path} ({'present' if path.exists() else 'absent'})")
+
+    if uc.server_venv_exists():
+        venv_version = uc.server_venv_version()
+        ok(f"Server venv: {uc.server_venv_dir()} (mad-cli {venv_version or 'unknown'})")
+        if venv_version is not None and venv_version != __version__:
+            warn(
+                f"Server venv runs mad-cli {venv_version} but this CLI is {__version__}. "
+                "Run `mad service update` to realign."
+            )
+    elif uc.server_deps_available():
+        info("Server venv: not provisioned (the current environment has the server extra).")
+    else:
+        info("Server venv: not provisioned. `mad service install` will create one.")
+
+
+@service_app.command("update")
+def update(wheel: Path | None = _WHEEL_OPTION) -> None:
+    """Reinstall ``mad-cli[server]`` into the server venv at the CLI's version."""
+    header("Updating the server venv")
+    try:
+        uc.bootstrap_server_venv(wheel=wheel)
+    except UseCaseError as exc:
+        fail(exc)
+    ok(f"Server venv realigned to mad-cli {__version__} → {uc.server_venv_dir()}")