mirrorneuron-cli 1.2.7__tar.gz → 1.2.8__tar.gz

{mirrorneuron_cli-1.2.7/mirrorneuron_cli.egg-info → mirrorneuron_cli-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirrorneuron-cli
-Version: 1.2.7
+Version: 1.2.8
 Summary: MirrorNeuron CLI
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3

{mirrorneuron_cli-1.2.7 → mirrorneuron_cli-1.2.8/mirrorneuron_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirrorneuron-cli
-Version: 1.2.7
+Version: 1.2.8
 Summary: MirrorNeuron CLI
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3

{mirrorneuron_cli-1.2.7 → mirrorneuron_cli-1.2.8}/mn_cli/libs/model_cmds.py

@@ -250,7 +250,7 @@ def install_model_entry(
     target = docker_model_name(entry)
     if _docker_model_cli_available():
         _ensure_runner(compatibility.backend, compatibility.accelerator)
-        _docker(["model", "pull", target], timeout=900, stream=True)
+        _docker_model_pull(target)
         run_command = ["model", "run", "--detach"]
         resolved_context = context_size or entry.get("context_size")
         if resolved_context and _docker_model_run_supports_context_size():
@@ -269,6 +269,22 @@ def install_model_entry(
     }
 
 
+def _docker_model_pull(target: str, *, attempts: int = 2) -> None:
+    last_error: RuntimeError | None = None
+    for attempt in range(1, attempts + 1):
+        try:
+            _docker(["model", "pull", target], timeout=900, stream=True)
+            return
+        except RuntimeError as exc:
+            if _model_installed(target):
+                return
+            last_error = exc
+            if attempt < attempts:
+                console.print("[yellow]Docker model pull failed; retrying once...[/yellow]")
+    if last_error is not None:
+        raise last_error
+
+
 def remove_model_ref(model: str, *, force: bool = False) -> None:
     if _docker_model_cli_available():
         command = ["model", "rm"]

{mirrorneuron_cli-1.2.7 → mirrorneuron_cli-1.2.8}/mn_cli/server_cmds.py

@@ -112,6 +112,10 @@ RUNTIME_MODELS_OVERRIDE_FILE = "docker-compose.models.yml"
 DEFAULT_LLM_MODEL_RUNNER_MODEL = "ai/gemma4:E2B"
 DEFAULT_CONTEXT_MODEL_RUNNER_MODEL = "hf.co/homerquan/mn-context-engine-model-v-Q4_K_M"
 DEFAULT_MEMBRANE_REPO = "MirrorNeuronLab/Membrane"
+DEFAULT_MEMBRANE_ENGINE_IMAGE_REPOSITORY = (
+    "us-central1-docker.pkg.dev/mirrorneuron-public-packages/"
+    "mirrorneuron-runtime/membrane-context-engine"
+)
 CONTEXT_ENGINE_SERVICE = "membrane-context-engine"
 CONTEXT_ENGINE_CONTAINER = "mirror-neuron-context-engine"
 CONTEXT_ENGINE_MODEL_CONTAINER = "mirror-neuron-context-engine-model"
@@ -2000,14 +2004,23 @@ def ensure_context_engine_runtime(*, force: bool = False) -> dict[str, str]:
         )
 
     env = _runtime_base_env(True)
-    source_dir = _ensure_context_engine_source(env)
     profiles = _compose_profiles_with(env.get("COMPOSE_PROFILES"), "context")
     model = str(env.get("MN_CONTEXT_MODEL_RUNNER_MODEL") or DEFAULT_CONTEXT_MODEL_RUNNER_MODEL)
+    engine_image = _context_engine_release_image(env)
+    use_engine_image = _context_engine_image_mode_enabled(env, engine_image)
     updates = {
         "COMPOSE_PROFILES": profiles,
-        "MEMBRANE_DIR": str(source_dir),
         "MN_CONTEXT_MODEL_RUNNER_MODEL": model,
     }
+    source_dir: Path | None = None
+    if use_engine_image:
+        updates["ENGINE_IMAGE"] = engine_image
+        updates["MN_MEMBRANE_ENGINE_IMAGE"] = engine_image
+        _remove_env_file_keys(RUNTIME_COMPOSE_ENV, {"MEMBRANE_DIR"})
+        env.pop("MEMBRANE_DIR", None)
+    else:
+        source_dir = _ensure_context_engine_source(env)
+        updates["MEMBRANE_DIR"] = str(source_dir)
     _write_env_file_values(RUNTIME_COMPOSE_ENV, updates)
     env.update(updates)
 
@@ -2017,14 +2030,24 @@ def ensure_context_engine_runtime(*, force: bool = False) -> dict[str, str]:
 
     already_running = _docker_container_running(CONTEXT_ENGINE_CONTAINER)
     if force or not already_running:
+        if use_engine_image:
+            subprocess.run(
+                runtime_compose_cmd("pull", CONTEXT_ENGINE_SERVICE),
+                check=True,
+                stdout=subprocess.DEVNULL,
+                env=env,
+            )
+            up_args = ("up", "-d", "--no-build", CONTEXT_ENGINE_SERVICE)
+        else:
+            subprocess.run(
+                runtime_compose_cmd("build", CONTEXT_ENGINE_SERVICE),
+                check=True,
+                stdout=subprocess.DEVNULL,
+                env=env,
+            )
+            up_args = ("up", "-d", CONTEXT_ENGINE_SERVICE)
         subprocess.run(
-            runtime_compose_cmd("build", CONTEXT_ENGINE_SERVICE),
-            check=True,
-            stdout=subprocess.DEVNULL,
-            env=env,
-        )
-        subprocess.run(
-            runtime_compose_cmd("up", "-d", CONTEXT_ENGINE_SERVICE),
+            runtime_compose_cmd(*up_args),
             check=True,
             stdout=subprocess.DEVNULL,
             env=env,
@@ -2038,8 +2061,8 @@ def ensure_context_engine_runtime(*, force: bool = False) -> dict[str, str]:
         "service": CONTEXT_ENGINE_SERVICE,
         "container": CONTEXT_ENGINE_CONTAINER,
         "model": model,
-        "membrane_dir": str(source_dir),
         "compose_profiles": profiles,
+        **({"engine_image": engine_image} if use_engine_image else {"membrane_dir": str(source_dir)}),
     }
 
 def _compose_profiles_with(value: object, required_profile: str) -> str:
@@ -2058,6 +2081,50 @@ def _compose_profiles_with(value: object, required_profile: str) -> str:
         profiles.append(required_profile)
     return ",".join(profiles)
 
+def _normalized_release_image_tag(value: object) -> str:
+    tag = str(value or "").strip()
+    if not tag:
+        return ""
+    return tag if tag.startswith("v") else f"v{tag}"
+
+def _context_engine_release_image(env: dict[str, str]) -> str:
+    explicit = str(
+        os.getenv("MN_MEMBRANE_ENGINE_IMAGE")
+        or env.get("MN_MEMBRANE_ENGINE_IMAGE")
+        or os.getenv("MN_CONTEXT_ENGINE_IMAGE")
+        or env.get("MN_CONTEXT_ENGINE_IMAGE")
+        or os.getenv("ENGINE_IMAGE")
+        or env.get("ENGINE_IMAGE")
+        or ""
+    ).strip()
+    if explicit:
+        return explicit
+
+    tag = _normalized_release_image_tag(
+        os.getenv("MN_MEMBRANE_ENGINE_IMAGE_TAG")
+        or env.get("MN_MEMBRANE_ENGINE_IMAGE_TAG")
+        or os.getenv("MN_RUNTIME_MODULE_VERSION")
+        or env.get("MN_RUNTIME_MODULE_VERSION")
+        or os.getenv("MN_PACKAGE_VERSION")
+        or env.get("MN_PACKAGE_VERSION")
+    )
+    if not tag:
+        return ""
+    repository = str(
+        os.getenv("MN_MEMBRANE_ENGINE_IMAGE_REPOSITORY")
+        or env.get("MN_MEMBRANE_ENGINE_IMAGE_REPOSITORY")
+        or DEFAULT_MEMBRANE_ENGINE_IMAGE_REPOSITORY
+    ).strip().rstrip("/")
+    return f"{repository}:{tag}" if repository else ""
+
+def _context_engine_image_mode_enabled(env: dict[str, str], image: str) -> bool:
+    mode = str(os.getenv("MN_MEMBRANE_SOURCE_MODE") or env.get("MN_MEMBRANE_SOURCE_MODE") or "").strip().lower()
+    if mode in {"source", "git", "checkout", "local"}:
+        return False
+    if mode in {"image", "docker", "gar", "release"}:
+        return bool(image)
+    return bool(image and image != "mirror-neuron-memory-engine:latest")
+
 def _context_engine_git_url(env: dict[str, str]) -> str:
     explicit = str(os.getenv("MN_MEMBRANE_GIT_URL") or env.get("MN_MEMBRANE_GIT_URL") or "").strip()
     if explicit:

{mirrorneuron_cli-1.2.7 → mirrorneuron_cli-1.2.8}/tests/test_model_cmds.py

@@ -128,6 +128,38 @@ def test_model_install_streams_pull_progress(mocker):
     assert pull_kwargs["capture_output"] is False
 
 
+def test_model_install_retries_transient_pull_failure(mocker):
+    calls = []
+    pull_attempts = 0
+
+    def fake_run(command, **kwargs):
+        nonlocal pull_attempts
+        calls.append(command)
+        if command[:4] == ["docker", "model", "status", "--json"]:
+            return _completed(command, stdout=json.dumps({"running": True, "backends": {"llama.cpp": "Running"}}))
+        if command[:4] == ["docker", "model", "run", "--help"]:
+            return _completed(command, stdout="Options:\n")
+        if command == ["docker", "model", "pull", "ai/gemma4:E2B"]:
+            pull_attempts += 1
+            if pull_attempts == 1:
+                return _completed(command, returncode=1, stderr="writing blob: blob digest mismatch")
+        if command == ["docker", "model", "inspect", "ai/gemma4:E2B"]:
+            return _completed(command, returncode=1)
+        return _completed(command)
+
+    mocker.patch("subprocess.run", side_effect=fake_run)
+    mocker.patch(
+        "mn_sdk.model_runtime.detect_host_hardware",
+        return_value=HostHardwareProfile("darwin", "arm64", total_memory_gb=16, unified_memory_gb=16, has_apple_silicon=True),
+    )
+
+    result = runner.invoke(app, ["model", "install", "gemma4:e2b"])
+
+    assert result.exit_code == 0
+    assert calls.count(["docker", "model", "pull", "ai/gemma4:E2B"]) == 2
+    assert ["docker", "model", "run", "--detach", "ai/gemma4:E2B"] in calls
+
+
 def test_model_install_persists_manual_ownership_record(mocker):
     def fake_run(command, **kwargs):
         if command[:4] == ["docker", "model", "status", "--json"]:
@@ -293,6 +325,8 @@ def test_model_install_failure_does_not_record_manual_ownership(mocker, tmp_path
             return _completed(command, stdout=json.dumps({"running": True, "backends": {"llama.cpp": "Running"}}))
         if command[:3] == ["docker", "model", "pull"]:
             return _completed(command, returncode=1, stderr="pull failed")
+        if command[:3] == ["docker", "model", "inspect"]:
+            return _completed(command, returncode=1)
         return _completed(command)
 
     mocker.patch("subprocess.run", side_effect=fake_run)

{mirrorneuron_cli-1.2.7 → mirrorneuron_cli-1.2.8}/tests/test_server_cmds.py

@@ -588,6 +588,39 @@ def test_ensure_context_engine_runtime_persists_profile_and_starts_compose(mocke
     assert run.call_args_list[0].args[0] == runtime_compose_cmd("build", "membrane-context-engine")
     assert run.call_args_list[1].args[0] == runtime_compose_cmd("up", "-d", "membrane-context-engine")
 
+def test_ensure_context_engine_runtime_uses_release_image_without_source_clone(mocker):
+    server_cmds.RUNTIME_COMPOSE_ENV.parent.mkdir(parents=True, exist_ok=True)
+    server_cmds.RUNTIME_COMPOSE_ENV.write_text(
+        "COMPOSE_PROJECT_NAME=mirror-neuron\n"
+        "COMPOSE_PROFILES=openshell\n"
+        "MN_RUNTIME_MODULE_VERSION=1.2.7\n"
+        "MEMBRANE_DIR=/private/membrane\n",
+        encoding="utf-8",
+    )
+    server_cmds.RUNTIME_COMPOSE_FILE.write_text("services: {}\n", encoding="utf-8")
+    ensure_source = mocker.patch("mn_cli.server_cmds._ensure_context_engine_source")
+    mocker.patch("mn_cli.server_cmds._ensure_docker_model_runner")
+    mocker.patch("mn_cli.server_cmds._remove_non_mirror_neuron_container")
+    mocker.patch("mn_cli.server_cmds._docker_container_running", return_value=False)
+    run = mocker.patch("mn_cli.server_cmds.subprocess.run")
+
+    result = server_cmds.ensure_context_engine_runtime()
+
+    env = server_cmds._read_env_file(server_cmds.RUNTIME_COMPOSE_ENV)
+    expected_image = (
+        "us-central1-docker.pkg.dev/mirrorneuron-public-packages/"
+        "mirrorneuron-runtime/membrane-context-engine:v1.2.7"
+    )
+    assert env["COMPOSE_PROFILES"] == "openshell,context"
+    assert env["ENGINE_IMAGE"] == expected_image
+    assert env["MN_MEMBRANE_ENGINE_IMAGE"] == expected_image
+    assert "MEMBRANE_DIR" not in env
+    assert result["status"] == "started"
+    assert result["engine_image"] == expected_image
+    ensure_source.assert_not_called()
+    assert run.call_args_list[0].args[0] == runtime_compose_cmd("pull", "membrane-context-engine")
+    assert run.call_args_list[1].args[0] == runtime_compose_cmd("up", "-d", "--no-build", "membrane-context-engine")
+
 def test_ensure_context_engine_runtime_skips_compose_when_already_running(mocker, tmp_path):
     membrane_dir = tmp_path / "Membrane"
     membrane_dir.mkdir()