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

{mirrorneuron_cli-1.2.8/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.8
+Version: 1.2.18
 Summary: MirrorNeuron CLI
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3

{mirrorneuron_cli-1.2.8 → 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.8
+Version: 1.2.18
 Summary: MirrorNeuron CLI
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3

{mirrorneuron_cli-1.2.8 → 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.8 → 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.8 → mirrorneuron_cli-1.2.18}/mn_cli/libs/model_cmds.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import os
 import subprocess
 from typing import Annotated, Any, Optional
 
@@ -250,16 +251,21 @@ def install_model_entry(
     target = docker_model_name(entry)
     if _docker_model_cli_available():
         _ensure_runner(compatibility.backend, compatibility.accelerator)
-        _docker_model_pull(target)
+        pull_result = _pull_model(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():
             run_command.extend(["--context-size", str(resolved_context)])
         run_command.append(target)
         _docker(run_command, timeout=300)
-        return {"entry": entry, "docker_model": target, "compatibility": payload, "transport": "docker_cli"}
+        return {
+            "entry": entry,
+            "docker_model": target,
+            "compatibility": payload,
+            **pull_result,
+        }
 
-    api_result = dmr_api_pull_model(target, timeout=900)
+    api_result = dmr_api_pull_model(target, timeout=_model_pull_timeout_seconds())
     return {
         "entry": entry,
         "docker_model": target,
@@ -269,6 +275,21 @@ def install_model_entry(
     }
 
 
+def _model_pull_timeout_seconds() -> float:
+    try:
+        return max(float(os.getenv("MN_DOCKER_MODEL_PULL_TIMEOUT_SECONDS", "3600")), 1.0)
+    except ValueError:
+        return 3600.0
+
+
+def _pull_model(target: str) -> dict[str, Any]:
+    if _endpoint_responds():
+        api_result = dmr_api_pull_model(target, timeout=_model_pull_timeout_seconds())
+        return {"transport": "docker_model_runner_api", "api": api_result}
+    _docker_model_pull(target)
+    return {"transport": "docker_cli"}
+
+
 def _docker_model_pull(target: str, *, attempts: int = 2) -> None:
     last_error: RuntimeError | None = None
     for attempt in range(1, attempts + 1):

{mirrorneuron_cli-1.2.8 → 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.8 → mirrorneuron_cli-1.2.18}/mn_cli/libs/skill_dependencies.py

@@ -79,8 +79,19 @@ def gar_requirement_lines(manifest: dict[str, Any] | None) -> list[str]:
     ]
 
 
+def gar_requirements_file_lines(manifest: dict[str, Any] | None) -> list[str]:
+    requirements = pinned_skill_dependency_requirements(manifest)
+    if not requirements:
+        return []
+    return [
+        f"--index-url {GAR_PIP_INDEX_URL}",
+        f"--extra-index-url {PYPI_PIP_INDEX_URL}",
+        *requirements,
+    ]
+
+
 def gar_requirements_text(manifest: dict[str, Any] | None) -> str:
-    lines = gar_requirement_lines(manifest)
+    lines = gar_requirements_file_lines(manifest)
     return "\n".join(lines).strip() + ("\n" if lines else "")
 
 

{mirrorneuron_cli-1.2.8 → mirrorneuron_cli-1.2.18}/mn_cli/libs/sys_cmds.py

@@ -310,15 +310,21 @@ def ensure_context_engine(
             )
             summary = ensure_context_engine_runtime(force=force)
             progress.update(task, description="[green]Context memory is ready.")
+        details = [
+            ("Service", summary["service"]),
+            ("Model", summary["model"]),
+            ("Model status", summary.get("model_status", "unknown")),
+        ]
+        if summary.get("membrane_dir"):
+            details.append(("Membrane", summary["membrane_dir"]))
+        if summary.get("engine_image"):
+            details.append(("Engine image", summary["engine_image"]))
+
         print_success_confirmation(
             console,
             "Context engine",
             status=summary["status"],
-            details=[
-                ("Service", summary["service"]),
-                ("Model", summary["model"]),
-                ("Membrane", summary["membrane_dir"]),
-            ],
+            details=details,
             next_steps="mn runtime health",
         )
     except Exception as exc: