hud-python 0.4.45__py3-none-any.whl → 0.5.13__py3-none-any.whl

hud/cli/utils/interactive.py

@@ -3,19 +3,21 @@
 from __future__ import annotations
 
 import json
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import questionary
-from mcp.types import TextContent
+from mcp.types import ImageContent, TextContent
 from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.syntax import Syntax
 from rich.tree import Tree
 
-from hud.clients import MCPClient
 from hud.utils.hud_console import HUDConsole
 
+if TYPE_CHECKING:
+    from hud.clients import MCPClient
+
 console = Console()
 
 
@@ -38,6 +40,9 @@ class InteractiveMCPTester:
     async def connect(self) -> bool:
         """Connect to the MCP server."""
         try:
+            # Lazy import to avoid loading mcp_use on simple CLI commands
+            from hud.clients import MCPClient
+
             # Create MCP config for HTTP transport
             # Note: We explicitly set auth to None to prevent OAuth discovery attempts
             config = {"server": {"url": self.server_url, "auth": None}}
@@ -45,7 +50,6 @@ class InteractiveMCPTester:
             self.client = MCPClient(
                 mcp_config=config,
                 verbose=self.verbose,
-                auto_trace=False,  # Disable telemetry for interactive testing
             )
             await self.client.initialize()
 
@@ -242,7 +246,27 @@ class InteractiveMCPTester:
             # Prompt for each property
             args = {}
             for prop_name, prop_schema in properties.items():
-                prop_type = prop_schema.get("type", "string")
+                prop_type = prop_schema.get("type")
+                if not prop_type and "anyOf" in prop_schema:
+                    prop_type = next(
+                        (
+                            s.get("type")
+                            for s in prop_schema.get("anyOf", [])
+                            if s.get("type") != "null"
+                        ),
+                        None,
+                    )
+                if not prop_type and "oneOf" in prop_schema:
+                    prop_type = next(
+                        (
+                            s.get("type")
+                            for s in prop_schema.get("oneOf", [])
+                            if s.get("type") != "null"
+                        ),
+                        None,
+                    )
+                prop_type = prop_type or "string"
+
                 description = prop_schema.get("description", "")
                 is_required = prop_name in required
 
@@ -353,6 +377,16 @@ class InteractiveMCPTester:
                             border_style="green" if not result.isError else "red",
                         )
                     )
+                elif isinstance(content, ImageContent):
+                    mime_type = getattr(content, "mimeType", "image/png")
+                    data_length = len(content.data) if hasattr(content, "data") else 0
+                    console.print(
+                        Panel(
+                            f"📷 Image ({mime_type})\nSize: {data_length:,} bytes (base64 encoded)",
+                            title="Result",
+                            border_style="green" if not result.isError else "red",
+                        )
+                    )
                 else:
                     # Handle other content types
                     console.print(json.dumps(content, indent=2))

hud/cli/utils/metadata.py

@@ -32,7 +32,7 @@ def fetch_lock_from_registry(reference: str) -> dict | None:
 
         # URL-encode the path segments to handle special characters in tags
         url_safe_path = "/".join(quote(part, safe="") for part in reference.split("/"))
-        registry_url = f"{settings.hud_telemetry_url.rstrip('/')}/registry/envs/{url_safe_path}"
+        registry_url = f"{settings.hud_api_url.rstrip('/')}/registry/envs/{url_safe_path}"
 
         headers = {}
         if settings.api_key:
@@ -173,6 +173,8 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
         "tools": [],
         "resources": [],
         "prompts": [],
+        "scenarios": [],
+        "verbose": verbose,
     }
 
     # Add basic info
@@ -206,6 +208,73 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
                 }
             )
 
+    # Extract resources
+    if "resources" in lock_data:
+        for resource in lock_data["resources"]:
+            analysis["resources"].append(
+                {
+                    "uri": resource.get("uri", ""),
+                    "name": resource.get("name", ""),
+                    "description": resource.get("description", ""),
+                    "mime_type": resource.get("mimeType", resource.get("mime_type", "")),
+                }
+            )
+
+    # Extract prompts
+    if "prompts" in lock_data:
+        for prompt in lock_data["prompts"]:
+            analysis["prompts"].append(
+                {
+                    "name": prompt.get("name", ""),
+                    "description": prompt.get("description", ""),
+                    "arguments": prompt.get("arguments", []),
+                }
+            )
+
+    # Derive scenarios from scenario prompts/resources if present
+    scenarios_by_id: dict[str, dict] = {}
+    for p in analysis["prompts"]:
+        desc = (p.get("description") or "").strip()
+        if not desc.startswith("[Setup]"):
+            continue
+        scenario_id = p.get("name")
+        if not scenario_id:
+            continue
+        env_name, scenario_name = ([*scenario_id.split(":", 1), ""])[:2]
+        scenarios_by_id[scenario_id] = {
+            "id": scenario_id,
+            "env": env_name,
+            "name": scenario_name or scenario_id,
+            "setup_description": desc,
+            "arguments": p.get("arguments") or [],
+            "has_setup_prompt": True,
+            "has_evaluate_resource": False,
+        }
+    for r in analysis["resources"]:
+        desc = (r.get("description") or "").strip()
+        if not desc.startswith("[Evaluate]"):
+            continue
+        scenario_id = r.get("uri")
+        if not scenario_id:
+            continue
+        env_name, scenario_name = ([*scenario_id.split(":", 1), ""])[:2]
+        if scenario_id not in scenarios_by_id:
+            scenarios_by_id[scenario_id] = {
+                "id": scenario_id,
+                "env": env_name,
+                "name": scenario_name or scenario_id,
+                "arguments": [],
+                "has_setup_prompt": False,
+                "has_evaluate_resource": True,
+            }
+        scenarios_by_id[scenario_id]["evaluate_description"] = desc
+        scenarios_by_id[scenario_id]["has_evaluate_resource"] = True
+
+    analysis["scenarios"] = sorted(
+        scenarios_by_id.values(),
+        key=lambda s: (str(s.get("env") or ""), str(s.get("name") or "")),
+    )
+
     # Display results
     hud_console.info("")
     if source == "local":

hud/cli/utils/runner.py

@@ -16,7 +16,7 @@ def run_stdio_server(image: str, docker_args: list[str], verbose: bool) -> None:
     """Run Docker image as stdio MCP server (direct passthrough)."""
     hud_console = HUDConsole()  # Use stderr for stdio mode
 
-    # Build docker command
+    # Build docker command (image-only mode: do not auto-inject local .env)
     docker_cmd = ["docker", "run", "--rm", "-i", *docker_args, image]
 
     if verbose:

hud/cli/utils/server.py

@@ -138,9 +138,9 @@ class MCPServerManager:
             logging.getLogger("uvicorn.access").setLevel(logging.ERROR)
             logging.getLogger("uvicorn.error").setLevel(logging.ERROR)
 
-            import warnings
+            from hud.patches.warnings import apply_default_warning_filters
 
-            warnings.filterwarnings("ignore", category=DeprecationWarning)
+            apply_default_warning_filters(verbose=False)
 
         try:
             await proxy.run_async(

hud/cli/utils/source_hash.py

@@ -1,7 +1,7 @@
 """Utilities to compute a fast, deterministic source hash for environments.
 
 This intentionally focuses on the typical HUD environment layout and aims to be fast:
-- Always include: Dockerfile, pyproject.toml
+- Always include: Dockerfile.hud, Dockerfile, pyproject.toml
 - Include directories: controller/, environment/, src/
 - Exclude common build/runtime caches and lock files
 
@@ -40,8 +40,8 @@ EXCLUDE_FILES = {
     "hud.lock.yaml",
 }
 
-INCLUDE_FILES = {"Dockerfile", "pyproject.toml"}
-INCLUDE_DIRS = {"controller", "environment"}
+INCLUDE_FILES = {"Dockerfile", "Dockerfile.hud", "pyproject.toml"}
+INCLUDE_DIRS = {"server", "mcp", "controller", "environment"}
 
 
 def iter_source_files(root: Path) -> Iterable[Path]:

hud/cli/utils/tasks.py

@@ -18,9 +18,12 @@ def find_tasks_file(tasks_file: str | None, msg: str = "Select a tasks file") ->
     ]
     all_files = [file for file in all_files if file[0] != "."]  # Remove all config files
 
+    if not all_files:
+        # No task files found - raise a clear exception
+        raise FileNotFoundError("No task JSON or JSONL files found in current directory")
+
     if len(all_files) == 1:
         return str(all_files[0])
-
     else:
         # Prompt user to select a file
         return hud_console.select(msg, choices=all_files)

hud/cli/utils/tests/test_config.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hud.cli.utils.config import (
+    ensure_config_dir,
+    get_config_dir,
+    get_user_env_path,
+    load_env_file,
+    parse_env_file,
+    render_env_file,
+    save_env_file,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_parse_env_file_basic():
+    contents = """
+# comment
+KEY=VALUE
+EMPTY=
+NOEQ
+ SPACED = v 
+"""  # noqa: W291
+    data = parse_env_file(contents)
+    assert data["KEY"] == "VALUE"
+    assert data["EMPTY"] == ""
+    assert data["SPACED"] == "v"
+    assert "NOEQ" not in data
+
+
+def test_render_and_load_roundtrip(tmp_path: Path):
+    env = {"A": "1", "B": "2"}
+    file_path = tmp_path / ".env"
+    rendered = render_env_file(env)
+    file_path.write_text(rendered, encoding="utf-8")
+    loaded = load_env_file(file_path)
+    assert loaded == env
+
+
+def test_get_paths(monkeypatch, tmp_path: Path):
+    from pathlib import Path as _Path
+
+    monkeypatch.setattr(_Path, "home", lambda: tmp_path)
+    cfg = get_config_dir()
+    assert str(cfg).replace("\\", "/").endswith("/.hud")
+    assert str(get_user_env_path()).replace("\\", "/").endswith("/.hud/.env")
+
+
+def test_ensure_and_save(tmp_path: Path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    cfg = ensure_config_dir()
+    assert cfg.exists()
+    out = save_env_file({"K": "V"})
+    assert out.exists()
+    assert load_env_file(out) == {"K": "V"}

hud/cli/utils/tests/test_docker.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from hud.cli.utils.docker import (
+    build_run_command,
+    generate_container_name,
+    get_docker_cmd,
+    image_exists,
+    remove_container,
+    require_docker_running,
+)
+
+
+def test_build_run_command_basic():
+    cmd = build_run_command("my-image:latest")
+    assert cmd[:4] == ["docker", "run", "--rm", "-i"]
+    assert cmd[-1] == "my-image:latest"
+
+
+def test_build_run_command_with_args():
+    cmd = build_run_command("img", ["-e", "K=V", "-p", "8080:8080"])
+    assert "-e" in cmd and "K=V" in cmd
+    assert "-p" in cmd and "8080:8080" in cmd
+    assert cmd[-1] == "img"
+
+
+def test_generate_container_name():
+    assert generate_container_name("repo/name:tag") == "hud-repo-name-tag"
+    assert generate_container_name("a/b:c", prefix="x") == "x-a-b-c"
+
+
+@patch("subprocess.run")
+def test_image_exists_true(mock_run):
+    mock_run.return_value = MagicMock(returncode=0)
+    assert image_exists("any") is True
+
+
+@patch("subprocess.run")
+def test_image_exists_false(mock_run):
+    mock_run.return_value = MagicMock(returncode=1)
+    assert image_exists("any") is False
+
+
+@patch("subprocess.run")
+def test_get_docker_cmd_success(mock_run):
+    mock_run.return_value = MagicMock(
+        stdout='[{"Config": {"Cmd": ["python", "-m", "app"]}}]', returncode=0
+    )
+    assert get_docker_cmd("img") == ["python", "-m", "app"]
+
+
+@patch("subprocess.run")
+def test_get_docker_cmd_none(mock_run):
+    mock_run.return_value = MagicMock(stdout="[]", returncode=0)
+    assert get_docker_cmd("img") is None
+
+
+@patch("subprocess.run")
+def test_remove_container_ok(mock_run):
+    mock_run.return_value = MagicMock(returncode=0)
+    assert remove_container("x") is True
+
+
+@patch("shutil.which", return_value=None)
+def test_require_docker_running_no_cli(_which):
+    import typer
+
+    with pytest.raises(typer.Exit):
+        require_docker_running()
+
+
+@patch("shutil.which", return_value="docker")
+@patch("subprocess.run")
+def test_require_docker_running_ok(mock_run, _which):
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+    require_docker_running()  # should not raise
+
+
+@patch("shutil.which", return_value="docker")
+@patch("subprocess.run")
+def test_require_docker_running_error_emits_hints(mock_run, _which):
+    import typer
+
+    mock_run.return_value = MagicMock(
+        returncode=1,
+        stdout="Cannot connect to the Docker daemon",
+        stderr="",
+    )
+    with pytest.raises(typer.Exit):
+        require_docker_running()

hud/cli/utils/tests/test_docker_hints.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import sys
+
+import pytest
+
+from hud.cli.utils import docker as mod
+
+pytestmark = pytest.mark.skipif(sys.platform == "win32", reason="Prefers Linux")
+
+
+def test_emit_docker_hints_windows(monkeypatch):
+    # Patch the global hud_console used by hint printing
+
+    fake = type(
+        "C",
+        (),
+        {
+            "error": lambda *a, **k: None,
+            "hint": lambda *a, **k: None,
+            "dim_info": lambda *a, **k: None,
+        },
+    )()
+    monkeypatch.setattr("hud.utils.hud_console.hud_console", fake, raising=False)
+    monkeypatch.setattr(mod.platform, "system", lambda: "Windows")
+    mod._emit_docker_hints("cannot connect to the docker daemon")
+
+
+def test_emit_docker_hints_linux(monkeypatch):
+    fake = type(
+        "C",
+        (),
+        {
+            "error": lambda *a, **k: None,
+            "hint": lambda *a, **k: None,
+            "dim_info": lambda *a, **k: None,
+        },
+    )()
+    monkeypatch.setattr("hud.utils.hud_console.hud_console", fake, raising=False)
+    monkeypatch.setattr(mod.platform, "system", lambda: "Linux")
+    mod._emit_docker_hints("Cannot connect to the Docker daemon")
+
+
+def test_emit_docker_hints_darwin(monkeypatch):
+    fake = type(
+        "C",
+        (),
+        {
+            "error": lambda *a, **k: None,
+            "hint": lambda *a, **k: None,
+            "dim_info": lambda *a, **k: None,
+        },
+    )()
+    monkeypatch.setattr("hud.utils.hud_console.hud_console", fake, raising=False)
+    monkeypatch.setattr(mod.platform, "system", lambda: "Darwin")
+    mod._emit_docker_hints("error during connect: is the docker daemon running")
+
+
+def test_emit_docker_hints_generic(monkeypatch):
+    fake = type(
+        "C",
+        (),
+        {
+            "error": lambda *a, **k: None,
+            "hint": lambda *a, **k: None,
+            "dim_info": lambda *a, **k: None,
+        },
+    )()
+    monkeypatch.setattr("hud.utils.hud_console.hud_console", fake, raising=False)
+    monkeypatch.setattr(mod.platform, "system", lambda: "Other")
+    mod._emit_docker_hints("some unrelated error")

hud/cli/utils/tests/test_env_check.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+from hud.cli.utils.env_check import (
+    _collect_source_diffs,
+    _parse_generated_at,
+    ensure_built,
+    find_environment_dir,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_parse_generated_at_variants():
+    ts = _parse_generated_at({"build": {"generatedAt": datetime.now(UTC).isoformat()}})
+    assert isinstance(ts, float)
+    assert _parse_generated_at({}) is None
+
+
+def test_collect_source_diffs_basic(tmp_path: Path):
+    env = tmp_path / "env"
+    env.mkdir()
+    # simulate files
+    (env / "Dockerfile").write_text("FROM python:3.11")
+    (env / "pyproject.toml").write_text("[tool.hud]")
+    (env / "a.txt").write_text("x")
+
+    # stored file list includes a non-existent file and old time
+    built_time = (datetime.now(UTC) - timedelta(days=1)).isoformat()
+    lock = {"build": {"sourceFiles": ["a.txt", "b.txt"], "generatedAt": built_time}}
+
+    # Patch list_source_files to return current env files
+    with patch("hud.cli.utils.env_check.list_source_files") as mock_list:
+        mock_list.return_value = [env / "a.txt", env / "Dockerfile"]
+        diffs = _collect_source_diffs(env, lock)
+    assert "Dockerfile" in diffs["added"]
+    assert "b.txt" in diffs["removed"]
+    assert "a.txt" in diffs["modified"] or "a.txt" in diffs["added"]
+
+
+def test_find_environment_dir_prefers_lock(tmp_path: Path):
+    # Create env as a sibling to tasks, so it will be in the candidates list
+    parent = tmp_path / "parent"
+    parent.mkdir()
+    tasks = parent / "tasks.json"
+    tasks.write_text("[]")
+    env = tmp_path / "env"
+    env.mkdir()
+    (env / "hud.lock.yaml").write_text("version: 1.3")
+    # Set cwd to env so it's in the candidate list
+    with patch("pathlib.Path.cwd", return_value=env):
+        found = find_environment_dir(tasks)
+    # Should find env because cwd returns env and it has hud.lock.yaml
+    assert found == env
+
+
+def test_ensure_built_no_lock_noninteractive(tmp_path: Path):
+    env = tmp_path / "e"
+    env.mkdir()
+    # Non-interactive: returns empty dict and does not raise
+    result = ensure_built(env, interactive=False)
+    assert result == {}
+
+
+def test_ensure_built_interactive_build(tmp_path: Path):
+    env = tmp_path / "e"
+    env.mkdir()
+    # Simulate interactive=False path avoids prompts
+    result = ensure_built(env, interactive=False)
+    assert result == {}

hud/cli/utils/tests/test_environment.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import MagicMock, patch
+
+from hud.cli.utils.environment import get_image_name, image_exists, is_environment_directory
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_get_image_name_override():
+    name, source = get_image_name(".", image_override="custom:dev")
+    assert name == "custom:dev" and source == "override"
+
+
+def test_get_image_name_auto(tmp_path: Path):
+    env = tmp_path / "my_env"
+    env.mkdir()
+    # Provide Dockerfile and pyproject to pass directory check later if used
+    (env / "Dockerfile").write_text("FROM python:3.11")
+    (env / "pyproject.toml").write_text("[tool.hud]\nimage='x'")
+    name, source = get_image_name(env)
+    # Because pyproject exists with image key, source should be cache
+    assert source == "cache"
+    assert name == "x"
+
+
+def test_is_environment_directory(tmp_path: Path):
+    d = tmp_path / "env"
+    d.mkdir()
+    assert is_environment_directory(d) is False
+    (d / "Dockerfile").write_text("FROM python:3.11")
+    assert is_environment_directory(d) is False
+    (d / "pyproject.toml").write_text("[tool.hud]")
+    assert is_environment_directory(d) is True
+
+
+@patch("subprocess.run")
+def test_image_exists_true(mock_run):
+    mock_run.return_value = MagicMock(returncode=0)
+    assert image_exists("img") is True