mirrorneuron-cli 1.2.5__tar.gz → 1.2.6__tar.gz

{mirrorneuron_cli-1.2.5/mirrorneuron_cli.egg-info → mirrorneuron_cli-1.2.6}/PKG-INFO

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

{mirrorneuron_cli-1.2.5 → mirrorneuron_cli-1.2.6/mirrorneuron_cli.egg-info}/PKG-INFO

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

{mirrorneuron_cli-1.2.5 → mirrorneuron_cli-1.2.6}/mn_cli/server_cmds.py

@@ -53,6 +53,39 @@ def _erl_aflags_needs_update(value: Optional[str], dist_port: str | int) -> bool
         or f"inet_dist_listen_max {dist_port}" not in text
     )
 
+def _distributed_core_command() -> list[str]:
+    command = (
+        "if [ -x \"bin/mirror_neuron\" ]; then "
+        "if [ -n \"${MN_NODE_NAME:-}\" ]; then "
+        "if [ -z \"${MN_COOKIE:-}\" ] || [ \"${MN_COOKIE:-}\" = \"mirrorneuron\" ]; then "
+        "echo \"MN_COOKIE must be set to a non-default secret when MN_NODE_NAME enables distributed Erlang\" >&2; exit 1; "
+        "fi; "
+        "unset ERL_EPMD_ADDRESS; "
+        "epmd_bin=\"$(find erts-* -path '*/bin/epmd' -type f | head -n 1)\"; "
+        "if [ -n \"$epmd_bin\" ]; then \"$epmd_bin\" -daemon; else epmd -daemon; fi; "
+        "export RELEASE_DISTRIBUTION=name; "
+        "export RELEASE_NODE=\"$MN_NODE_NAME\"; "
+        "export RELEASE_COOKIE=\"$MN_COOKIE\"; "
+        "else "
+        "export RELEASE_DISTRIBUTION=none; "
+        "fi; "
+        "exec bin/mirror_neuron start; "
+        "fi; "
+        "if [ -n \"${MN_NODE_NAME:-}\" ]; then "
+        "if [ -z \"${MN_COOKIE:-}\" ] || [ \"${MN_COOKIE:-}\" = \"mirrorneuron\" ]; then "
+        "echo \"MN_COOKIE must be set to a non-default secret when MN_NODE_NAME enables distributed Erlang\" >&2; exit 1; "
+        "fi; "
+        "dist_port=\"${MN_DIST_PORT:-4370}\"; "
+        "unset ERL_EPMD_ADDRESS; "
+        "epmd -daemon; "
+        "exec elixir --name \"$MN_NODE_NAME\" --cookie \"$MN_COOKIE\" --erl "
+        "\"-kernel inet_dist_listen_min ${dist_port} inet_dist_listen_max ${dist_port}\" -S mix run --no-halt; "
+        "else "
+        "exec mix run --no-halt; "
+        "fi"
+    )
+    return ["sh", "-c", command]
+
 def _mn_home() -> Path:
     return _runtime_mn_home()
 
@@ -65,6 +98,7 @@ API_PID_FILE = PID_DIR / "api.pid"
 API_WATCHDOG_PID_FILE = PID_DIR / "api-watchdog.pid"
 WEB_UI_PID_FILE = PID_DIR / "web-ui.pid"
 WEB_UI_WATCHDOG_PID_FILE = PID_DIR / "web-ui-watchdog.pid"
+API_TOKEN_FILE = DIR / "api.token"
 BEAM_LOG = LOG_DIR / "beam.log"
 API_LOG = LOG_DIR / "api.log"
 API_WATCHDOG_LOG = LOG_DIR / "api-watchdog.log"
@@ -143,6 +177,7 @@ 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"
 LEGACY_EPMD_PORT = "4369"
@@ -727,6 +762,33 @@ def _write_grpc_token_file(token_file: Path, token: str, label: str) -> None:
         return
     write_private_text(token_file, f"{token}\n")
 
+def _resolve_api_token() -> str:
+    env_token = os.getenv("MN_API_TOKEN", "").strip()
+    if env_token:
+        write_private_text(API_TOKEN_FILE, f"{env_token}\n")
+        return env_token
+    try:
+        existing_token = API_TOKEN_FILE.read_text(encoding="utf-8").strip()
+        if existing_token:
+            return existing_token
+    except OSError:
+        pass
+    generated_token = secrets.token_hex(32)
+    write_private_text(API_TOKEN_FILE, f"{generated_token}\n")
+    return generated_token
+
+def _ensure_runtime_api_token(env: dict[str, str], *, persist_compose: bool = False) -> dict[str, str]:
+    resolved = dict(env)
+    if str(resolved.get("MN_ENV") or "").strip().lower() != "prod":
+        return resolved
+    if not str(resolved.get("MN_API_TOKEN") or "").strip():
+        resolved["MN_API_TOKEN"] = _resolve_api_token()
+    else:
+        write_private_text(API_TOKEN_FILE, f"{resolved['MN_API_TOKEN'].strip()}\n")
+    if persist_compose and runtime_compose_available():
+        _write_env_file_values(RUNTIME_COMPOSE_ENV, {"MN_API_TOKEN": resolved["MN_API_TOKEN"]})
+    return resolved
+
 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():
@@ -1167,6 +1229,9 @@ def _network_core_env(
             "MN_NODE_ROLE": "runtime",
             "MN_CLUSTER_NODES": cluster_nodes,
             "MN_REDIS_URL": redis_url,
+            "MN_HOST_SHARED_STORAGE_ROOT": str(DIR / "shared"),
+            "MN_SHARED_STORAGE_ROOT": DEFAULT_RUNTIME_SHARED_STORAGE_ROOT,
+            "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(),
@@ -1186,6 +1251,50 @@ def _docker_env_args(env: dict[str, str]) -> list[str]:
             args.extend(["-e", f"{key}={env[key]}"])
     return args
 
+def _network_redis_image() -> str:
+    return os.getenv("MN_REDIS_IMAGE", "").strip() or DEFAULT_REDIS_IMAGE
+
+def _docker_host_socket() -> Optional[Path]:
+    candidates = [
+        os.getenv("DOCKER_HOST_SOCKET", "").strip(),
+        "/var/run/docker.sock",
+        str(Path.home() / ".docker" / "run" / "docker.sock"),
+    ]
+    for candidate in candidates:
+        if not candidate:
+            continue
+        path = Path(candidate).expanduser()
+        if path.exists():
+            return path
+    return None
+
+def _network_core_bind_args() -> list[str]:
+    args: list[str] = []
+    shared_dir = DIR / "shared"
+    shared_dir.mkdir(parents=True, exist_ok=True)
+
+    for host_path, container_path in (
+        (DIR, "/root/.mn"),
+        (DIR, "/opt/mirror_neuron/.mn"),
+        (DIR, str(DIR)),
+        (shared_dir, "/root/.mn/shared"),
+        (shared_dir, "/opt/mirror_neuron/.mn/shared"),
+    ):
+        args.extend(["-v", f"{host_path}:{container_path}:rw"])
+
+    args.extend(_docker_worker_bind_args())
+    return args
+
+def _docker_worker_bind_args() -> list[str]:
+    args: list[str] = []
+    socket_path = _docker_host_socket()
+    if socket_path is not None:
+        args.extend(["-v", f"{socket_path}:/var/run/docker.sock:rw"])
+        docker_cli = shutil.which("docker") if sys.platform.startswith("linux") else None
+        if docker_cli:
+            args.extend(["-v", f"{docker_cli}:/usr/local/bin/docker:ro"])
+    return args
+
 def _start_network_redis(
     host: str,
     redis_port: Optional[int],
@@ -1210,7 +1319,7 @@ def _start_network_redis(
         *_docker_network_run_args(docker_network_mode, docker_network_name, redis_alias),
         "-v",
         f"{data_dir}:/data",
-        "redis:7",
+        _network_redis_image(),
         "redis-server",
         "--appendonly",
         "yes",
@@ -1257,8 +1366,10 @@ def _start_network_core(
         NETWORK_CORE_CONTAINER,
         *_docker_network_run_args(docker_network_mode, docker_network_name, node_alias),
         *port_args,
+        *_network_core_bind_args(),
         *env_args,
         "mirror-neuron-core:latest",
+        *_distributed_core_command(),
     ]
     subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL)
 
@@ -1501,6 +1612,8 @@ def _start_network_seed(
         redis_public_port = selected_redis_port or REDIS_CONTAINER_PORT
 
     _ensure_network_docker_network(container_network_mode, network_name)
+    if container_network_mode == "disabled" and _docker_host_socket() is not None:
+        _ensure_docker_network("bridge", network_name)
     if not external_redis_url:
         console.print("=> Starting network Redis...")
         _start_network_redis(
@@ -1608,6 +1721,8 @@ def _join_network(
         console.print("Check that the local MirrorNeuron core is running, and that the remote host and token are correct.")
         console.print(f"[dim]{exc}[/dim]")
         raise typer.Exit(1) from exc
+    if runtime_compose_available():
+        _persist_compose_cluster_node(remote_node)
     details: list[tuple[str, str]] = [("Node", remote_node)]
     if runtime_compose_available() or os.getenv("MN_REDIS_URL", "").strip():
         replication = _configure_worker_redis_replica(seed_host, handshake, token)
@@ -1625,6 +1740,17 @@ def _join_network(
     )
     return handshake
 
+def _persist_compose_cluster_node(node_name: str) -> None:
+    node_name = str(node_name or "").strip()
+    if not node_name:
+        return
+
+    env = _read_env_file(RUNTIME_COMPOSE_ENV)
+    nodes = _split_env_list(env.get("MN_CLUSTER_NODES"))
+    if node_name not in nodes:
+        nodes.append(node_name)
+        _write_env_file_values(RUNTIME_COMPOSE_ENV, {"MN_CLUSTER_NODES": ",".join(nodes)})
+
 def _ensure_local_cluster_runtime_for_join(
     *,
     local_host: str,
@@ -2065,6 +2191,80 @@ def _runtime_endpoint_snapshot(env: dict[str, str], web_ui_available: bool = Fal
         }
     return snapshot
 
+def _read_runtime_api_health(api_host: str, api_port: str, *, timeout_seconds: float = 2.0) -> Optional[dict[str, Any]]:
+    url = _api_http_url(api_host, api_port, "/api/v1/health")
+    try:
+        with urllib.request.urlopen(url, timeout=timeout_seconds) as response:
+            payload = json.loads(response.read().decode("utf-8"))
+            return payload if isinstance(payload, dict) else None
+    except Exception:
+        return None
+
+def _is_url_like(value: str) -> bool:
+    normalized = str(value or "").strip()
+    if re.fullmatch(r"[\w.-]+@[\w.-]+:[^\s]+", normalized):
+        return True
+    try:
+        parsed = urlparse(normalized)
+    except Exception:
+        return False
+    return parsed.scheme in {"http", "https", "ssh", "git"} and bool(parsed.netloc)
+
+def _normalize_blueprint_location(value: str) -> str:
+    normalized = str(value or "").strip()
+    if not normalized:
+        return ""
+    if _is_url_like(normalized):
+        if re.fullmatch(r"[\w.-]+@[\w.-]+:[^\s]+", normalized):
+            host, _, repo_path = normalized.partition(":")
+            return f"{host.lower()}:{repo_path.rstrip('/').removesuffix('.git')}"
+        parsed = urlparse(normalized)
+        repo_path = parsed.path.rstrip("/").removesuffix(".git")
+        return f"{parsed.scheme.lower()}://{parsed.netloc.lower()}{repo_path}"
+    return str(Path(normalized).expanduser().resolve())
+
+def _same_blueprint_location(active: str, expected: str) -> bool:
+    active_normalized = _normalize_blueprint_location(active)
+    expected_normalized = _normalize_blueprint_location(expected)
+    return bool(active_normalized and expected_normalized and active_normalized == expected_normalized)
+
+def _same_runtime_path(active: str, expected: str) -> bool:
+    active_path = str(active or "").strip()
+    expected_path = str(expected or "").strip()
+    if not active_path or not expected_path:
+        return False
+    try:
+        return Path(active_path).expanduser().resolve() == Path(expected_path).expanduser().resolve()
+    except OSError:
+        return active_path == expected_path
+
+def _expected_blueprint_location(env: dict[str, str]) -> str:
+    source = str(env.get("MN_BLUEPRINT_SOURCE") or "github").strip().lower()
+    if source == "local":
+        return str(env.get("MN_BLUEPRINT_LOCAL") or "").strip()
+    return str(env.get("MN_BLUEPRINT_REPO") or DEFAULT_BLUEPRINT_REPO).strip()
+
+def _runtime_api_config_mismatches(env: dict[str, str], health: Optional[dict[str, Any]]) -> list[tuple[str, str, str]]:
+    if not health:
+        return []
+    mismatches: list[tuple[str, str, str]] = []
+    expected_blueprint = _expected_blueprint_location(env)
+    active_blueprint = str(
+        health.get("active_blueprint_location")
+        or health.get("activeBlueprintLocation")
+        or health.get("blueprint_repo")
+        or health.get("blueprintRepo")
+        or ""
+    ).strip()
+    if active_blueprint and expected_blueprint and not _same_blueprint_location(active_blueprint, expected_blueprint):
+        mismatches.append(("blueprint repo", active_blueprint, expected_blueprint))
+
+    expected_runs_root = str(env.get("MN_RUNS_ROOT") or env.get("MN_HOST_ARTIFACTS_DIR") or "").strip()
+    active_runs_root = str(health.get("runs_root") or health.get("runsRoot") or "").strip()
+    if active_runs_root and expected_runs_root and not _same_runtime_path(active_runs_root, expected_runs_root):
+        mismatches.append(("runs root", active_runs_root, expected_runs_root))
+    return mismatches
+
 def _write_runtime_endpoints_file(env: dict[str, str], web_ui_available: bool = False) -> dict[str, object]:
     snapshot = _runtime_endpoint_snapshot(env, web_ui_available=web_ui_available)
     RUNTIME_ENDPOINTS_FILE.parent.mkdir(parents=True, exist_ok=True)
@@ -2399,15 +2599,6 @@ def _configure_worker_redis_replica(
             worker_redis_host,
             worker_redis_port,
             worker_password,
-            "CONFIG",
-            "SET",
-            "requirepass",
-            primary_password,
-        )
-        _redis_command(
-            worker_redis_host,
-            worker_redis_port,
-            primary_password,
             "REPLICAOF",
             primary_host,
             str(primary_port),
@@ -2704,7 +2895,12 @@ def _start_api_watchdog(env: dict[str, str]) -> subprocess.Popen:
             start_new_session=True,
         )
 
-def _start_api_if_installed(runtime_env: Optional[dict[str, str]] = None) -> bool:
+def _start_api_if_installed(
+    runtime_env: Optional[dict[str, str]] = None,
+    *,
+    restart_running: bool = False,
+    restart_reason: str = "",
+) -> bool:
     if _api_command() is None:
         console.print("[yellow]=> Warning: mn-api not found, skipping.[/yellow]")
         return False
@@ -2723,12 +2919,16 @@ def _start_api_if_installed(runtime_env: Optional[dict[str, str]] = None) -> boo
     watchdog_status = check_status(API_WATCHDOG_PID_FILE)
     child_status = check_status(API_PID_FILE)
     if watchdog_status == 0:
-        if _wait_for_api(api_host, api_port, timeout_seconds=5.0):
+        if _wait_for_api(api_host, api_port, timeout_seconds=5.0) and not restart_running:
             console.print("[yellow]=> REST API watchdog is already running, skipping.[/yellow]")
             return True
+        if restart_running:
+            detail = f" ({restart_reason})" if restart_reason else ""
+            console.print(f"[yellow]=> REST API watchdog is already running; restarting it{detail}.[/yellow]")
+        else:
+            console.print("[yellow]=> REST API watchdog is running, but the API is not responding; restarting it.[/yellow]")
         try:
             watchdog_pid = int(API_WATCHDOG_PID_FILE.read_text().strip())
-            console.print("[yellow]=> REST API watchdog is running, but the API is not responding; restarting it.[/yellow]")
             kill_tree(watchdog_pid)
             time.sleep(1)
         except (ValueError, OSError):
@@ -3159,9 +3359,10 @@ def _build_core_docker_run_command(
     cmd.extend(["-v", f"{host_blob_store_dir}:/opt/mirror_neuron/.mn/blobs"])
     cmd.extend(["-v", f"{host_shared_storage_root}:{runtime_shared_storage_root}"])
     cmd.extend(["-v", f"{host_shared_storage_root}:/opt/mirror_neuron/.mn/shared"])
+    cmd.extend(_docker_worker_bind_args())
     cmd.extend(["-e", f"MN_BLOB_STORE_ROOT={container_blob_store_root}"])
 
-    cmd.append("mirror-neuron-core:latest")
+    cmd.extend(["mirror-neuron-core:latest", *_distributed_core_command()])
     return cmd
 
 def _start_server(
@@ -3187,6 +3388,7 @@ def _start_server(
             if value:
                 env[key] = value
         env = _ensure_runtime_grpc_tokens(env, persist_compose=compose_runtime)
+        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"):
@@ -3201,7 +3403,21 @@ def _start_server(
         env.setdefault("MN_API_PORT", DEFAULT_API_PORT)
         env.setdefault("MN_WEB_UI_HOST", _web_ui_host())
         env.setdefault("MN_WEB_UI_PORT", DEFAULT_WEB_UI_PORT)
-        _start_api_if_installed(env)
+        api_host = str(env.get("MN_API_HOST") or DEFAULT_HOST)
+        api_port = _valid_port_text(str(env.get("MN_API_PORT") or DEFAULT_API_PORT), DEFAULT_API_PORT)
+        api_health = _read_runtime_api_health(api_host, api_port)
+        api_mismatches = _runtime_api_config_mismatches(env, api_health)
+        if api_mismatches:
+            mismatch_details = ", ".join(
+                f"{key} {active or '(unset)'} -> {expected or '(unset)'}"
+                for key, active, expected in api_mismatches
+            )
+            console.print(f"[yellow]=> REST API runtime config changed; restarting API ({mismatch_details}).[/yellow]")
+        _start_api_if_installed(
+            env,
+            restart_running=bool(api_mismatches),
+            restart_reason="runtime config changed",
+        )
         web_ui_available = _start_web_ui_if_installed(env)
         endpoint_snapshot = _write_runtime_endpoints_file(env, web_ui_available=web_ui_available)
         console.print(f"   Runtime endpoints: {RUNTIME_ENDPOINTS_FILE}")
@@ -3266,6 +3482,7 @@ def _start_server(
     if join_handshake:
         _validate_remote_redis_details(join_handshake, ip, network_token)
         env.update(_grpc_tokens_from_handshake(join_handshake))
+    env = _ensure_runtime_api_token(env, persist_compose=compose_runtime)
     reconnecting_joined_node = bool(compose_runtime and not ip and _persisted_join_profile(env))
     if compose_runtime:
         env = _ensure_compose_native_port_settings(env)

{mirrorneuron_cli-1.2.5 → mirrorneuron_cli-1.2.6}/mn_cli/update_cmds.py

@@ -50,6 +50,21 @@ RUN apt-get update && apt-get install -y --no-install-recommends \\
     procps \\
     && rm -rf /var/lib/apt/lists/*
 
+ARG DOCKER_CLI_VERSION=29.2.1
+RUN set -eux; \\
+    arch="$(dpkg --print-architecture)"; \\
+    case "$arch" in \\
+      arm64) docker_target="aarch64" ;; \\
+      amd64) docker_target="x86_64" ;; \\
+      *) echo "unsupported architecture for Docker CLI: $arch" >&2; exit 1 ;; \\
+    esac; \\
+    curl -fLsS -o /tmp/docker-cli.tgz \\
+      "https://download.docker.com/linux/static/stable/${docker_target}/docker-${DOCKER_CLI_VERSION}.tgz"; \\
+    tar -xzf /tmp/docker-cli.tgz -C /tmp docker/docker; \\
+    install -m 0755 /tmp/docker/docker /usr/local/bin/docker; \\
+    rm -rf /tmp/docker /tmp/docker-cli.tgz; \\
+    docker --version
+
 ARG OPENSHELL_VERSION=v0.0.47
 RUN set -eux; \\
     arch="$(dpkg --print-architecture)"; \\

{mirrorneuron_cli-1.2.5 → mirrorneuron_cli-1.2.6}/tests/test_server_cmds.py

@@ -47,6 +47,7 @@ def isolated_mn_cookie_home(mocker, tmp_path, monkeypatch):
     monkeypatch.delenv("MN_GRPC_ADMIN_TOKEN", raising=False)
     monkeypatch.delenv("MN_GRPC_AUTH_TOKEN_FILE", raising=False)
     monkeypatch.delenv("MN_GRPC_ADMIN_TOKEN_FILE", raising=False)
+    monkeypatch.delenv("MN_API_TOKEN", raising=False)
     monkeypatch.delenv("MN_ARTIFACT_AUTH_TOKEN", raising=False)
     monkeypatch.delenv("MN_NODE_GPU", raising=False)
     monkeypatch.delenv("MN_NODE_GPU_COUNT", raising=False)
@@ -64,6 +65,8 @@ def isolated_mn_cookie_home(mocker, tmp_path, monkeypatch):
     monkeypatch.delenv("MN_BLUEPRINT_LOCAL", raising=False)
     monkeypatch.delenv("MN_DOCKER_NETWORK_MODE", raising=False)
     monkeypatch.delenv("MN_DOCKER_NETWORK_NAME", raising=False)
+    monkeypatch.delenv("MN_REDIS_IMAGE", raising=False)
+    monkeypatch.delenv("DOCKER_HOST_SOCKET", raising=False)
     monkeypatch.delenv("MN_NETWORK_JOIN_TOKEN", raising=False)
     state_dir = tmp_path / ".mn"
     log_dir = state_dir / ".logs"
@@ -74,6 +77,7 @@ def isolated_mn_cookie_home(mocker, tmp_path, monkeypatch):
     mocker.patch('mn_cli.server_cmds.BEAM_PID_FILE', pid_dir / "beam.pid")
     mocker.patch('mn_cli.server_cmds.API_PID_FILE', pid_dir / "api.pid")
     mocker.patch('mn_cli.server_cmds.API_WATCHDOG_PID_FILE', pid_dir / "api-watchdog.pid")
+    mocker.patch('mn_cli.server_cmds.API_TOKEN_FILE', state_dir / "api.token")
     mocker.patch('mn_cli.server_cmds.WEB_UI_PID_FILE', pid_dir / "web-ui.pid")
     mocker.patch('mn_cli.server_cmds.WEB_UI_WATCHDOG_PID_FILE', pid_dir / "web-ui-watchdog.pid")
     mocker.patch('mn_cli.server_cmds.BEAM_LOG', log_dir / "beam.log")
@@ -84,6 +88,7 @@ def isolated_mn_cookie_home(mocker, tmp_path, monkeypatch):
     mocker.patch('mn_cli.server_cmds.VENV_DIR', tmp_path / "mn_venv")
     mocker.patch('mn_cli.server_cmds.RUNTIME_COMPOSE_FILE', state_dir / "docker-compose.yml")
     mocker.patch('mn_cli.server_cmds.RUNTIME_COMPOSE_ENV', state_dir / "docker-compose.env")
+    mocker.patch('mn_cli.server_cmds._docker_host_socket', return_value=None)
     mocker.patch('mn_cli.server_cmds.RUNTIME_ENDPOINTS_FILE', state_dir / "runtime-endpoints.json")
     mocker.patch('mn_cli.server_cmds.NETWORK_TOKEN_FILE', state_dir / "network.token")
     mocker.patch('mn_cli.server_cmds.NETWORK_REDIS_ENV_FILE', state_dir / "network-redis.env")
@@ -349,6 +354,30 @@ def test_resolve_grpc_admin_token_ignores_legacy_env(monkeypatch):
 
     assert _resolve_grpc_admin_token() != "legacy-admin-token"
 
+def test_runtime_api_token_is_generated_for_prod_and_persisted(mocker):
+    mocker.patch("mn_cli.server_cmds.secrets.token_hex", return_value="generated-api-token")
+
+    env = server_cmds._ensure_runtime_api_token({"MN_ENV": "prod"})
+
+    assert env["MN_API_TOKEN"] == "generated-api-token"
+    assert server_cmds.API_TOKEN_FILE.read_text().strip() == "generated-api-token"
+    assert server_cmds.API_TOKEN_FILE.stat().st_mode & 0o777 == 0o600
+    assert server_cmds._ensure_runtime_api_token({"MN_ENV": "prod"})["MN_API_TOKEN"] == "generated-api-token"
+
+def test_runtime_api_token_prefers_env_and_persists_compose(mocker, monkeypatch):
+    monkeypatch.setenv("MN_API_TOKEN", "explicit-api-token")
+    compose_file = server_cmds.RUNTIME_COMPOSE_FILE
+    compose_env = server_cmds.RUNTIME_COMPOSE_ENV
+    compose_file.parent.mkdir(parents=True, exist_ok=True)
+    compose_file.write_text("services: {}\n", encoding="utf-8")
+    compose_env.write_text("COMPOSE_PROJECT_NAME=mirror-neuron\n", encoding="utf-8")
+
+    env = server_cmds._ensure_runtime_api_token({"MN_ENV": "prod"}, persist_compose=True)
+
+    assert env["MN_API_TOKEN"] == "explicit-api-token"
+    assert server_cmds.API_TOKEN_FILE.read_text().strip() == "explicit-api-token"
+    assert "MN_API_TOKEN=explicit-api-token" in compose_env.read_text()
+
 def test_start_server_persists_env_grpc_tokens_for_later_cli_process(mocker, monkeypatch):
     monkeypatch.setenv("MN_GRPC_AUTH_TOKEN", "runtime-auth-token")
     monkeypatch.setenv("MN_GRPC_ADMIN_TOKEN", "runtime-admin-token")
@@ -697,6 +726,10 @@ def test_start_network_seed_starts_only_core_and_redis(mocker, tmp_path, monkeyp
     assert any(cmd[:4] == ["docker", "run", "-d", "--name"] and cmd[4] == "mirror-neuron-network-redis" for cmd in commands)
     core_run = next(cmd for cmd in commands if len(cmd) > 4 and cmd[:4] == ["docker", "run", "-d", "--name"] and cmd[4] == "mirror-neuron-network-core")
     assert "mirror-neuron-core:latest" in core_run
+    image_index = core_run.index("mirror-neuron-core:latest")
+    assert core_run[image_index + 1 : image_index + 3] == ["sh", "-c"]
+    assert "epmd_bin=" in core_run[image_index + 3]
+    assert "RELEASE_DISTRIBUTION=name" in core_run[image_index + 3]
     assert "redis:7" not in core_run
     assert core_run.count("-p") == 1
     assert "0.0.0.0:50055:50055" in core_run
@@ -741,6 +774,7 @@ def test_start_network_seed_default_disabled_ignores_stale_named_network(mocker,
     mocker.patch('mn_cli.server_cmds.secrets.token_urlsafe', return_value="worker-token")
     mocker.patch('mn_cli.server_cmds._docker_container_running', return_value=False)
     mocker.patch('mn_cli.server_cmds._port_available_or_owned', return_value=True)
+    mocker.patch('mn_cli.server_cmds._docker_host_socket', return_value=None)
 
     commands = []
 
@@ -782,6 +816,34 @@ def test_start_network_seed_default_disabled_ignores_stale_named_network(mocker,
     assert "MN_DOCKER_NETWORK_MODE=disabled" in core_run
     assert "MN_NODE_NAME=mirror_neuron@192.168.4.173" in core_run
 
+def test_start_network_seed_uses_configured_redis_image(mocker, tmp_path, monkeypatch):
+    monkeypatch.delenv("MN_REDIS_URL", raising=False)
+    monkeypatch.setenv("MN_REDIS_IMAGE", "redis:8.8")
+    token_file = tmp_path / "network.token"
+    mocker.patch('mn_cli.server_cmds.DIR', tmp_path)
+    mocker.patch('mn_cli.server_cmds.NETWORK_TOKEN_FILE', token_file)
+    mocker.patch('mn_cli.server_cmds.NETWORK_REDIS_ENV_FILE', tmp_path / "network-redis.env")
+    mocker.patch('mn_cli.server_cmds.secrets.token_urlsafe', return_value="worker-token")
+    mocker.patch('mn_cli.server_cmds._docker_container_running', return_value=False)
+    mocker.patch('mn_cli.server_cmds._port_available_or_owned', return_value=True)
+    mocker.patch('mn_cli.server_cmds._docker_host_socket', return_value=None)
+
+    commands = []
+
+    def mock_run(cmd, **kwargs):
+        commands.append(cmd)
+        m = mocker.Mock()
+        m.returncode = 0
+        m.stdout = "false\n"
+        return m
+
+    mocker.patch('mn_cli.server_cmds.subprocess.run', side_effect=mock_run)
+
+    _start_network_seed(host="192.168.4.173", grpc_port=50055, dist_port=4500)
+
+    redis_run = next(cmd for cmd in commands if len(cmd) > 4 and cmd[:4] == ["docker", "run", "-d", "--name"] and cmd[4] == "mirror-neuron-network-redis")
+    assert "redis:8.8" in redis_run
+
 def test_start_network_seed_already_exposed_prints_existing_token(mocker):
     output = StringIO()
     mocker.patch('mn_cli.server_cmds.console', Console(file=output, force_terminal=False, width=120))
@@ -896,6 +958,17 @@ def test_sidecar_pid_files_include_legacy_checkout_paths():
     assert (legacy_pid_dir / "web-ui-watchdog.pid", "Web UI watchdog") in server_cmds.web_ui_pid_files()
     assert (legacy_pid_dir / "web-ui.pid", "Web UI") in server_cmds.web_ui_pid_files()
 
+def test_persist_compose_cluster_node_appends_remote_once():
+    server_cmds.RUNTIME_COMPOSE_ENV.parent.mkdir(parents=True, exist_ok=True)
+    server_cmds.RUNTIME_COMPOSE_ENV.write_text("MN_CLUSTER_NODES=mirror_neuron@local\n")
+
+    server_cmds._persist_compose_cluster_node("mirror_neuron@worker")
+    server_cmds._persist_compose_cluster_node("mirror_neuron@worker")
+
+    env = server_cmds._read_env_file(server_cmds.RUNTIME_COMPOSE_ENV)
+    assert env["MN_CLUSTER_NODES"] == "mirror_neuron@local,mirror_neuron@worker"
+
+
 def test_add_node_uses_handshake_and_local_core(mocker, tmp_path, capsys):
     import mn_sdk
     import mn_cli.shared
@@ -1136,14 +1209,9 @@ def test_join_network_configures_worker_redis_replica(mocker, tmp_path, capsys):
         "192.168.4.20",
         56380,
         worker_password,
-        ("CONFIG", "SET", "requirepass", primary_password),
-    ) in redis_calls
-    assert (
-        "192.168.4.20",
-        56380,
-        primary_password,
         ("REPLICAOF", "192.168.4.99", "56379"),
     ) in redis_calls
+    assert not any(call[3][:3] == ("CONFIG", "SET", "requirepass") for call in redis_calls)
     assert (
         "192.168.4.99",
         56379,
@@ -1245,6 +1313,7 @@ def test_start_server_already_running(mocker, tmp_path):
     mocker.patch('mn_cli.server_cmds.API_PID_FILE', tmp_path / "api.pid")
     (tmp_path / "api.pid").write_text("1234")
     mocker.patch('mn_cli.server_cmds.os.kill') # check_status returns 0
+    mocker.patch('mn_cli.server_cmds._read_runtime_api_health', return_value=None)
 
     mock_container_tokens = mocker.patch(
         'mn_cli.server_cmds._runtime_grpc_tokens_from_running_container',
@@ -1266,6 +1335,54 @@ def test_start_server_already_running(mocker, tmp_path):
     mock_write_endpoints.assert_called_once()
     mock_print_endpoints.assert_called_once_with(None, True)
 
+def test_start_server_restarts_existing_api_when_runtime_blueprint_env_changes(mocker, tmp_path, monkeypatch):
+    mocker.patch('mn_cli.server_cmds.API_PID_FILE', tmp_path / "api.pid")
+    (tmp_path / "api.pid").write_text("1234")
+    mocker.patch('mn_cli.server_cmds.os.kill') # check_status returns 0
+
+    compose_file = server_cmds.RUNTIME_COMPOSE_FILE
+    compose_env = server_cmds.RUNTIME_COMPOSE_ENV
+    compose_file.parent.mkdir(parents=True, exist_ok=True)
+    compose_file.write_text("services: {}\n", encoding="utf-8")
+    compose_env.write_text(
+        "COMPOSE_PROJECT_NAME=mirror-neuron\n"
+        "MN_BLUEPRINT_SOURCE=github\n"
+        "MN_BLUEPRINT_REPO=https://github.com/MirrorNeuronLab/mn-blueprints.git\n"
+        "MN_RUNS_ROOT=/tmp/mn-runs\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setenv("MN_BLUEPRINT_SOURCE", "github")
+    monkeypatch.setenv("MN_BLUEPRINT_REPO", "https://github.com/MirrorNeuronLab/otterdesk-blueprints")
+    monkeypatch.setenv("MN_RUNS_ROOT", "/tmp/otterdesk-runs")
+    mocker.patch('mn_cli.server_cmds._runtime_grpc_tokens_from_running_container', return_value={})
+    mocker.patch('mn_cli.server_cmds._docker_container_running', return_value=True)
+    mocker.patch(
+        'mn_cli.server_cmds._read_runtime_api_health',
+        return_value={
+            "status": "ok",
+            "blueprint_source": "github",
+            "blueprint_repo": "https://github.com/MirrorNeuronLab/mn-blueprints.git",
+            "active_blueprint_location": "https://github.com/MirrorNeuronLab/mn-blueprints.git",
+            "runs_root": "/tmp/mn-runs",
+        },
+    )
+    start_api = mocker.patch('mn_cli.server_cmds._start_api_if_installed')
+    mocker.patch('mn_cli.server_cmds._start_web_ui_if_installed', return_value=False)
+    mocker.patch('mn_cli.server_cmds._write_runtime_endpoints_file', return_value={"api": {}})
+    mocker.patch('mn_cli.server_cmds._print_service_endpoints')
+
+    _start_server()
+
+    start_api.assert_called_once()
+    api_env = start_api.call_args.args[0]
+    assert start_api.call_args.kwargs["restart_running"] is True
+    assert start_api.call_args.kwargs["restart_reason"] == "runtime config changed"
+    assert api_env["MN_BLUEPRINT_REPO"] == "https://github.com/MirrorNeuronLab/otterdesk-blueprints"
+    assert api_env["MN_RUNS_ROOT"] == "/tmp/otterdesk-runs"
+    compose_text = compose_env.read_text()
+    assert "MN_BLUEPRINT_REPO=https://github.com/MirrorNeuronLab/otterdesk-blueprints" in compose_text
+    assert "MN_RUNS_ROOT=/tmp/otterdesk-runs" in compose_text
+
 def test_start_server_join_compose_imports_primary_grpc_tokens(mocker, tmp_path):
     compose_file = server_cmds.RUNTIME_COMPOSE_FILE
     compose_env = server_cmds.RUNTIME_COMPOSE_ENV
@@ -2209,6 +2326,10 @@ def test_start_server_passes_slack_env_to_docker(mocker, tmp_path, monkeypatch):
     _start_server()
 
     docker_run = next(cmd for cmd in commands if cmd[:3] == ["docker", "run", "-d"])
+    image_index = docker_run.index("mirror-neuron-core:latest")
+    assert docker_run[image_index + 1 : image_index + 3] == ["sh", "-c"]
+    assert "epmd_bin=" in docker_run[image_index + 3]
+    assert "RELEASE_DISTRIBUTION=name" in docker_run[image_index + 3]
     cookie_env = next(value for flag, value in zip(docker_run, docker_run[1:]) if flag == "-e" and value.startswith("MN_COOKIE="))
     auth_env = next(value for flag, value in zip(docker_run, docker_run[1:]) if flag == "-e" and value.startswith("MN_GRPC_AUTH_TOKEN="))
     auth_file_env = next(
@@ -2244,6 +2365,48 @@ def test_start_server_passes_slack_env_to_docker(mocker, tmp_path, monkeypatch):
         docker_run.index("SLACK_DEFAULT_CHANNEL") - 1 : docker_run.index("SLACK_DEFAULT_CHANNEL") + 1
     ]
 
+def test_start_server_mounts_docker_worker_socket_and_linux_cli(mocker, tmp_path, monkeypatch):
+    mocker.patch('mn_cli.server_cmds.API_PID_FILE', tmp_path / "api.pid")
+    mocker.patch('mn_cli.server_cmds.WEB_UI_DIRS', ())
+    docker_socket = tmp_path / "docker.sock"
+    docker_socket.touch()
+    host_docker = tmp_path / "docker"
+    host_docker.write_text("#!/bin/sh\n", encoding="utf-8")
+    mocker.patch('mn_cli.server_cmds._docker_host_socket', return_value=docker_socket)
+    mocker.patch('mn_cli.server_cmds.shutil.which', return_value=str(host_docker))
+    monkeypatch.setattr(sys, "platform", "linux")
+
+    commands = []
+
+    def mock_run(cmd, **kwargs):
+        commands.append(cmd)
+        m = mocker.Mock()
+        m.stdout = "false\n"
+        return m
+
+    mocker.patch('mn_cli.server_cmds.subprocess.run', side_effect=mock_run)
+    mocker.patch('mn_cli.server_cmds.time.sleep')
+    mocker.patch('mn_cli.server_cmds.PID_DIR', tmp_path / ".pids")
+    mocker.patch('mn_cli.server_cmds.LOG_DIR', tmp_path / ".logs")
+    mocker.patch('mn_cli.server_cmds.BEAM_LOG', tmp_path / "beam.log")
+    mocker.patch('mn_cli.server_cmds.API_LOG', tmp_path / "api.log")
+    mocker.patch('mn_cli.server_cmds.VENV_DIR', tmp_path)
+
+    class UnameMock:
+        sysname = "Linux"
+
+    mocker.patch('mn_cli.server_cmds.os.uname', return_value=UnameMock())
+
+    _start_server()
+
+    docker_run = next(cmd for cmd in commands if cmd[:3] == ["docker", "run", "-d"])
+    assert ["-v", f"{docker_socket}:/var/run/docker.sock:rw"] == docker_run[
+        docker_run.index(f"{docker_socket}:/var/run/docker.sock:rw") - 1 : docker_run.index(f"{docker_socket}:/var/run/docker.sock:rw") + 1
+    ]
+    assert ["-v", f"{host_docker}:/usr/local/bin/docker:ro"] == docker_run[
+        docker_run.index(f"{host_docker}:/usr/local/bin/docker:ro") - 1 : docker_run.index(f"{host_docker}:/usr/local/bin/docker:ro") + 1
+    ]
+
 def test_detach_local_docker_node_stops_compose_core_for_local_alias(mocker, tmp_path):
     compose_file = tmp_path / "docker-compose.yml"
     compose_env = tmp_path / "docker-compose.env"
@@ -2378,6 +2541,43 @@ def test_start_api_restarts_untracked_healthy_instance_under_watchdog(mocker, tm
         call("localhost", "54001", timeout_seconds=10.0),
     ]
 
+def test_start_api_restarts_running_watchdog_when_requested(mocker, tmp_path):
+    api_bin = tmp_path / "mn_venv" / "bin" / "mn-api"
+    api_bin.parent.mkdir(parents=True)
+    api_bin.write_text("#!/bin/sh\n")
+    api_pid = tmp_path / "api.pid"
+    watchdog_pid = tmp_path / "api-watchdog.pid"
+    api_pid.write_text("1234")
+    watchdog_pid.write_text("5678")
+
+    mocker.patch('mn_cli.server_cmds.VENV_DIR', tmp_path / "mn_venv")
+    mocker.patch('mn_cli.server_cmds.API_PID_FILE', api_pid)
+    mocker.patch('mn_cli.server_cmds.API_WATCHDOG_PID_FILE', watchdog_pid)
+    mocker.patch('mn_cli.server_cmds.API_LOG', tmp_path / "api.log")
+    mocker.patch('mn_cli.server_cmds.API_WATCHDOG_LOG', tmp_path / "api-watchdog.log")
+    mocker.patch('mn_cli.server_cmds.os.kill') # check_status returns running
+    mocker.patch('mn_cli.server_cmds.time.sleep')
+    kill = mocker.patch('mn_cli.server_cmds.kill_tree')
+    mock_wait = mocker.patch('mn_cli.server_cmds._wait_for_api', side_effect=[True, True, True])
+    stop_matching = mocker.patch('mn_cli.server_cmds.stop_matching_sidecar_processes', return_value=False)
+    mock_popen = mocker.patch('mn_cli.server_cmds.subprocess.Popen')
+    mock_popen.return_value.pid = 54001
+
+    assert _start_api_if_installed(
+        {"MN_API_HOST": "localhost", "MN_API_PORT": "54001"},
+        restart_running=True,
+        restart_reason="runtime config changed",
+    ) is True
+
+    assert kill.call_args_list == [call(5678)]
+    stop_matching.assert_called_once_with("mn-api", "REST API")
+    mock_popen.assert_called_once()
+    assert mock_wait.call_args_list == [
+        call("localhost", "54001", timeout_seconds=5.0),
+        call("localhost", "54001", timeout_seconds=1.0),
+        call("localhost", "54001", timeout_seconds=10.0),
+    ]
+
 def test_start_web_ui_if_installed(mocker, tmp_path):
     web_ui_dir = tmp_path / "web-ui"
     (web_ui_dir / "dist").mkdir(parents=True)

{mirrorneuron_cli-1.2.5 → mirrorneuron_cli-1.2.6}/tests/test_update_cmds.py

@@ -221,6 +221,8 @@ def test_prepare_core_docker_context_copies_release_and_writes_dockerfile(tmp_pa
     assert copied_binary.read_text(encoding="utf-8") == "run\n"
     dockerfile = (context_dir / "Dockerfile").read_text(encoding="utf-8")
     assert "COPY mirror_neuron /opt/mirror_neuron" in dockerfile
+    assert "ARG DOCKER_CLI_VERSION=29.2.1" in dockerfile
+    assert "download.docker.com/linux/static/stable" in dockerfile
     assert 'CMD ["bin/mirror_neuron", "foreground"]' in dockerfile