mirrorneuron-cli 1.1.3__tar.gz → 1.1.4__tar.gz

{mirrorneuron_cli-1.1.3 → mirrorneuron_cli-1.1.4}/PKG-INFO

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

{mirrorneuron_cli-1.1.3 → mirrorneuron_cli-1.1.4}/mirrorneuron_cli.egg-info/PKG-INFO

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

{mirrorneuron_cli-1.1.3 → mirrorneuron_cli-1.1.4}/mn_cli/libs/blueprint_cmds.py

@@ -2,6 +2,7 @@ import os
 import json
 import shutil
 import subprocess
+import sys
 import time
 from pathlib import Path
 from typing import Any, Optional
@@ -40,6 +41,7 @@ from mn_cli.libs.blueprint_repository import (
 )
 from mn_cli.shared import console, logger
 from mn_cli.libs.run_cmds import run_bundle as _run_bundle
+from mn_cli.libs.run_manifest import load_blueprint_config as _load_blueprint_config
 
 blueprint_app = typer.Typer(help="Manage and run MirrorNeuron blueprints")
 _PATCH_COMPAT = (subprocess, _git_checkout, _git_fetch)
@@ -128,6 +130,7 @@ def _run_resolved_blueprint(
     if revision:
         console.print(f"Blueprint revision: {revision}")
     bundle_path = _prepare_blueprint_bundle_for_run(blueprint_dir, manifest, shared_run_id)
+    config_overrides = _collect_init_config_review_overrides(bundle_path, manifest)
     _run_bundle(
         str(bundle_path),
         follow_seconds=follow_seconds,
@@ -141,6 +144,7 @@ def _run_resolved_blueprint(
             "blueprint_revision": revision,
             "blueprint_source": source_label,
         },
+        config_overrides=config_overrides,
     )
 
 
@@ -171,6 +175,116 @@ def _run_local_blueprint_target(
     return True
 
 
+def _collect_init_config_review_overrides(
+    bundle_path: Path,
+    manifest: dict[str, Any],
+) -> dict[str, Any] | None:
+    review = _manifest_init_config_review(manifest)
+    if not isinstance(review, dict):
+        return None
+    fields = review.get("fields")
+    if not isinstance(fields, list) or not fields:
+        return None
+    if _env_flag("MN_BLUEPRINT_SKIP_INIT_CONFIG_REVIEW"):
+        return None
+    if not sys.stdin.isatty():
+        if review.get("required") is True:
+            console.print("[yellow]Blueprint config review requested; keeping current config in this non-interactive run.[/yellow]")
+        return None
+
+    config = _load_blueprint_config(bundle_path) or {}
+    overrides: dict[str, Any] = {}
+    console.print("[bold]Review blueprint config before launch[/bold]")
+    instruction = review.get("instruction")
+    if isinstance(instruction, str) and instruction.strip():
+        console.print(instruction.strip())
+
+    for raw_field in fields:
+        if not isinstance(raw_field, dict):
+            continue
+        path = raw_field.get("path")
+        if not isinstance(path, str) or not path.strip():
+            continue
+        path = path.strip()
+        label = str(raw_field.get("label") or path)
+        description = raw_field.get("description")
+        current = _config_path_get(config, path)
+        fallback = raw_field.get("default")
+        default_value = current if current is not None else fallback
+        if isinstance(description, str) and description.strip():
+            console.print(f"{label}: {description.strip()}")
+        if default_value is None:
+            response = typer.prompt(label, default="", show_default=False)
+            if response == "":
+                continue
+        else:
+            response = typer.prompt(label, default=str(default_value), show_default=True)
+        parsed = _parse_review_value(response, default_value)
+        if parsed != current:
+            _config_path_set(overrides, path, parsed)
+
+    return overrides or None
+
+
+def _manifest_init_config_review(manifest: dict[str, Any]) -> Any:
+    if "init_config_review" in manifest:
+        return manifest.get("init_config_review")
+    metadata = manifest.get("metadata")
+    if isinstance(metadata, dict):
+        return metadata.get("init_config_review")
+    return None
+
+
+def _config_path_get(config: dict[str, Any], dotted_path: str) -> Any:
+    cursor: Any = config
+    for part in dotted_path.split("."):
+        if not isinstance(cursor, dict) or part not in cursor:
+            return None
+        cursor = cursor[part]
+    return cursor
+
+
+def _config_path_set(config: dict[str, Any], dotted_path: str, value: Any) -> None:
+    cursor = config
+    parts = [part for part in dotted_path.split(".") if part]
+    for part in parts[:-1]:
+        next_value = cursor.get(part)
+        if not isinstance(next_value, dict):
+            next_value = {}
+            cursor[part] = next_value
+        cursor = next_value
+    if parts:
+        cursor[parts[-1]] = value
+
+
+def _parse_review_value(value: str, default_value: Any) -> Any:
+    if isinstance(default_value, bool):
+        return value.strip().lower() in {"1", "true", "yes", "y", "on"}
+    if isinstance(default_value, int) and not isinstance(default_value, bool):
+        try:
+            return int(value)
+        except ValueError:
+            return value
+    if isinstance(default_value, float):
+        try:
+            return float(value)
+        except ValueError:
+            return value
+    if isinstance(default_value, (dict, list)):
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return value
+    return value
+
+
+def _env_flag(name: str) -> bool:
+    value = os.environ.get(name)
+    if value is None:
+        return False
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
 def _print_run_table(runs: list[dict[str, Any]]) -> None:
     if not runs:
         console.print("[yellow]No blueprint runs found.[/yellow]")

{mirrorneuron_cli-1.1.3 → mirrorneuron_cli-1.1.4}/mn_cli/libs/run_cmds.py

@@ -331,6 +331,7 @@ def run_bundle(
     follow_seconds: Optional[float] = None,
     env_overrides: Optional[dict[str, str]] = None,
     submission_metadata: Optional[dict[str, Any]] = None,
+    config_overrides: Optional[dict[str, Any]] = None,
 ):
     """Run a bundle after applying optional runtime metadata and environment."""
     try:
@@ -374,6 +375,7 @@ def run_bundle(
             manifest_dict,
             env_overrides=env_overrides,
             submission_metadata=submission_metadata,
+            config_overrides=config_overrides,
         )
         manifest = json.dumps(manifest_dict)
 

mirrorneuron_cli-1.1.4/mn_cli/libs/run_manifest.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+
+def prepare_manifest_for_submission(
+    bundle_dir: Path,
+    manifest_dict: dict[str, Any],
+    *,
+    env_overrides: Optional[dict[str, str]] = None,
+    submission_metadata: Optional[dict[str, Any]] = None,
+    config_overrides: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    prepared = json.loads(json.dumps(manifest_dict))
+    config = load_blueprint_config(bundle_dir, config_overrides=config_overrides)
+    if config is not None:
+        apply_manifest_config_bindings(prepared, config)
+    runtime_env = blueprint_runtime_environment(
+        bundle_dir,
+        config=config,
+        config_overrides=config_overrides,
+    )
+    runtime_env.update({key: str(value) for key, value in (env_overrides or {}).items() if value is not None})
+    if runtime_env:
+        inject_node_environment(prepared, runtime_env)
+    metadata = dict(submission_metadata or {})
+    if metadata:
+        prepared.setdefault("metadata", {}).setdefault("mn_cli", {}).update(metadata)
+    return prepared
+
+
+def blueprint_runtime_environment(
+    bundle_dir: Path,
+    *,
+    config: Optional[dict[str, Any]] = None,
+    config_overrides: Optional[dict[str, Any]] = None,
+) -> dict[str, str]:
+    env: dict[str, str] = {}
+    if config is None:
+        config = load_blueprint_config(bundle_dir, config_overrides=config_overrides)
+    if config is not None:
+        env["MN_BLUEPRINT_CONFIG_JSON"] = json.dumps(config, sort_keys=True)
+        projected_config = load_blueprint_config_overwrites(bundle_dir, config_overrides=config_overrides)
+        if projected_config is not None:
+            env.update(config_to_environment(projected_config))
+
+    scenario_path = bundle_dir / "scenario.json"
+    if scenario_path.exists():
+        env["MN_BLUEPRINT_SCENARIO_JSON"] = scenario_path.read_text(encoding="utf-8")
+    return env
+
+
+def apply_manifest_config_bindings(manifest: dict[str, Any], config: dict[str, Any]) -> None:
+    bindings = config.get("manifest_config_bindings") or []
+    if not isinstance(bindings, list):
+        return
+    for binding in bindings:
+        if not isinstance(binding, dict):
+            continue
+        config_path = binding.get("config_path") or binding.get("from")
+        manifest_path = binding.get("manifest_path") or binding.get("to")
+        if not isinstance(config_path, str) or not isinstance(manifest_path, str):
+            continue
+        value = config_path_get(config, config_path)
+        if value is None and not binding.get("allow_null", False):
+            continue
+        if binding.get("stringify") is True:
+            value = str(value).lower() if isinstance(value, bool) else str(value)
+        set_manifest_path(manifest, manifest_path, value)
+
+
+def config_to_environment(config: dict[str, Any]) -> dict[str, str]:
+    env: dict[str, str] = {}
+    for path, names in (
+        ("video_source.uri", ("VIDEO_SOURCE_URI",)),
+        ("video_source.transport", ("VIDEO_SOURCE_TRANSPORT",)),
+        ("video_source.codec", ("VIDEO_SOURCE_CODEC",)),
+        ("video_source.camera_id", ("VIDEO_SOURCE_CAMERA_ID",)),
+        ("video_source.frame_sample_seconds", ("FRAME_SAMPLE_SECONDS",)),
+        ("video_source.frame_jpeg_max_width", ("FRAME_JPEG_MAX_WIDTH",)),
+        ("vl_model.base_url", ("VL_MODEL_BASE_URL", "OLLAMA_BASE_URL")),
+        ("vl_model.model", ("VL_MODEL_NAME", "OLLAMA_MODEL")),
+        ("vl_model.timeout_seconds", ("VL_MODEL_TIMEOUT_SECONDS", "OLLAMA_TIMEOUT_SECONDS")),
+        ("vl_model.temperature", ("VL_MODEL_TEMPERATURE", "OLLAMA_TEMPERATURE")),
+        ("llm.api_base", ("MN_LLM_API_BASE", "LITELLM_API_BASE")),
+        ("llm.model", ("MN_LLM_MODEL", "LITELLM_MODEL")),
+        ("llm.timeout_seconds", ("MN_LLM_TIMEOUT_SECONDS", "LITELLM_TIMEOUT_SECONDS")),
+        ("llm.max_tokens", ("MN_LLM_MAX_TOKENS", "LITELLM_MAX_TOKENS")),
+        ("llm.num_retries", ("MN_LLM_NUM_RETRIES", "LITELLM_NUM_RETRIES")),
+    ):
+        value = config_path_get(config, path)
+        if value is None:
+            continue
+        for name in names:
+            env[name] = str(value)
+    return env
+
+
+def set_manifest_path(target: Any, dotted_path: str, value: Any) -> None:
+    parts = [part for part in dotted_path.split(".") if part]
+    _set_path(target, parts, value)
+
+
+def _set_path(cursor: Any, parts: list[str], value: Any) -> None:
+    if not parts:
+        return
+    part = parts[0]
+    rest = parts[1:]
+
+    if isinstance(cursor, list):
+        for item in _list_targets(cursor, part):
+            _set_path(item, rest, value)
+        return
+
+    if not isinstance(cursor, dict):
+        return
+
+    if len(parts) == 1:
+        cursor[part] = value
+        return
+
+    next_value = cursor.get(part)
+    if isinstance(next_value, list):
+        _set_path(next_value, rest, value)
+        return
+    if not isinstance(next_value, dict):
+        next_value = {}
+        cursor[part] = next_value
+    _set_path(next_value, rest, value)
+
+
+def _list_targets(items: list[Any], selector: str) -> list[Any]:
+    if selector == "*":
+        return [item for item in items if isinstance(item, dict)]
+    if selector.isdigit():
+        index = int(selector)
+        if 0 <= index < len(items):
+            return [items[index]]
+        return []
+    if selector.endswith("*"):
+        prefix = selector[:-1]
+        return [
+            item
+            for item in items
+            if isinstance(item, dict) and str(item.get("node_id") or "").startswith(prefix)
+        ]
+    return [
+        item
+        for item in items
+        if isinstance(item, dict) and (item.get("node_id") == selector or item.get("edge_id") == selector)
+    ]
+
+
+def config_path_get(config: dict[str, Any], dotted_path: str) -> Any:
+    cursor: Any = config
+    for part in dotted_path.split("."):
+        if not isinstance(cursor, dict) or part not in cursor:
+            return None
+        cursor = cursor[part]
+    return cursor
+
+
+def load_blueprint_config(
+    bundle_dir: Path,
+    *,
+    config_overrides: Optional[dict[str, Any]] = None,
+) -> dict[str, Any] | None:
+    config: dict[str, Any] = {}
+    loaded = False
+    for path in (
+        bundle_dir / "config" / "default.json",
+        bundle_dir / "config" / "overwrite.json",
+    ):
+        if path.exists():
+            config = deep_merge(config, read_json_object(path))
+            loaded = True
+    if config_overrides:
+        config = deep_merge(config, config_overrides)
+        loaded = True
+    return config if loaded else None
+
+
+def load_blueprint_config_overwrites(
+    bundle_dir: Path,
+    *,
+    config_overrides: Optional[dict[str, Any]] = None,
+) -> dict[str, Any] | None:
+    config: dict[str, Any] = {}
+    loaded = False
+    overwrite_path = bundle_dir / "config" / "overwrite.json"
+    if overwrite_path.exists():
+        config = deep_merge(config, read_json_object(overwrite_path))
+        loaded = True
+    if config_overrides:
+        config = deep_merge(config, config_overrides)
+        loaded = True
+    return config if loaded else None
+
+
+def inject_node_environment(manifest: dict[str, Any], env: dict[str, str]) -> None:
+    for node in manifest.get("nodes") or []:
+        if not isinstance(node, dict):
+            continue
+        config = node.setdefault("config", {})
+        if not isinstance(config, dict):
+            continue
+        environment = config.setdefault("environment", {})
+        if not isinstance(environment, dict):
+            continue
+        environment.update(env)
+        add_mn_llm_aliases(environment)
+
+
+def add_mn_llm_aliases(environment: dict[str, Any]) -> None:
+    for legacy, primary in (
+        ("LITELLM_MODEL", "MN_LLM_MODEL"),
+        ("LITELLM_API_BASE", "MN_LLM_API_BASE"),
+        ("LITELLM_API_KEY", "MN_LLM_API_KEY"),
+        ("LITELLM_TIMEOUT_SECONDS", "MN_LLM_TIMEOUT_SECONDS"),
+        ("LITELLM_MAX_TOKENS", "MN_LLM_MAX_TOKENS"),
+        ("LITELLM_NUM_RETRIES", "MN_LLM_NUM_RETRIES"),
+        ("LITELLM_RETRY_BACKOFF_SECONDS", "MN_LLM_RETRY_BACKOFF_SECONDS"),
+    ):
+        if primary not in environment and legacy in environment:
+            environment[primary] = environment[legacy]
+
+
+def run_mode_label(manifest: dict) -> str:
+    is_live = manifest.get("daemon") is True or manifest.get("policies", {}).get("stream_mode") == "live"
+    if is_live and manifest.get("daemon") is True:
+        return "Live daemon"
+    if is_live:
+        return "Live"
+    return "Batch"
+
+
+def read_json_object(path: Path) -> dict[str, Any]:
+    decoded = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(decoded, dict):
+        raise ValueError(f"{path} must contain a JSON object")
+    return decoded
+
+
+def deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    result = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(result.get(key), dict):
+            result[key] = deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result

{mirrorneuron_cli-1.1.3 → mirrorneuron_cli-1.1.4}/tests/test_run_cmds.py

@@ -124,7 +124,8 @@ def test_run_injects_blueprint_config_scenario_and_run_id(mocker, tmp_path):
     }))
     config_dir = bundle_dir / "config"
     config_dir.mkdir()
-    (config_dir / "default.json").write_text(json.dumps({"identity": {"blueprint_id": "bp-1"}}))
+    (config_dir / "default.json").write_text(json.dumps({"identity": {"blueprint_id": "bp-1"}, "video_source": {"uri": "default"}}))
+    (config_dir / "overwrite.json").write_text(json.dumps({"video_source": {"uri": "overwrite"}}))
     (bundle_dir / "scenario.json").write_text(json.dumps({"blueprint_id": "bp-1", "metrics": [], "actions": []}))
 
     result = runner.invoke(app, ["run", str(bundle_dir)])
@@ -132,7 +133,10 @@ def test_run_injects_blueprint_config_scenario_and_run_id(mocker, tmp_path):
     assert result.exit_code == 0
     manifest = json.loads(mock_submit.call_args.args[0])
     env = manifest["nodes"][0]["config"]["environment"]
-    assert json.loads(env["MN_BLUEPRINT_CONFIG_JSON"])["identity"]["blueprint_id"] == "bp-1"
+    injected_config = json.loads(env["MN_BLUEPRINT_CONFIG_JSON"])
+    assert injected_config["identity"]["blueprint_id"] == "bp-1"
+    assert injected_config["video_source"]["uri"] == "overwrite"
+    assert env["VIDEO_SOURCE_URI"] == "overwrite"
     assert json.loads(env["MN_BLUEPRINT_SCENARIO_JSON"])["blueprint_id"] == "bp-1"
     assert "MN_BLUEPRINT_PRODUCT_JSON" not in env
     assert env["MN_LLM_MODEL"] == "ollama/nemotron3:33b"

mirrorneuron_cli-1.1.4/tests/test_run_helpers.py

@@ -0,0 +1,155 @@
+import json
+
+import pytest
+
+from mn_cli.libs.run_logs import JobLogWriter, materialize_sent_email_copy
+from mn_cli.libs.run_manifest import (
+    apply_manifest_config_bindings,
+    load_blueprint_config,
+    prepare_manifest_for_submission,
+)
+
+
+def test_prepare_manifest_for_submission_merges_runtime_env_and_metadata(tmp_path):
+    bundle_dir = tmp_path / "bundle"
+    bundle_dir.mkdir()
+    config_dir = bundle_dir / "config"
+    config_dir.mkdir()
+    (config_dir / "default.json").write_text(json.dumps({
+        "identity": {"blueprint_id": "bp"},
+        "vl_model": {"model": "default"},
+        "manifest_config_bindings": [
+            {
+                "config_path": "vl_model.model",
+                "manifest_path": "nodes.worker.config.environment.CUSTOM_MODEL",
+            }
+        ],
+    }))
+    (config_dir / "overwrite.json").write_text(json.dumps({"vl_model": {"model": "overwrite"}}))
+
+    manifest = {
+        "nodes": [
+            {
+                "node_id": "worker",
+                "config": {
+                    "environment": {
+                        "LITELLM_MODEL": "ollama/test",
+                        "MN_LLM_API_KEY": "kept",
+                    }
+                },
+            }
+        ]
+    }
+
+    prepared = prepare_manifest_for_submission(
+        bundle_dir,
+        manifest,
+        env_overrides={"MN_RUN_ID": "run-1"},
+        submission_metadata={"blueprint_id": "bp"},
+        config_overrides={"vl_model": {"base_url": "http://local"}},
+    )
+
+    env = prepared["nodes"][0]["config"]["environment"]
+    injected_config = json.loads(env["MN_BLUEPRINT_CONFIG_JSON"])
+    assert injected_config["identity"]["blueprint_id"] == "bp"
+    assert injected_config["vl_model"] == {"model": "overwrite", "base_url": "http://local"}
+    assert env["VL_MODEL_NAME"] == "overwrite"
+    assert env["OLLAMA_MODEL"] == "overwrite"
+    assert env["VL_MODEL_BASE_URL"] == "http://local"
+    assert env["CUSTOM_MODEL"] == "overwrite"
+    assert env["MN_RUN_ID"] == "run-1"
+    assert env["MN_LLM_MODEL"] == "ollama/test"
+    assert env["MN_LLM_API_KEY"] == "kept"
+    assert prepared["metadata"]["mn_cli"]["blueprint_id"] == "bp"
+
+
+def test_blueprint_config_ignores_misnamed_overwrite_file(tmp_path):
+    bundle_dir = tmp_path / "bundle"
+    config_dir = bundle_dir / "config"
+    config_dir.mkdir(parents=True)
+    (config_dir / "default.json").write_text(json.dumps({"vl_model": {"model": "default"}}))
+    (config_dir / "overwrites.json").write_text(json.dumps({"vl_model": {"model": "wrong-name"}}))
+
+    config = load_blueprint_config(bundle_dir)
+
+    assert config == {"vl_model": {"model": "default"}}
+
+
+@pytest.mark.parametrize("payload", ["[]", "{bad json"])
+def test_blueprint_config_rejects_invalid_overwrite_data_format(tmp_path, payload):
+    bundle_dir = tmp_path / "bundle"
+    config_dir = bundle_dir / "config"
+    config_dir.mkdir(parents=True)
+    (config_dir / "default.json").write_text(json.dumps({"vl_model": {"model": "default"}}))
+    (config_dir / "overwrite.json").write_text(payload)
+
+    with pytest.raises((json.JSONDecodeError, ValueError)):
+        load_blueprint_config(bundle_dir)
+
+
+def test_manifest_config_bindings_ignore_wrong_names():
+    manifest = {
+        "nodes": [
+            {
+                "node_id": "worker",
+                "config": {"environment": {"CUSTOM_MODEL": "keep"}},
+            }
+        ]
+    }
+    config = {
+        "vl_model": {"model": "overwrite"},
+        "manifest_config_bindings": [
+            {
+                "config_path": "vl_model.wrong_name",
+                "manifest_path": "nodes.worker.config.environment.CUSTOM_MODEL",
+            },
+            {
+                "config_path": "vl_model.model",
+                "manifest_path": "nodes.missing_worker.config.environment.NEW_MODEL",
+            },
+        ],
+    }
+
+    apply_manifest_config_bindings(manifest, config)
+
+    env = manifest["nodes"][0]["config"]["environment"]
+    assert env == {"CUSTOM_MODEL": "keep"}
+
+
+def test_job_log_writer_deduplicates_events_and_records_web_ui_once():
+    writer = JobLogWriter("unit-run-helper")
+    event = {
+        "timestamp": "2026-05-01T00:00:00Z",
+        "type": "custom",
+        "payload": {"message_id": "m1", "web_ui": {"url": "http://localhost:1"}},
+    }
+
+    assert writer.write_event(event) is True
+    assert writer.write_event(event) is False
+    assert writer.record_web_ui_url(event) == "http://localhost:1"
+    assert writer.record_web_ui_url(event) is None
+
+
+def test_materialize_sent_email_copy_uses_safe_host_paths(tmp_path):
+    materialize_sent_email_copy(
+        tmp_path,
+        {
+            "provider_id": "id/with spaces",
+            "sent_email_copy": {
+                "html_path": "../unsafe.html",
+                "text_content": "plain",
+                "html_content": "<p>Hello</p>",
+                "metadata": {"provider": "test"},
+            },
+        },
+    )
+
+    email_dir = tmp_path / "sent_emails"
+    assert (email_dir / "unsafe.html").read_text() == "<p>Hello</p>"
+    metadata = json.loads((email_dir / "id-with-spaces.json").read_text())
+    assert metadata["provider"] == "test"
+    assert PathLikeName(metadata["host_html_path"]) == "unsafe.html"
+
+
+def PathLikeName(path: str) -> str:
+    return path.rsplit("/", 1)[-1]

mirrorneuron_cli-1.1.3/mn_cli/libs/run_manifest.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any, Optional
-
-
-def prepare_manifest_for_submission(
-    bundle_dir: Path,
-    manifest_dict: dict[str, Any],
-    *,
-    env_overrides: Optional[dict[str, str]] = None,
-    submission_metadata: Optional[dict[str, Any]] = None,
-) -> dict[str, Any]:
-    prepared = json.loads(json.dumps(manifest_dict))
-    runtime_env = blueprint_runtime_environment(bundle_dir)
-    runtime_env.update({key: str(value) for key, value in (env_overrides or {}).items() if value is not None})
-    if runtime_env:
-        inject_node_environment(prepared, runtime_env)
-    metadata = dict(submission_metadata or {})
-    if metadata:
-        prepared.setdefault("metadata", {}).setdefault("mn_cli", {}).update(metadata)
-    return prepared
-
-
-def blueprint_runtime_environment(bundle_dir: Path) -> dict[str, str]:
-    env: dict[str, str] = {}
-    for filename, env_name in (
-        ("config/default.json", "MN_BLUEPRINT_CONFIG_JSON"),
-        ("scenario.json", "MN_BLUEPRINT_SCENARIO_JSON"),
-    ):
-        path = bundle_dir / filename
-        if path.exists():
-            env[env_name] = path.read_text(encoding="utf-8")
-    return env
-
-
-def inject_node_environment(manifest: dict[str, Any], env: dict[str, str]) -> None:
-    for node in manifest.get("nodes") or []:
-        if not isinstance(node, dict):
-            continue
-        config = node.setdefault("config", {})
-        if not isinstance(config, dict):
-            continue
-        environment = config.setdefault("environment", {})
-        if not isinstance(environment, dict):
-            continue
-        environment.update(env)
-        add_mn_llm_aliases(environment)
-
-
-def add_mn_llm_aliases(environment: dict[str, Any]) -> None:
-    for legacy, primary in (
-        ("LITELLM_MODEL", "MN_LLM_MODEL"),
-        ("LITELLM_API_BASE", "MN_LLM_API_BASE"),
-        ("LITELLM_API_KEY", "MN_LLM_API_KEY"),
-        ("LITELLM_TIMEOUT_SECONDS", "MN_LLM_TIMEOUT_SECONDS"),
-        ("LITELLM_MAX_TOKENS", "MN_LLM_MAX_TOKENS"),
-        ("LITELLM_NUM_RETRIES", "MN_LLM_NUM_RETRIES"),
-        ("LITELLM_RETRY_BACKOFF_SECONDS", "MN_LLM_RETRY_BACKOFF_SECONDS"),
-    ):
-        if primary not in environment and legacy in environment:
-            environment[primary] = environment[legacy]
-
-
-def run_mode_label(manifest: dict) -> str:
-    is_live = manifest.get("daemon") is True or manifest.get("policies", {}).get("stream_mode") == "live"
-    if is_live and manifest.get("daemon") is True:
-        return "Live daemon"
-    if is_live:
-        return "Live"
-    return "Batch"

mirrorneuron_cli-1.1.3/tests/test_run_helpers.py

@@ -1,79 +0,0 @@
-import json
-
-from mn_cli.libs.run_logs import JobLogWriter, materialize_sent_email_copy
-from mn_cli.libs.run_manifest import prepare_manifest_for_submission
-
-
-def test_prepare_manifest_for_submission_merges_runtime_env_and_metadata(tmp_path):
-    bundle_dir = tmp_path / "bundle"
-    bundle_dir.mkdir()
-    config_dir = bundle_dir / "config"
-    config_dir.mkdir()
-    (config_dir / "default.json").write_text(json.dumps({"identity": {"blueprint_id": "bp"}}))
-
-    manifest = {
-        "nodes": [
-            {
-                "node_id": "worker",
-                "config": {
-                    "environment": {
-                        "LITELLM_MODEL": "ollama/test",
-                        "MN_LLM_API_KEY": "kept",
-                    }
-                },
-            }
-        ]
-    }
-
-    prepared = prepare_manifest_for_submission(
-        bundle_dir,
-        manifest,
-        env_overrides={"MN_RUN_ID": "run-1"},
-        submission_metadata={"blueprint_id": "bp"},
-    )
-
-    env = prepared["nodes"][0]["config"]["environment"]
-    assert json.loads(env["MN_BLUEPRINT_CONFIG_JSON"])["identity"]["blueprint_id"] == "bp"
-    assert env["MN_RUN_ID"] == "run-1"
-    assert env["MN_LLM_MODEL"] == "ollama/test"
-    assert env["MN_LLM_API_KEY"] == "kept"
-    assert prepared["metadata"]["mn_cli"]["blueprint_id"] == "bp"
-
-
-def test_job_log_writer_deduplicates_events_and_records_web_ui_once():
-    writer = JobLogWriter("unit-run-helper")
-    event = {
-        "timestamp": "2026-05-01T00:00:00Z",
-        "type": "custom",
-        "payload": {"message_id": "m1", "web_ui": {"url": "http://localhost:1"}},
-    }
-
-    assert writer.write_event(event) is True
-    assert writer.write_event(event) is False
-    assert writer.record_web_ui_url(event) == "http://localhost:1"
-    assert writer.record_web_ui_url(event) is None
-
-
-def test_materialize_sent_email_copy_uses_safe_host_paths(tmp_path):
-    materialize_sent_email_copy(
-        tmp_path,
-        {
-            "provider_id": "id/with spaces",
-            "sent_email_copy": {
-                "html_path": "../unsafe.html",
-                "text_content": "plain",
-                "html_content": "<p>Hello</p>",
-                "metadata": {"provider": "test"},
-            },
-        },
-    )
-
-    email_dir = tmp_path / "sent_emails"
-    assert (email_dir / "unsafe.html").read_text() == "<p>Hello</p>"
-    metadata = json.loads((email_dir / "id-with-spaces.json").read_text())
-    assert metadata["provider"] == "test"
-    assert PathLikeName(metadata["host_html_path"]) == "unsafe.html"
-
-
-def PathLikeName(path: str) -> str:
-    return path.rsplit("/", 1)[-1]