diff --git a/adapters/common/src/nemo_fabric_adapters/common/utils.py b/adapters/common/src/nemo_fabric_adapters/common/utils.py index 1fe8dd2a5..5484cc235 100644 --- a/adapters/common/src/nemo_fabric_adapters/common/utils.py +++ b/adapters/common/src/nemo_fabric_adapters/common/utils.py @@ -5,6 +5,7 @@ from __future__ import annotations +import glob import json import os import sys @@ -271,7 +272,44 @@ def normalize_relay_output_dirs(plugin_config: dict[str, Any], payload: dict[str atif.setdefault("model_name", relay_model_name(payload)) +def _artifact_directory(value: Any) -> Path | None: + if not value: + return None + try: + directory = Path(value).resolve(strict=True) + except (OSError, RuntimeError, TypeError, ValueError): + return None + return directory if directory.is_dir() else None + + +def _artifact_file(value: Any, *, directory: Path) -> Path | None: + try: + path = Path(value).resolve(strict=True) + except (OSError, RuntimeError, TypeError, ValueError): + return None + if not path.is_file() or not path.is_relative_to(directory): + return None + return path + + +def _artifact_name_is_local(value: str) -> bool: + try: + return Path(value).name == value + except (OSError, ValueError): + return False + + +def _artifact_glob(directory: Path, pattern: str) -> list[Path]: + if not _artifact_name_is_local(pattern): + return [] + try: + return sorted(directory.glob(pattern)) + except (OSError, ValueError): + return [] + + def collect_relay_artifacts(plugin_config: dict[str, Any]) -> list[dict[str, str]]: + artifacts: list[dict[str, str]] = [] for component in plugin_config.get("components", []): if component.get("kind") != "observability": @@ -282,26 +320,34 @@ def collect_relay_artifacts(plugin_config: dict[str, Any]) -> list[dict[str, str for sink in atof.get("sinks") or []: if not isinstance(sink, dict) or sink.get("type") != "file": continue - output_directory = sink.get("output_directory") - if not output_directory: - continue - directory = Path(output_directory) - if not directory.exists(): - continue - for path in sorted(directory.glob("*.jsonl")): - artifacts.append({"kind": "atof", "path": str(path)}) + directory = _artifact_directory(sink.get("output_directory")) + if directory is not None: + filename = sink.get("filename") + if isinstance(filename, str) and filename: + paths = ( + [directory / filename] + if _artifact_name_is_local(filename) + else [] + ) + else: + paths = _artifact_glob(directory, "*.jsonl") + for path in paths: + resolved = _artifact_file(path, directory=directory) + if resolved is not None: + artifacts.append({"kind": "atof", "path": str(resolved)}) atif = config.get("atif") - if not isinstance(atif, dict) or not atif.get("enabled"): - continue - output_directory = atif.get("output_directory") - if not output_directory: - continue - directory = Path(output_directory) - if not directory.exists(): - continue - for path in sorted(directory.glob("*.json")): - artifacts.append({"kind": "atif", "path": str(path)}) + if isinstance(atif, dict) and atif.get("enabled"): + directory = _artifact_directory(atif.get("output_directory")) + if directory is not None: + template = atif.get("filename_template") + if not isinstance(template, str) or not template: + continue + pattern = glob.escape(template).replace("{session_id}", "*") + for path in _artifact_glob(directory, pattern): + resolved = _artifact_file(path, directory=directory) + if resolved is not None: + artifacts.append({"kind": "atif", "path": str(resolved)}) return artifacts diff --git a/tests/adapters/test_adapaters_common_utils.py b/tests/adapters/test_adapaters_common_utils.py index b9ed3ba2a..053b9ff1d 100644 --- a/tests/adapters/test_adapaters_common_utils.py +++ b/tests/adapters/test_adapaters_common_utils.py @@ -8,6 +8,7 @@ import tomllib from io import StringIO from pathlib import Path +from typing import Any import nemo_fabric_adapters.common.utils as common_utils import pytest @@ -369,9 +370,15 @@ def test_collect_relay_artifacts(tmp_path: Path): atof_file = atof_dir / "events.atof.jsonl" atif_file = atif_dir / "trajectory-1.atif.json" ignored_file = atif_dir / "ignored.txt" + unrelated_atif = atif_dir / "config.json" + atof_directory = atof_dir / "directory.jsonl" + atif_directory = atif_dir / "trajectory-directory.atif.json" atof_file.write_text("{}", encoding="utf-8") atif_file.write_text("{}", encoding="utf-8") ignored_file.write_text("ignored", encoding="utf-8") + unrelated_atif.write_text("{}", encoding="utf-8") + atof_directory.mkdir() + atif_directory.mkdir() plugin_config = { "components": [ { @@ -390,7 +397,11 @@ def test_collect_relay_artifacts(tmp_path: Path): }, ], }, - "atif": {"enabled": True, "output_directory": str(atif_dir)}, + "atif": { + "enabled": True, + "output_directory": str(atif_dir), + "filename_template": "trajectory-{session_id}.atif.json", + }, }, } ] @@ -402,6 +413,59 @@ def test_collect_relay_artifacts(tmp_path: Path): ] +@pytest.mark.parametrize("filename_template", [None, "", 123]) +def test_collect_relay_artifacts_requires_valid_atif_filename_template( + tmp_path: Path, + filename_template: object, +): + atif_dir = tmp_path / "atif" + atif_dir.mkdir() + (atif_dir / "config.json").write_text("{}", encoding="utf-8") + atif_config: dict[str, Any] = { + "enabled": True, + "output_directory": str(atif_dir), + } + if filename_template is not None: + atif_config["filename_template"] = filename_template + plugin_config = { + "components": [ + { + "kind": "observability", + "config": {"atif": atif_config}, + } + ] + } + + assert common_utils.collect_relay_artifacts(plugin_config) == [] + + +def test_collect_relay_artifacts_treats_atif_template_as_literal(tmp_path: Path): + atif_dir = tmp_path / "atif" + atif_dir.mkdir() + configured = atif_dir / "[team]-session.json" + unrelated = atif_dir / "t-session.json" + configured.write_text("{}", encoding="utf-8") + unrelated.write_text("{}", encoding="utf-8") + plugin_config = { + "components": [ + { + "kind": "observability", + "config": { + "atif": { + "enabled": True, + "output_directory": str(atif_dir), + "filename_template": "[team]-{session_id}.json", + } + }, + } + ] + } + + assert common_utils.collect_relay_artifacts(plugin_config) == [ + {"kind": "atif", "path": str(configured)} + ] + + def test_collect_relay_artifacts_ignores_missing_output_directories( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, @@ -427,6 +491,130 @@ def test_collect_relay_artifacts_ignores_missing_output_directories( assert common_utils.collect_relay_artifacts(plugin_config) == [] +def _atof_artifact_config( + output_directory: object, + *, + filename: object | None = None, +) -> dict[str, Any]: + sink: dict[str, Any] = { + "type": "file", + "output_directory": output_directory, + } + if filename is not None: + sink["filename"] = filename + return { + "components": [ + { + "kind": "observability", + "config": { + "atof": { + "enabled": True, + "sinks": [sink], + } + }, + } + ] + } + + +def test_collect_relay_artifacts_honors_configured_atof_filename(tmp_path: Path): + atof_dir = tmp_path / "atof" + atof_dir.mkdir() + configured = atof_dir / "configured.jsonl" + ignored = atof_dir / "ignored.jsonl" + configured.write_text("{}", encoding="utf-8") + ignored.write_text("{}", encoding="utf-8") + plugin_config = _atof_artifact_config(atof_dir, filename=configured.name) + + assert common_utils.collect_relay_artifacts(plugin_config) == [ + {"kind": "atof", "path": str(configured)} + ] + + +def test_collect_relay_artifacts_missing_configured_atof_file_returns_empty( + tmp_path: Path, +): + atof_dir = tmp_path / "atof" + atof_dir.mkdir() + (atof_dir / "unrelated.jsonl").write_text("{}", encoding="utf-8") + plugin_config = _atof_artifact_config(atof_dir, filename="missing.jsonl") + + assert common_utils.collect_relay_artifacts(plugin_config) == [] + + +def test_collect_relay_artifacts_configured_atof_directory_returns_empty( + tmp_path: Path, +): + atof_dir = tmp_path / "atof" + atof_dir.mkdir() + configured = atof_dir / "directory.jsonl" + configured.mkdir() + plugin_config = _atof_artifact_config(atof_dir, filename=configured.name) + + assert common_utils.collect_relay_artifacts(plugin_config) == [] + + +def test_collect_relay_artifacts_ignores_path_resolution_runtime_errors( + tmp_path: Path, + monkeypatch: pytest.MonkeyPatch, +): + artifact_dir = tmp_path / "atof" + artifact_dir.mkdir() + original_resolve = Path.resolve + + def resolve(path: Path, *, strict: bool = False) -> Path: + if path.name == "loop": + raise RuntimeError + return original_resolve(path, strict=strict) + + monkeypatch.setattr(Path, "resolve", resolve) + + assert common_utils.collect_relay_artifacts( + _atof_artifact_config(tmp_path / "loop") + ) == [] + assert common_utils.collect_relay_artifacts( + _atof_artifact_config(artifact_dir, filename="loop") + ) == [] + + +def test_collect_relay_artifacts_non_string_atof_filename_uses_glob(tmp_path: Path): + atof_dir = tmp_path / "atof" + atof_dir.mkdir() + artifact = atof_dir / "events.jsonl" + artifact.write_text("{}", encoding="utf-8") + plugin_config = _atof_artifact_config(atof_dir, filename=123) + + assert common_utils.collect_relay_artifacts(plugin_config) == [ + {"kind": "atof", "path": str(artifact)} + ] + + +def test_collect_relay_artifacts_rejects_escaping_atof_filenames(tmp_path: Path): + atof_dir = tmp_path / "atof" + atof_dir.mkdir() + outside = tmp_path / "outside.jsonl" + outside.write_text("{}", encoding="utf-8") + + for filename in (str(outside), "../outside.jsonl"): + plugin_config = _atof_artifact_config(atof_dir, filename=filename) + assert common_utils.collect_relay_artifacts(plugin_config) == [] + + +def test_collect_relay_artifacts_ignores_malformed_paths(tmp_path: Path): + atof_dir = tmp_path / "atof" + atof_dir.mkdir() + plugin_config = _atof_artifact_config( + atof_dir, + filename="invalid\0name.jsonl", + ) + plugin_config["components"][0]["config"]["atif"] = { + "enabled": True, + "output_directory": "invalid\0directory", + } + + assert common_utils.collect_relay_artifacts(plugin_config) == [] + + def test_relay_validates_raw_v06_plugin_config(): from nemo_relay import plugin diff --git a/tests/adapters/test_claude_adapter.py b/tests/adapters/test_claude_adapter.py index f575fe0b9..5d1af53e4 100644 --- a/tests/adapters/test_claude_adapter.py +++ b/tests/adapters/test_claude_adapter.py @@ -684,6 +684,7 @@ async def test_runtime_reports_relay_artifacts(relay_payload, monkeypatch, tmp_p "atif": { "enabled": True, "output_directory": str(tmp_path / "atif"), + "filename_template": "trajectory-{session_id}.atif.json", } }, } diff --git a/tests/e2e/test_cli_scaffold.py b/tests/e2e/test_cli_scaffold.py index 8d6d9e3d6..a22841de4 100644 --- a/tests/e2e/test_cli_scaffold.py +++ b/tests/e2e/test_cli_scaffold.py @@ -70,7 +70,7 @@ def test_generated_rust_scaffold_builds(tmp_path: Path): manifest = (destination / "Cargo.toml").read_text() assert "[workspace]" in manifest core_dependency = tomllib.loads(manifest)["dependencies"]["nemo-fabric-core"] - assert Path(core_dependency["path"]) == ROOT / "crates/fabric-core" + assert Path(core_dependency["path"]).samefile(ROOT / "crates/fabric-core") expected_version = tomllib.loads((ROOT / "Cargo.toml").read_text())["workspace"][ "package" ]["version"]