modelmux-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{modelmux_cli-0.1.0 → modelmux_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: modelmux-cli
-Version: 0.1.0
+Version: 0.2.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

{modelmux_cli-0.1.0 → modelmux_cli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "modelmux-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "Set up, log in to and run ModelMux: AI coding CLIs as an OpenAI-compatible API"
 readme = "README.md"
 license = "Apache-2.0"

modelmux_cli-0.2.0/shared/release.json

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

{modelmux_cli-0.1.0 → modelmux_cli-0.2.0}/src/modelmux_cli/commands/up.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+from concurrent.futures import ThreadPoolExecutor
 
 from modelmux_cli import health
 from modelmux_cli.config import save_config
@@ -16,7 +17,7 @@ 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
+POLL_INTERVAL = 0.5
 COMPOSE_UP_TIMEOUT = 300.0
 
 
@@ -79,8 +80,11 @@ def start_and_wait(ctx: Context, provider: Provider) -> None:
     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."""
+def prepare(ctx: Context, image: str) -> bool:
+    """Docker, API key, compose file, image and login volumes: all idempotent.
+
+    Returns True if the compose file changed (so running containers must be
+    recreated to pick it up)."""
     console, stack = ctx.console, ctx.stack
     console.step("Checking Docker...")
     ctx.docker.check_available()
@@ -88,12 +92,45 @@ def prepare(ctx: Context, image: str) -> None:
     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))
+    changed = 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)
+    return changed or key.created
+
+
+def running_and_ready(ctx: Context, providers: list[Provider]) -> set[str]:
+    """Providers whose container runs and answers /health/ready. Their login
+    is proven (the server's startup check made a real request), so no helper
+    container is needed to check it again."""
+    states = ctx.stack.states()
+    return {
+        p.name for p in providers
+        if (s := states.get(service_name(p))) is not None and s.state == "running"
+        and health.ready(ctx.config.port(p.name))
+    }  # fmt: skip
+
+
+def check_logins(ctx: Context, providers: list[Provider], image: str) -> dict[str, bool]:
+    """Logged in or not, per provider: running ones count as logged in, the
+    rest are checked in parallel helper containers."""
+    ready = running_and_ready(ctx, providers)
+    unknown = [p for p in providers if p.name not in ready]
+    with ThreadPoolExecutor(max_workers=max(1, len(unknown))) as pool:
+        answers = list(pool.map(lambda p: ctx.stack.logged_in(p, image), unknown))
+    return {p.name: True for p in providers if p.name in ready} | {
+        p.name: answer for p, answer in zip(unknown, answers, strict=True)
+    }
+
+
+def wait_all(ctx: Context, providers: list[Provider]) -> None:
+    """Wait for every provider at once; report the first failure afterwards."""
+    with ThreadPoolExecutor(max_workers=max(1, len(providers))) as pool:
+        futures = [pool.submit(start_and_wait, ctx, p) for p in providers]
+    for future in futures:
+        future.result()  # re-raises the provider's CliError
 
 
 def check_ports(ctx: Context, providers: list[Provider]) -> None:
@@ -119,11 +156,10 @@ def run(args: argparse.Namespace, console: Console) -> int:
             hint=f"Choose from: {', '.join(sorted(providers))}.",
         )
     image = apply_settings(ctx, args)
-    prepare(ctx, image)
-
+    compose_changed = 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}
+    logged_in = check_logins(ctx, targets, image)
     missing = [p for p in targets if not logged_in[p.name]]
     if args.providers and missing:
         raise CliError(
@@ -135,22 +171,20 @@ def run(args: argparse.Namespace, console: Console) -> int:
         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)
+    ready = set() if compose_changed else running_and_ready(ctx, to_start)
+    waiting = [p for p in to_start if p.name not in ready]
+    if waiting:
+        check_ports(ctx, waiting)
+        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):
+        if provider.name in ready:
+            port = ctx.config.port(provider.name)
             console.success(
                 f"{provider.display_name} is already running at {health.base_url(port)}/v1"
             )
-        else:
-            start_and_wait(ctx, provider)
+    wait_all(ctx, waiting)
     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)")

{modelmux_cli-0.1.0 → modelmux_cli-0.2.0}/src/modelmux_cli/stack.py

@@ -83,11 +83,18 @@ def build_compose(
     }
 
 
-def write_compose(directory: Path, compose: dict[str, Any]) -> Path:
+def write_compose(directory: Path, compose: dict[str, Any]) -> bool:
+    """Write the compose file. Returns True if its content changed."""
     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
+    content = header + json.dumps(compose, indent=2) + "\n"
+    try:
+        if path.read_text(encoding="utf-8") == content:
+            return False
+    except OSError:
+        pass
+    write_private(path, content)
+    return True
 
 
 @dataclass(frozen=True)

{modelmux_cli-0.1.0 → modelmux_cli-0.2.0}/tests/test_commands.py

@@ -3,11 +3,14 @@ from __future__ import annotations
 import json
 import os
 import stat
+import threading
+import time
 from pathlib import Path
 
 import pytest
 
 from modelmux_cli import health, release
+from modelmux_cli import stack as stack_module
 from modelmux_cli.commands import up as up_module
 from modelmux_cli.main import main
 from tests.conftest import FakeDocker
@@ -97,6 +100,54 @@ def test_up_is_idempotent(capsys: pytest.CaptureFixture[str], fake_docker: FakeD
     assert "Created an API key" not in out
 
 
+def test_up_running_provider_skips_login_check_and_compose(
+    capsys: pytest.CaptureFixture[str], fake_docker: FakeDocker
+) -> None:
+    # Second `up` with nothing changed: no helper container, no compose up.
+    logged_in(fake_docker, "claude")
+    cli(capsys, "up", "claude")
+    fake_docker.calls.clear()
+    fake_docker.when("compose", "ps", returns=(0, RUNNING, ""))
+    code, out = cli(capsys, "up", "claude")
+    assert code == 0
+    assert "already running" in out
+    assert not [c for c in fake_docker.calls if c[:2] == ("run", "--rm")]
+    assert not fake_docker.called("compose", "up")
+
+
+def test_up_changed_settings_recreate_running_provider(
+    capsys: pytest.CaptureFixture[str], fake_docker: FakeDocker
+) -> None:
+    logged_in(fake_docker, "claude")
+    cli(capsys, "up", "claude")
+    fake_docker.when("compose", "ps", returns=(0, RUNNING, ""))
+    code, out = cli(capsys, "up", "claude", "--port", "claude=9101")
+    assert code == 0
+    assert fake_docker.called("compose", "up")
+    assert "running at http://127.0.0.1:9101/v1" in out
+
+
+def test_up_checks_logins_in_parallel(
+    capsys: pytest.CaptureFixture[str], fake_docker: FakeDocker, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    active, peak, lock = 0, 0, threading.Lock()
+
+    def slow_check(self: object, provider: object, image: str) -> bool:
+        nonlocal active, peak
+        with lock:
+            active += 1
+            peak = max(peak, active)
+        time.sleep(0.05)
+        with lock:
+            active -= 1
+        return False
+
+    monkeypatch.setattr(stack_module.Stack, "logged_in", slow_check)
+    code, _ = cli(capsys, "up")
+    assert code == 0
+    assert peak == 2  # claude and codex checked at the same time
+
+
 def test_up_explicit_provider_not_logged_in(
     capsys: pytest.CaptureFixture[str], fake_docker: FakeDocker
 ) -> None:

{modelmux_cli-0.1.0 → modelmux_cli-0.2.0}/tests/test_stack.py

@@ -87,11 +87,15 @@ def test_compose_is_hardened_and_isolated() -> None:
 
 
 def test_write_compose(tmp_path: Path) -> None:
-    path = write_compose(tmp_path, build_compose(PROVIDERS, Config(), "img:1", SECRETS))
-    text = path.read_text()
+    compose = build_compose(PROVIDERS, Config(), "img:1", SECRETS)
+    assert write_compose(tmp_path, compose) is True
+    text = (tmp_path / "compose.yaml").read_text()
     assert text.startswith("# Generated by modelmux")
     body = json.loads(text.split("\n", 1)[1])
     assert set(body["services"]) == {"modelmux-claude", "modelmux-codex"}
+    # Same content again: nothing to apply, so running containers can stay.
+    assert write_compose(tmp_path, compose) is False
+    assert write_compose(tmp_path, build_compose(PROVIDERS, Config(), "img:2", SECRETS)) is True
 
 
 def test_names() -> None:

{modelmux_cli-0.1.0 → modelmux_cli-0.2.0}/uv.lock

@@ -403,7 +403,7 @@ wheels = [
 
 [[package]]
 name = "modelmux-cli"
-version = "0.1.0"
+version = "0.2.0"
 source = { editable = "." }
 
 [package.dev-dependencies]

modelmux_cli-0.1.0/shared/release.json

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