mirrorneuron-cli 1.2.15__tar.gz → 1.2.18__tar.gz

{mirrorneuron_cli-1.2.15/mirrorneuron_cli.egg-info → mirrorneuron_cli-1.2.18}/PKG-INFO

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

{mirrorneuron_cli-1.2.15 → mirrorneuron_cli-1.2.18/mirrorneuron_cli.egg-info}/PKG-INFO

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

{mirrorneuron_cli-1.2.15 → mirrorneuron_cli-1.2.18}/mirrorneuron_cli.egg-info/SOURCES.txt

@@ -13,6 +13,8 @@ mirrorneuron_cli.egg-info/SOURCES.txt
 mirrorneuron_cli.egg-info/dependency_links.txt
 mirrorneuron_cli.egg-info/entry_points.txt
 mirrorneuron_cli.egg-info/requires.txt
+mirrorneuron_cli.egg-info/scm_file_list.json
+mirrorneuron_cli.egg-info/scm_version.json
 mirrorneuron_cli.egg-info/top_level.txt
 mn_cli/__init__.py
 mn_cli/banner.py

mirrorneuron_cli-1.2.18/mirrorneuron_cli.egg-info/scm_file_list.json

@@ -0,0 +1,83 @@
+{
+  "files": [
+    "README.md",
+    "uv.lock",
+    "RELEASE.md",
+    ".python-version",
+    "LICENSE",
+    "pyproject.toml",
+    "AGENTS.md",
+    ".gitignore",
+    "scripts/check-release-artifacts.sh",
+    "scripts/make-release-zip.sh",
+    "scripts/validate-version-tag.sh",
+    "mn_cli/runtime_state.py",
+    "mn_cli/__init__.py",
+    "mn_cli/error_handler.py",
+    "mn_cli/config.py",
+    "mn_cli/sdk_path.py",
+    "mn_cli/logging_config.py",
+    "mn_cli/banner.py",
+    "mn_cli/main.py",
+    "mn_cli/runtime_mode.py",
+    "mn_cli/server_cmds.py",
+    "mn_cli/terminal.py",
+    "mn_cli/shared.py",
+    "mn_cli/update_cmds.py",
+    "mn_cli/libs/backup_cmds.py",
+    "mn_cli/libs/model_cmds.py",
+    "mn_cli/libs/run_manifest.py",
+    "mn_cli/libs/__init__.py",
+    "mn_cli/libs/artifacts.py",
+    "mn_cli/libs/blueprint_cmds.py",
+    "mn_cli/libs/workflow_progress.py",
+    "mn_cli/libs/blueprint_models.py",
+    "mn_cli/libs/blueprint_observability.py",
+    "mn_cli/libs/deployment_cmds.py",
+    "mn_cli/libs/run_cmds.py",
+    "mn_cli/libs/skill_runtime.py",
+    "mn_cli/libs/event_relay.py",
+    "mn_cli/libs/resource_cmds.py",
+    "mn_cli/libs/skill_dependencies.py",
+    "mn_cli/libs/service_cmds.py",
+    "mn_cli/libs/run_logs.py",
+    "mn_cli/libs/runtime_health.py",
+    "mn_cli/libs/bundles.py",
+    "mn_cli/libs/blueprint_resources.py",
+    "mn_cli/libs/blueprint_repository.py",
+    "mn_cli/libs/schedule_cmds.py",
+    "mn_cli/libs/sys_cmds.py",
+    "mn_cli/libs/ui.py",
+    "mn_cli/libs/workflow_validation.py",
+    "mn_cli/libs/job_cmds.py",
+    "mn_cli/schemas/workflow_manifest.schema.json",
+    "tests/test_shared.py",
+    "tests/test_model_cmds.py",
+    "tests/test_deployment_cmds.py",
+    "tests/test_docker_network_integration.py",
+    "tests/test_service_cmds.py",
+    "tests/test_blueprint_resources.py",
+    "tests/test_backup_cmds.py",
+    "tests/test_server_cmds.py",
+    "tests/test_run_cmds.py",
+    "tests/test_blueprint_repository.py",
+    "tests/test_blueprint_cmds.py",
+    "tests/test_workflow_validation.py",
+    "tests/test_runtime_mode.py",
+    "tests/test_update_cmds.py",
+    "tests/test_schedule_cmds.py",
+    "tests/test_run_helpers.py",
+    "tests/test_sys_cmds.py",
+    "tests/conftest.py",
+    "tests/test_terminal.py",
+    "tests/test_job_cmds.py",
+    "tests/test_ui.py",
+    "tests/test_resource_cmds.py",
+    "tests/test_main.py",
+    "tests/test_runtime_health.py",
+    "tests/test_runtime_state.py",
+    "tests/test_repo_hygiene.py",
+    ".github/workflows/release.yml",
+    ".github/workflows/ci.yml"
+  ]
+}

mirrorneuron_cli-1.2.18/mirrorneuron_cli.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.2.18",
+  "distance": 0,
+  "node": "g2f11bbb43d316e874c05b7e3fb0e28480742005c",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-06-22"
+}

{mirrorneuron_cli-1.2.15 → mirrorneuron_cli-1.2.18}/mn_cli/libs/job_cmds.py

@@ -98,11 +98,6 @@ def list_jobs(running_only: bool = typer.Option(False, "--running-only", help="O
 def clear():
     """Remove all job records except running ones"""
     try:
-        admin_token = str(getattr(client, "admin_token", "") or config.grpc_admin_token or "").strip()
-        if not admin_token:
-            console.print("[red]Error: No local gRPC admin token was found for job clear.[/red]")
-            console.print("Start or recreate the runtime so the shared grpc_admin.token file is generated.")
-            return
         cleared_count = client.clear_jobs()
         logger.info("Cleared %d non-running jobs", cleared_count)
         print_success_confirmation(
@@ -115,11 +110,10 @@ def clear():
         if e.code() == grpc.StatusCode.PERMISSION_DENIED and "MN_GRPC_ADMIN_TOKEN" in str(e.details()):
             console.print("[red]Error: ClearJobs admin authorization failed.[/red]")
             console.print(
-                "The local admin token exists, but the running core rejected it. "
-                "This usually means the CLI/API is pointed at a runtime with different cluster tokens, "
-                "or the running core has not been recreated with the shared token-file mount."
+                "The running core rejected the fixed gRPC admin token. "
+                "Recreate the runtime with the current fixed-token build."
             )
-            console.print("Recreate the runtime once, then retry: mn runtime stop; mn runtime start")
+            console.print("Retry after: mn runtime stop; mn runtime start")
             return
         handle_cli_error(e, console, 'clear')
     except Exception as e:

{mirrorneuron_cli-1.2.15 → mirrorneuron_cli-1.2.18}/mn_cli/libs/run_cmds.py

@@ -61,14 +61,23 @@ from mn_cli.libs.workflow_validation import (
 from mn_cli.libs.blueprint_observability import (
     make_blueprint_run_id as _make_blueprint_run_id,
 )
+from mn_cli.libs.blueprint_models import BlueprintModelOps, blueprint_model_dependency_summary
+from mn_cli.libs.model_cmds import install_model_entry, model_installed
 from mn_cli.libs.blueprint_resources import cleanup_blueprint_host_hooks
 from mn_cli.server_cmds import ensure_context_engine_runtime
 from mn_cli.shared import console, client, logger
 from mn_cli.terminal import use_progress
 from mn_cli.error_handler import handle_cli_error
 from mn_sdk import (
+    cluster_provided_model,
+    docker_model_name,
+    load_model_catalog,
+    load_model_ownership,
     make_validation_report,
     prepare_job_submission,
+    record_model_owner,
+    required_blueprint_models,
+    resolve_model_entry,
     run_hardware_requirements_validation,
     run_input_validation,
     run_model_validation,
@@ -234,6 +243,119 @@ def _manifest_config(manifest: dict[str, Any]) -> dict[str, Any]:
     return {}
 
 
+def _prepare_runtime_models_for_run_or_exit(
+    bundle_dir: Path,
+    manifest: dict[str, Any],
+    *,
+    env_overrides: Optional[dict[str, str]] = None,
+    config_overrides: Optional[dict[str, Any]] = None,
+    force: bool = False,
+) -> dict[str, Any]:
+    config = load_blueprint_config(bundle_dir, config_overrides=config_overrides) or {}
+    validation_manifest = _manifest_for_model_validation(manifest, config)
+    summary = blueprint_model_dependency_summary(
+        blueprint_id=_runtime_model_blueprint_id(bundle_dir, manifest, config),
+        blueprint_revision=_runtime_model_blueprint_revision(manifest, config),
+        bundle_root=bundle_dir,
+        manifest=validation_manifest,
+        config=config,
+        install_source=str(bundle_dir),
+        force=force,
+        ops=BlueprintModelOps(
+            load_model_catalog=load_model_catalog,
+            required_blueprint_models=required_blueprint_models,
+            load_model_ownership=load_model_ownership,
+            resolve_model_entry=resolve_model_entry,
+            docker_model_name=docker_model_name,
+            cluster_provided_model=cluster_provided_model,
+            record_model_owner=record_model_owner,
+            model_installed=model_installed,
+            install_model_entry=install_model_entry,
+            notify_model_install_start=_print_runtime_model_install_start,
+        ),
+    )
+    _print_runtime_model_install_summary(summary)
+    if summary["errors"]:
+        raise typer.Exit(1)
+    return summary
+
+
+def _runtime_model_blueprint_id(
+    bundle_dir: Path,
+    manifest: dict[str, Any],
+    config: dict[str, Any],
+) -> str:
+    metadata = manifest.get("metadata") if isinstance(manifest.get("metadata"), dict) else {}
+    identity = config.get("identity") if isinstance(config.get("identity"), dict) else {}
+    for value in (
+        metadata.get("blueprint_id"),
+        metadata.get("blueprintId"),
+        identity.get("blueprint_id"),
+        identity.get("blueprintId"),
+        manifest.get("id"),
+        manifest.get("graph_id"),
+        manifest.get("job_name"),
+    ):
+        text = str(value or "").strip()
+        if text:
+            return text
+    return bundle_dir.name
+
+
+def _runtime_model_blueprint_revision(
+    manifest: dict[str, Any],
+    config: dict[str, Any],
+) -> str | None:
+    metadata = manifest.get("metadata") if isinstance(manifest.get("metadata"), dict) else {}
+    identity = config.get("identity") if isinstance(config.get("identity"), dict) else {}
+    for value in (
+        metadata.get("blueprint_revision"),
+        metadata.get("blueprintRevision"),
+        identity.get("blueprint_revision"),
+        identity.get("blueprintRevision"),
+        manifest.get("revision"),
+        manifest.get("version"),
+    ):
+        text = str(value or "").strip()
+        if text:
+            return text
+    return None
+
+
+def _print_runtime_model_install_start(model: dict[str, Any]) -> None:
+    label = str(model.get("id") or model.get("model") or "runtime model")
+    docker_model = str(model.get("model") or "")
+    backend = str(model.get("backend") or "auto")
+    detail = f"{label} ({docker_model})" if docker_model and docker_model != label else label
+    console.print(
+        f"[yellow]Runtime model {detail} is not installed. "
+        f"Installing with backend {backend}; this may take a few minutes the first time.[/yellow]"
+    )
+
+
+def _print_runtime_model_install_summary(summary: dict[str, Any]) -> None:
+    models = summary.get("models") or []
+    if not models:
+        return
+
+    prepared = [
+        item
+        for item in models
+        if str(item.get("status") or "")
+        in {"installed", "already_installed", "service_required", "cluster_provided"}
+    ]
+    if prepared:
+        labels = ", ".join(
+            str(item.get("id") or item.get("model") or "runtime model")
+            for item in prepared[:4]
+        )
+        if len(prepared) > 4:
+            labels = f"{labels}, +{len(prepared) - 4} more"
+        console.print(f"[green]Runtime models ready:[/green] {labels}")
+    for error in summary.get("errors") or []:
+        console.print(f"[red]Runtime model install failed: {error}[/red]")
+
+
 def _ensure_context_engine_for_run_if_needed(
     bundle_dir: Path,
     manifest: dict[str, Any],
@@ -1609,6 +1731,17 @@ def run_bundle(
                 env_overrides=env_overrides,
                 config_overrides=config_overrides,
             )
+            _print_launch_progress(
+                "Prepare runtime models",
+                "installing any missing Docker Model Runner models required by this blueprint.",
+            )
+            _prepare_runtime_models_for_run_or_exit(
+                bundle_dir,
+                manifest_dict,
+                env_overrides=env_overrides,
+                config_overrides=config_overrides,
+                force=force,
+            )
             _validate_manifest_models_or_exit(
                 bundle_dir,
                 manifest_dict,
@@ -1623,7 +1756,18 @@ def run_bundle(
             )
         else:
             console.print(
-                "[yellow]Validation skipped because --force was provided; service checks, model checks, input checks, and non-hard runtime requirements will be bypassed for this run.[/yellow]"
+                "[yellow]Validation skipped because --force was provided; service checks, model checks, input checks, and non-hard runtime requirements will be bypassed, but required runtime models will still be prepared.[/yellow]"
+            )
+            _print_launch_progress(
+                "Prepare runtime models",
+                "installing any missing Docker Model Runner models required by this blueprint.",
+            )
+            _prepare_runtime_models_for_run_or_exit(
+                bundle_dir,
+                manifest_dict,
+                env_overrides=env_overrides,
+                config_overrides=config_overrides,
+                force=force,
             )
         _print_launch_progress(
             "Package workflow",

{mirrorneuron_cli-1.2.15 → mirrorneuron_cli-1.2.18}/mn_cli/server_cmds.py

@@ -19,7 +19,7 @@ from urllib.parse import urlparse
 import typer
 from rich.console import Console
 from rich.table import Table
-from mn_sdk.blueprint_source import DEFAULT_BLUEPRINT_REPO
+from mn_sdk.blueprint_source import DEFAULT_BLUEPRINT_REPO, normalize_blueprint_repo_value
 from mn_cli.config import CliConfig
 from mn_cli.libs.ui import print_confirmed, print_success_confirmation
 from mn_cli.logging_config import configure_logging
@@ -36,6 +36,8 @@ logger = configure_logging("mn-cli", CliConfig.from_env().log_path)
 GRPC_ADMIN_TOKEN_ENV = "MN_GRPC_ADMIN_TOKEN"
 GRPC_AUTH_TOKEN_FILE_ENV = "MN_GRPC_AUTH_TOKEN_FILE"
 GRPC_ADMIN_TOKEN_FILE_ENV = "MN_GRPC_ADMIN_TOKEN_FILE"
+FIXED_GRPC_AUTH_TOKEN = "mirror_neuron_password"
+FIXED_GRPC_ADMIN_TOKEN = "mirror_neuron_password_admin"
 
 def _erl_aflags(dist_port: str | int) -> str:
     return (
@@ -186,8 +188,6 @@ DEFAULT_BLUEPRINT_WEB_UI_PORT_ALLOCATION_MODE = "prepublished"
 DEFAULT_CONTAINER_RUNS_ROOT = "/root/.mn/runs"
 DEFAULT_CONTAINER_BLOB_STORE_ROOT = "/root/.mn/blobs"
 DEFAULT_RUNTIME_SHARED_STORAGE_ROOT = "/root/.mn/shared"
-DEFAULT_CONTAINER_GRPC_AUTH_TOKEN_FILE = "/root/.mn/grpc_auth.token"
-DEFAULT_CONTAINER_GRPC_ADMIN_TOKEN_FILE = "/root/.mn/grpc_admin.token"
 DEFAULT_REDIS_IMAGE = "redis:8"
 LEGACY_GRPC_PORT = "50051"
 LEGACY_API_PORT = "4001"
@@ -732,46 +732,10 @@ def _resolve_mn_cookie() -> str:
     return generated_cookie
 
 def _resolve_grpc_auth_token() -> str:
-    env_token = os.getenv("MN_GRPC_AUTH_TOKEN", "").strip()
-    if env_token:
-        return env_token
-
-    token_file = DIR / "grpc_auth.token"
-    try:
-        existing_token = token_file.read_text().strip()
-        if existing_token:
-            return existing_token
-    except FileNotFoundError:
-        pass
-
-    DIR.mkdir(parents=True, exist_ok=True)
-    generated_token = secrets.token_hex(32)
-    _write_grpc_token_file(token_file, generated_token, "gRPC auth")
-    return generated_token
+    return FIXED_GRPC_AUTH_TOKEN
 
 def _resolve_grpc_admin_token() -> str:
-    env_token = os.getenv(GRPC_ADMIN_TOKEN_ENV, "").strip()
-    if env_token:
-        return env_token
-
-    token_file = DIR / "grpc_admin.token"
-    try:
-        existing_token = token_file.read_text().strip()
-        if existing_token:
-            return existing_token
-    except FileNotFoundError:
-        pass
-
-    DIR.mkdir(parents=True, exist_ok=True)
-    generated_token = secrets.token_hex(32)
-    _write_grpc_token_file(token_file, generated_token, "gRPC admin")
-    return generated_token
-
-def _write_grpc_token_file(token_file: Path, token: str, label: str) -> None:
-    token = str(token or "").strip()
-    if not token:
-        return
-    write_private_text(token_file, f"{token}\n")
+    return FIXED_GRPC_ADMIN_TOKEN
 
 def _resolve_api_token() -> str:
     env_token = os.getenv("MN_API_TOKEN", "").strip()
@@ -802,57 +766,34 @@ def _ensure_runtime_api_token(env: dict[str, str], *, persist_compose: bool = Fa
 
 def _ensure_runtime_grpc_tokens(env: dict[str, str], *, persist_compose: bool = False) -> dict[str, str]:
     resolved = dict(env)
-    if not str(resolved.get("MN_GRPC_AUTH_TOKEN") or "").strip():
-        resolved["MN_GRPC_AUTH_TOKEN"] = _resolve_grpc_auth_token()
-    if not str(resolved.get(GRPC_ADMIN_TOKEN_ENV) or "").strip():
-        resolved[GRPC_ADMIN_TOKEN_ENV] = _resolve_grpc_admin_token()
-    if not str(resolved.get(GRPC_AUTH_TOKEN_FILE_ENV) or "").strip():
-        resolved[GRPC_AUTH_TOKEN_FILE_ENV] = DEFAULT_CONTAINER_GRPC_AUTH_TOKEN_FILE
-    if not str(resolved.get(GRPC_ADMIN_TOKEN_FILE_ENV) or "").strip():
-        resolved[GRPC_ADMIN_TOKEN_FILE_ENV] = DEFAULT_CONTAINER_GRPC_ADMIN_TOKEN_FILE
-
-    _write_grpc_token_file(DIR / "grpc_auth.token", resolved["MN_GRPC_AUTH_TOKEN"], "gRPC auth")
-    _write_grpc_token_file(
-        DIR / "grpc_admin.token",
-        resolved[GRPC_ADMIN_TOKEN_ENV],
-        "gRPC admin",
-    )
+    fixed_tokens = {
+        "MN_GRPC_AUTH_TOKEN": FIXED_GRPC_AUTH_TOKEN,
+        GRPC_ADMIN_TOKEN_ENV: FIXED_GRPC_ADMIN_TOKEN,
+    }
+    stale_token_keys = {
+        "MN_MIRROR_NEURON_GRPC_ADMIN_TOKEN",
+        GRPC_AUTH_TOKEN_FILE_ENV,
+        GRPC_ADMIN_TOKEN_FILE_ENV,
+    }
+    for key in stale_token_keys:
+        resolved.pop(key, None)
+    resolved.update(fixed_tokens)
     if persist_compose:
-        _write_env_file_values(
-            RUNTIME_COMPOSE_ENV,
-            {
-                "MN_GRPC_AUTH_TOKEN": resolved["MN_GRPC_AUTH_TOKEN"],
-                GRPC_ADMIN_TOKEN_ENV: resolved[GRPC_ADMIN_TOKEN_ENV],
-                GRPC_AUTH_TOKEN_FILE_ENV: resolved[GRPC_AUTH_TOKEN_FILE_ENV],
-                GRPC_ADMIN_TOKEN_FILE_ENV: resolved[GRPC_ADMIN_TOKEN_FILE_ENV],
-            },
-        )
+        _write_env_file_values(RUNTIME_COMPOSE_ENV, fixed_tokens)
+        _remove_env_file_keys(RUNTIME_COMPOSE_ENV, stale_token_keys)
     return resolved
 
 def _grpc_tokens_from_handshake(handshake: Optional[dict]) -> dict[str, str]:
-    if not handshake:
-        return {}
-    tokens: dict[str, str] = {}
-    auth_token = str(handshake.get("grpc_auth_token") or "").strip()
-    admin_token = str(handshake.get("grpc_admin_token") or "").strip()
-    if auth_token:
-        tokens["MN_GRPC_AUTH_TOKEN"] = auth_token
-    if admin_token:
-        tokens[GRPC_ADMIN_TOKEN_ENV] = admin_token
-    return tokens
+    return {
+        "MN_GRPC_AUTH_TOKEN": FIXED_GRPC_AUTH_TOKEN,
+        GRPC_ADMIN_TOKEN_ENV: FIXED_GRPC_ADMIN_TOKEN,
+    }
 
 def _runtime_grpc_tokens_from_running_container() -> dict[str, str]:
-    tokens: dict[str, str] = {}
-    for container_name in (LOCAL_CORE_CONTAINER, NETWORK_CORE_CONTAINER):
-        auth_token = _docker_container_env_value(container_name, "MN_GRPC_AUTH_TOKEN")
-        admin_token = _docker_container_env_value(container_name, GRPC_ADMIN_TOKEN_ENV)
-        if auth_token:
-            tokens["MN_GRPC_AUTH_TOKEN"] = auth_token
-        if admin_token:
-            tokens[GRPC_ADMIN_TOKEN_ENV] = admin_token
-        if tokens:
-            break
-    return tokens
+    return {
+        "MN_GRPC_AUTH_TOKEN": FIXED_GRPC_AUTH_TOKEN,
+        GRPC_ADMIN_TOKEN_ENV: FIXED_GRPC_ADMIN_TOKEN,
+    }
 
 def _resolve_network_token(force_new: bool = False) -> str:
     if force_new:
@@ -1245,8 +1186,8 @@ def _network_core_env(
             "MN_RUNTIME_SHARED_STORAGE_ROOT": DEFAULT_RUNTIME_SHARED_STORAGE_ROOT,
             "MN_DIST_PORT": str(dist_port),
             "MN_COOKIE": _derive_network_secret(token, "cookie"),
-            "MN_GRPC_AUTH_TOKEN": _resolve_grpc_auth_token(),
-            GRPC_ADMIN_TOKEN_ENV: _resolve_grpc_admin_token(),
+            "MN_GRPC_AUTH_TOKEN": FIXED_GRPC_AUTH_TOKEN,
+            GRPC_ADMIN_TOKEN_ENV: FIXED_GRPC_ADMIN_TOKEN,
             "ERL_EPMD_ADDRESS": "0.0.0.0",
             "ERL_EPMD_PORT": str(epmd_port),
             "ERL_AFLAGS": _erl_aflags(dist_port),
@@ -1652,9 +1593,6 @@ def _start_network_seed(
         redis_public_host=redis_public_host,
         redis_public_port=redis_public_port,
     )
-    env["MN_GRPC_AUTH_TOKEN"] = _resolve_grpc_auth_token()
-    env[GRPC_ADMIN_TOKEN_ENV] = _resolve_grpc_admin_token()
-
     env = _ensure_runtime_grpc_tokens(env, persist_compose=runtime_compose_available())
 
     console.print("=> Starting MirrorNeuron core-only exposed node...")
@@ -2029,11 +1967,10 @@ def ensure_context_engine_runtime(*, force: bool = False) -> dict[str, str]:
     _remove_non_mirror_neuron_container(CONTEXT_ENGINE_CONTAINER)
     _remove_non_mirror_neuron_container(CONTEXT_ENGINE_MODEL_CONTAINER)
     _ensure_docker_model_runner()
-    model_already_installed = _docker_model_inspect_ok(model)
-    model_status = "already_installed" if model_already_installed else "compose_pending"
+    model_status = _install_context_engine_model(model)
 
     already_running = _docker_container_running(CONTEXT_ENGINE_CONTAINER)
-    if force or not already_running or not model_already_installed:
+    if force or not already_running:
         compose_env = env
         anonymous_docker_config: Path | None = None
         if use_engine_image:
@@ -2066,8 +2003,6 @@ def ensure_context_engine_runtime(*, force: bool = False) -> dict[str, str]:
             if anonymous_docker_config is not None:
                 shutil.rmtree(anonymous_docker_config, ignore_errors=True)
         status = "restarted" if already_running and force else "started"
-        if not model_already_installed:
-            model_status = "installed" if _docker_model_inspect_ok(model) else "compose_managed"
     else:
         status = "already_running"
 
@@ -2091,6 +2026,37 @@ def _docker_model_inspect_ok(model: str) -> bool:
         return False
     return _docker_command_ok(["docker", "model", "inspect", model])
 
+def _install_context_engine_model(model: str) -> str:
+    model = str(model or "").strip()
+    if not model:
+        return "skipped"
+    if _docker_model_inspect_ok(model):
+        return "already_installed"
+    pull_result = subprocess.run(
+        ["docker", "model", "pull", model],
+        capture_output=True,
+        text=True,
+        timeout=900,
+    )
+    if pull_result.returncode != 0 and not _docker_model_inspect_ok(model):
+        output = _subprocess_error_output(pull_result)
+        raise RuntimeError(f"Failed to install context engine model {model}: {output}")
+    run_result = subprocess.run(
+        ["docker", "model", "run", "--detach", model],
+        capture_output=True,
+        text=True,
+        timeout=300,
+    )
+    if run_result.returncode != 0:
+        output = _subprocess_error_output(run_result)
+        if "already" not in output.lower():
+            raise RuntimeError(f"Failed to start context engine model {model}: {output}")
+    return "installed"
+
+def _subprocess_error_output(result: subprocess.CompletedProcess[str]) -> str:
+    output = f"{result.stderr or ''}\n{result.stdout or ''}".strip()
+    return output or f"exit code {result.returncode}"
+
 def _anonymous_public_gar_docker_env(env: dict[str, str], image: str) -> tuple[dict[str, str], Path | None]:
     if not _is_public_gar_image(image):
         return env, None
@@ -2454,10 +2420,13 @@ def _cluster_endpoint_host(env: dict[str, str], host: str) -> str:
     return _native_endpoint_host(normalized)
 
 def _runtime_blueprint_env_updates(env: dict[str, str]) -> dict[str, str]:
+    runtime_env = str(env.get("MN_ENV") or os.getenv("MN_ENV") or "dev").strip().lower()
     blueprint_source = str(env.get("MN_BLUEPRINT_SOURCE") or os.getenv("MN_BLUEPRINT_SOURCE") or "github").strip().lower()
     if blueprint_source not in {"github", "local"}:
         blueprint_source = "github"
-    blueprint_repo = str(env.get("MN_BLUEPRINT_REPO") or os.getenv("MN_BLUEPRINT_REPO") or DEFAULT_BLUEPRINT_REPO).strip()
+    blueprint_repo = normalize_blueprint_repo_value(
+        str(env.get("MN_BLUEPRINT_REPO") or os.getenv("MN_BLUEPRINT_REPO") or DEFAULT_BLUEPRINT_REPO).strip()
+    )
     blueprint_local = str(env.get("MN_BLUEPRINT_LOCAL") or os.getenv("MN_BLUEPRINT_LOCAL") or "").strip()
     host_home_dir = str(
         env.get("MN_HOST_HOME_DIR")
@@ -2500,6 +2469,7 @@ def _runtime_blueprint_env_updates(env: dict[str, str]) -> dict[str, str]:
         or DEFAULT_RUNTIME_SHARED_STORAGE_ROOT
     ).strip()
     updates: dict[str, str] = {
+        "MN_ENV": runtime_env,
         "MN_BLUEPRINT_SOURCE": blueprint_source,
         "MN_BLUEPRINT_REPO": blueprint_repo,
         "MN_BLUEPRINT_LOCAL": blueprint_local,
@@ -2636,6 +2606,11 @@ def _runtime_api_config_mismatches(env: dict[str, str], health: Optional[dict[st
     if not health:
         return []
     mismatches: list[tuple[str, str, str]] = []
+    expected_env = str(env.get("MN_ENV") or "dev").strip().lower()
+    active_env = str(health.get("env") or health.get("mn_env") or "").strip().lower()
+    if active_env and expected_env and active_env != expected_env:
+        mismatches.append(("MN_ENV", active_env, expected_env))
+
     expected_blueprint = _expected_blueprint_location(env)
     active_blueprint = str(
         health.get("active_blueprint_location")
@@ -3632,10 +3607,8 @@ def _build_core_docker_run_command(
 
     cmd.extend(["-e", f"MN_NODE_NAME={env['MN_NODE_NAME']}"])
     cmd.extend(["-e", f"MN_COOKIE={env['MN_COOKIE']}"])
-    cmd.extend(["-e", f"MN_GRPC_AUTH_TOKEN={env['MN_GRPC_AUTH_TOKEN']}"])
-    cmd.extend(["-e", f"{GRPC_AUTH_TOKEN_FILE_ENV}={env[GRPC_AUTH_TOKEN_FILE_ENV]}"])
-    cmd.extend(["-e", f"{GRPC_ADMIN_TOKEN_ENV}={env[GRPC_ADMIN_TOKEN_ENV]}"])
-    cmd.extend(["-e", f"{GRPC_ADMIN_TOKEN_FILE_ENV}={env[GRPC_ADMIN_TOKEN_FILE_ENV]}"])
+    cmd.extend(["-e", f"MN_GRPC_AUTH_TOKEN={env.get('MN_GRPC_AUTH_TOKEN', FIXED_GRPC_AUTH_TOKEN)}"])
+    cmd.extend(["-e", f"{GRPC_ADMIN_TOKEN_ENV}={env.get(GRPC_ADMIN_TOKEN_ENV, FIXED_GRPC_ADMIN_TOKEN)}"])
     cmd.extend(["-e", f"MN_NETWORK_JOIN_TOKEN={env['MN_NETWORK_JOIN_TOKEN']}"])
     cmd.extend(["-e", f"MN_NETWORK_ADVERTISE_HOST={env['MN_NETWORK_ADVERTISE_HOST']}"])
     if env.get("MN_MODEL_SERVICE_NODE_NAME"):
@@ -3779,14 +3752,16 @@ def _start_server(
         env = _ensure_runtime_api_token(env, persist_compose=compose_runtime)
         if compose_runtime:
             env = _ensure_compose_native_port_settings(env)
-            if not _docker_container_running("mirror-neuron-core"):
+            core_running = _docker_container_running("mirror-neuron-core")
+            if not core_running:
                 console.print("=> MirrorNeuron Core is not running; starting Docker runtime (Compose)...")
-                try:
-                    subprocess.run(runtime_compose_cmd("up", "-d"), check=True, stdout=subprocess.DEVNULL, env=env)
+            try:
+                subprocess.run(runtime_compose_cmd("up", "-d"), check=True, stdout=subprocess.DEVNULL, env=env)
+                if not core_running:
                     console.print("   [green][Started][/green] Docker runtime (Compose project: mirror-neuron)")
-                except (FileNotFoundError, subprocess.CalledProcessError):
-                    console.print("[red]Failed to start MirrorNeuron Docker runtime.[/red]")
-                    raise typer.Exit(1)
+            except (FileNotFoundError, subprocess.CalledProcessError):
+                console.print("[red]Failed to start MirrorNeuron Docker runtime.[/red]")
+                raise typer.Exit(1)
         env.setdefault("MN_API_HOST", _api_host())
         env.setdefault("MN_API_PORT", DEFAULT_API_PORT)
         env.setdefault("MN_WEB_UI_HOST", _web_ui_host())

{mirrorneuron_cli-1.2.15 → mirrorneuron_cli-1.2.18}/tests/test_job_cmds.py

@@ -25,7 +25,7 @@ def _capture_console(monkeypatch):
     return output
 
 
-def test_clear_preflights_missing_admin_token(monkeypatch):
+def test_clear_runs_without_local_admin_token_preflight(monkeypatch):
     output = _capture_console(monkeypatch)
     client = SimpleNamespace(admin_token="", clear_jobs=lambda: 1)
     monkeypatch.setattr(job_cmds, "client", client)
@@ -34,8 +34,8 @@ def test_clear_preflights_missing_admin_token(monkeypatch):
     job_cmds.clear()
 
     rendered = output.getvalue()
-    assert "No local gRPC admin token was found" in rendered
-    assert "shared grpc_admin.token file" in rendered
+    assert "Job clear successful" in rendered
+    assert "Jobs cleared: 1 non-running" in rendered
 
 
 def test_clear_reports_admin_token_mismatch(monkeypatch):
@@ -54,4 +54,4 @@ def test_clear_reports_admin_token_mismatch(monkeypatch):
 
     rendered = output.getvalue()
     assert "ClearJobs admin authorization failed" in rendered
-    assert "different cluster tokens" in rendered
+    assert "fixed gRPC admin token" in rendered