hud-python 0.4.56__tar.gz → 0.4.57__tar.gz

{hud_python-0.4.56 → hud_python-0.4.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hud-python
-Version: 0.4.56
+Version: 0.4.57
 Summary: SDK for the HUD platform.
 Project-URL: Homepage, https://github.com/hud-evals/hud-python
 Project-URL: Bug Tracker, https://github.com/hud-evals/hud-python/issues

{hud_python-0.4.56 → hud_python-0.4.57}/hud/cli/dev.py

@@ -237,7 +237,7 @@ async def run_mcp_module(
 
                 from hud.cli.flows.dev import create_dynamic_trace
 
-                live_trace_url = await create_dynamic_trace(
+                _, live_trace_url = await create_dynamic_trace(
                     mcp_config=local_mcp_config,
                     build_status=False,
                     environment_name=mcp_server.name or "mcp-server",
@@ -608,7 +608,7 @@ def run_docker_dev_server(
                     "headers": {},
                 }
             }
-            live_trace_url = _asy.run(
+            _, live_trace_url = _asy.run(
                 create_dynamic_trace(
                     mcp_config=local_mcp_config,
                     build_status=True,
@@ -661,13 +661,33 @@ def run_docker_dev_server(
     # Create and run proxy with HUD helpers
     async def run_proxy() -> None:
         from fastmcp import FastMCP
+        from fastmcp.server.proxy import ProxyClient
 
-        # Create FastMCP proxy to Docker stdio
-        fastmcp_proxy = FastMCP.as_proxy(mcp_config, name="HUD Docker Dev Proxy")
+        # Create ProxyClient without custom log handler since we capture Docker logs directly
+        proxy_client = ProxyClient(mcp_config, name="HUD Docker Dev Proxy")
+
+        # Extract container name from docker args and store for logs endpoint
+        docker_cmd = mcp_config["docker"]["args"]
+        container_name = None
+        for i, arg in enumerate(docker_cmd):
+            if arg == "--name" and i + 1 < len(docker_cmd):
+                container_name = docker_cmd[i + 1]
+                break
+
+        if container_name:
+            # Store container name for logs endpoint to use
+            os.environ["_HUD_DEV_DOCKER_CONTAINER"] = container_name
+            hud_console.debug(f"Docker container: {container_name}")
+
+        # Create FastMCP proxy using the ProxyClient
+        fastmcp_proxy = FastMCP.as_proxy(proxy_client)
 
         # Wrap in MCPServer to get /docs and REST wrappers
         proxy = MCPServer(name="HUD Docker Dev Proxy")
 
+        # Enable logs endpoint on HTTP server
+        os.environ["_HUD_DEV_LOGS_PROVIDER"] = "enabled"
+
         # Import all tools from the FastMCP proxy
         await proxy.import_server(fastmcp_proxy)
 

{hud_python-0.4.56 → hud_python-0.4.57}/hud/cli/flows/dev.py

@@ -18,7 +18,7 @@ async def create_dynamic_trace(
     mcp_config: dict[str, dict[str, Any]],
     build_status: bool,
     environment_name: str,
-) -> str | None:
+) -> tuple[str | None, str | None]:
     """
     Create a dynamic trace for HUD dev sessions when running in HTTP mode.
 
@@ -43,27 +43,16 @@ async def create_dynamic_trace(
     api_key = settings.api_key
     if not api_key:
         logger.warning("Skipping dynamic trace creation; missing HUD_API_KEY")
-        return None
+        return None, None
 
     try:
         resp = await make_request("POST", url=url, json=payload, api_key=api_key)
         # New API returns an id; construct the URL as https://hud.so/trace/{id}
-        trace_id = None
-        if isinstance(resp, dict):
-            trace_id = resp.get("id")
-            if trace_id is None:
-                data = resp.get("data", {}) or {}
-                if isinstance(data, dict):
-                    trace_id = data.get("id")
-            # Backcompat: if url is provided directly
-            if not trace_id:
-                direct_url = resp.get("url") or (resp.get("data", {}) or {}).get("url")
-                if isinstance(direct_url, str) and direct_url:
-                    return direct_url
+        trace_id = resp.get("id")
 
         if isinstance(trace_id, str) and trace_id:
-            return f"https://hud.so/trace/{trace_id}"
-        return None
+            return trace_id, f"https://hud.so/trace/{trace_id}"
+        return None, None
     except Exception as e:
         # Do not interrupt dev flow
         try:
@@ -71,7 +60,7 @@ async def create_dynamic_trace(
             logger.warning("Failed to create dynamic dev trace: %s | payload=%s", e, preview)
         except Exception:
             logger.warning("Failed to create dynamic dev trace: %s", e)
-        return None
+        return None, None
 
 
 def show_dev_ui(

hud_python-0.4.57/hud/cli/tests/test_convert.py

@@ -0,0 +1,367 @@
+"""Tests for the convert command."""
+
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from hud.cli.flows.tasks import convert_tasks_to_remote
+from hud.types import Task
+
+
+class TestConvertCommand:
+    """Test the convert command functionality."""
+
+    @pytest.fixture
+    def temp_tasks_file(self, tmp_path):
+        """Create a temporary tasks file."""
+        tasks = [
+            {
+                "prompt": "Test task 1",
+                "mcp_config": {
+                    "local": {
+                        "command": "docker",
+                        "args": ["run", "--rm", "-i", "test-image:latest"],
+                    }
+                },
+            }
+        ]
+        tasks_file = tmp_path / "tasks.json"
+        tasks_file.write_text(json.dumps(tasks))
+        return tasks_file
+
+    @pytest.fixture
+    def mock_env_dir(self, tmp_path):
+        """Create a mock environment directory with lock file."""
+        env_dir = tmp_path / "env"
+        env_dir.mkdir()
+
+        # Create lock file
+        lock_data = {
+            "images": {
+                "remote": "registry.hud.so/test-org/test-env:v1.0.0",
+                "local": "test-env:latest",
+            }
+        }
+        lock_file = env_dir / "hud.lock.yaml"
+        import yaml
+
+        lock_file.write_text(yaml.dump(lock_data))
+
+        return env_dir
+
+    @patch("hud.cli.flows.tasks._derive_remote_image")
+    @patch("hud.cli.flows.tasks._ensure_pushed")
+    @patch("hud.cli.flows.tasks.find_environment_dir")
+    @patch("hud.cli.flows.tasks.load_tasks")
+    @patch("hud.settings.settings")
+    def test_convert_tasks_basic(
+        self,
+        mock_settings,
+        mock_load_tasks,
+        mock_find_env,
+        mock_ensure_pushed,
+        mock_derive_remote,
+        temp_tasks_file,
+        mock_env_dir,
+    ):
+        """Test basic task conversion from local to remote."""
+        # Setup mocks
+        mock_settings.api_key = "test-api-key"
+        mock_find_env.return_value = mock_env_dir
+
+        # Mock the push check to return updated lock data
+        mock_ensure_pushed.return_value = {
+            "images": {
+                "remote": "registry.hud.so/test-org/test-env:v1.0.0",
+                "local": "test-env:v1.0.0",
+            }
+        }
+
+        # Mock derive remote image
+        mock_derive_remote.return_value = "registry.hud.so/test-org/test-env:v1.0.0"
+
+        task = Task(
+            prompt="Test task",
+            mcp_config={
+                "local": {"command": "docker", "args": ["run", "--rm", "-i", "test-image:latest"]}
+            },
+        )
+        raw_task = {
+            "prompt": "Test task",
+            "mcp_config": {
+                "local": {"command": "docker", "args": ["run", "--rm", "-i", "test-image:latest"]}
+            },
+        }
+
+        mock_load_tasks.side_effect = [[task], [raw_task]]
+
+        # Run conversion
+        result_path = convert_tasks_to_remote(str(temp_tasks_file))
+
+        # Check result
+        assert result_path.endswith("remote_tasks.json")
+        assert Path(result_path).exists()
+
+        # Verify converted content
+        with open(result_path) as f:
+            converted_tasks = json.load(f)
+
+        assert len(converted_tasks) == 1
+        assert "hud" in converted_tasks[0]["mcp_config"]
+        assert converted_tasks[0]["mcp_config"]["hud"]["url"] == "https://mcp.hud.so/v3/mcp"
+
+    @patch("hud.settings.settings")
+    def test_convert_missing_api_key(self, mock_settings, temp_tasks_file):
+        """Test that conversion fails without API key."""
+        mock_settings.api_key = ""
+
+        with pytest.raises(typer.Exit):
+            convert_tasks_to_remote(str(temp_tasks_file))
+
+    @patch("hud.cli.flows.tasks.find_environment_dir")
+    @patch("hud.cli.flows.tasks.load_tasks")
+    @patch("hud.settings.settings")
+    def test_convert_already_remote(
+        self, mock_settings, mock_load_tasks, mock_find_env, temp_tasks_file
+    ):
+        """Test that already remote tasks are not converted again."""
+        mock_settings.api_key = "test-api-key"
+        mock_find_env.return_value = None  # No env dir needed for remote tasks
+
+        # Create task that's already remote
+        task = Task(
+            prompt="Test task",
+            mcp_config={
+                "remote": {
+                    "url": "https://mcp.hud.so",
+                    "headers": {"Mcp-Image": "registry.hud.so/test/image:v1"},
+                }
+            },
+        )
+
+        mock_load_tasks.return_value = [task]
+
+        # Should return original path without modification
+        result_path = convert_tasks_to_remote(str(temp_tasks_file))
+        assert result_path == str(temp_tasks_file)
+
+    @patch("hud.cli.flows.tasks.find_environment_dir")
+    @patch("hud.cli.flows.tasks.load_tasks")
+    @patch("hud.settings.settings")
+    def test_convert_no_environment(
+        self, mock_settings, mock_load_tasks, mock_find_env, temp_tasks_file
+    ):
+        """Test that conversion fails when no environment is found."""
+        mock_settings.api_key = "test-api-key"
+        mock_find_env.return_value = None
+
+        task = Task(
+            prompt="Test task",
+            mcp_config={
+                "local": {"command": "docker", "args": ["run", "--rm", "-i", "test-image:latest"]}
+            },
+        )
+
+        mock_load_tasks.return_value = [task]
+
+        with pytest.raises(typer.Exit):
+            convert_tasks_to_remote(str(temp_tasks_file))
+
+    @patch("hud.utils.hud_console.hud_console.confirm")
+    @patch("hud.cli.flows.tasks._derive_remote_image")
+    @patch("hud.cli.flows.tasks._ensure_pushed")
+    @patch("hud.cli.flows.tasks.find_environment_dir")
+    @patch("hud.cli.flows.tasks.load_tasks")
+    @patch("hud.settings.settings")
+    def test_convert_with_env_vars(
+        self,
+        mock_settings,
+        mock_load_tasks,
+        mock_find_env,
+        mock_ensure_pushed,
+        mock_derive_remote,
+        mock_confirm,
+        temp_tasks_file,
+        mock_env_dir,
+    ):
+        """Test conversion includes environment variables as headers."""
+        mock_settings.api_key = "test-api-key"
+        mock_find_env.return_value = mock_env_dir
+        mock_confirm.return_value = True  # Always confirm in tests
+
+        # Mock the push check to return updated lock data
+        mock_ensure_pushed.return_value = {
+            "images": {
+                "remote": "registry.hud.so/test-org/test-env:v1.0.0",
+                "local": "test-env:v1.0.0",
+            }
+        }
+
+        # Mock derive remote image
+        mock_derive_remote.return_value = "registry.hud.so/test-org/test-env:v1.0.0"
+
+        # Add .env file with API keys
+        env_file = mock_env_dir / ".env"
+        env_file.write_text("OPENAI_API_KEY=sk-test123\nANTHROPIC_API_KEY=sk-ant456")
+
+        task = Task(
+            prompt="Test task",
+            mcp_config={
+                "local": {
+                    "command": "docker",
+                    "args": ["run", "--rm", "-i", "-e", "OPENAI_API_KEY", "test-image:latest"],
+                }
+            },
+        )
+        raw_task = task.model_dump()
+
+        mock_load_tasks.side_effect = [[task], [raw_task]]
+
+        # Run conversion
+        result_path = convert_tasks_to_remote(str(temp_tasks_file))
+
+        # Verify headers include env vars
+        with open(result_path) as f:
+            converted_tasks = json.load(f)
+
+        headers = converted_tasks[0]["mcp_config"]["hud"]["headers"]
+        assert "Env-Openai-Api-Key" in headers
+        assert headers["Env-Openai-Api-Key"] == "${OPENAI_API_KEY}"
+
+
+class TestConvertHelperFunctions:
+    """Test helper functions used by convert command."""
+
+    def test_env_var_to_header_key(self):
+        """Test environment variable name conversion to header format."""
+        from hud.cli.flows.tasks import _env_var_to_header_key
+
+        assert _env_var_to_header_key("OPENAI_API_KEY") == "Env-Openai-Api-Key"
+        assert _env_var_to_header_key("ANTHROPIC_API_KEY") == "Env-Anthropic-Api-Key"
+        assert _env_var_to_header_key("SIMPLE") == "Env-Simple"
+        assert _env_var_to_header_key("MULTIPLE_WORD_VAR") == "Env-Multiple-Word-Var"
+
+    def test_extract_dotenv_api_key_vars(self):
+        """Test extraction of API-like variables from .env file."""
+        # Create test env directory with .env file
+        import tempfile
+
+        from hud.cli.flows.tasks import _extract_dotenv_api_key_vars
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            env_dir = Path(tmpdir)
+            env_file = env_dir / ".env"
+            env_file.write_text("""
+# Test .env file
+OPENAI_API_KEY=sk-test123
+ANTHROPIC_API_KEY=sk-ant456
+SOME_TOKEN=abc123
+CLIENT_SECRET=secret789
+USER_PASSWORD=pass123
+REGULAR_VAR=not_included
+HUD_API_URL=https://api.hud.so
+""")
+
+            result = _extract_dotenv_api_key_vars(env_dir)
+
+            # Should include only API-like variables
+            assert "OPENAI_API_KEY" in result
+            assert "ANTHROPIC_API_KEY" in result
+            assert "SOME_TOKEN" in result
+            assert "CLIENT_SECRET" in result
+            assert "USER_PASSWORD" in result
+            assert "REGULAR_VAR" not in result
+            assert "HUD_API_URL" in result  # API in name, so it's included
+
+    def test_is_remote_url(self):
+        """Test remote URL detection."""
+        from hud.cli.flows.tasks import _is_remote_url
+
+        # This function matches URLs with domain names (not localhost or IPs)
+        assert _is_remote_url("https://mcp.hud.so")
+        assert _is_remote_url("http://mcp.hud.so")
+        assert _is_remote_url("https://mcp.hud.so/some/path")
+        assert _is_remote_url("https://example.com")  # Also matches
+        assert not _is_remote_url("http://localhost:8000")  # localhost doesn't match
+        assert not _is_remote_url("file:///path/to/file")  # file:// doesn't match
+
+    def test_extract_env_vars_from_docker_args(self):
+        """Test extraction of environment variables from docker arguments."""
+        from hud.cli.flows.tasks import _extract_env_vars_from_docker_args
+
+        # Test with various docker arg formats
+        args = [
+            "run",
+            "--rm",
+            "-i",
+            "-e",
+            "VAR1",
+            "-e",
+            "VAR2=value",
+            "--env",
+            "VAR3",
+            "--env=VAR4",
+            # Note: -eFOO compact form is not supported by the implementation
+            "--env-file",
+            ".env",
+            "-p",
+            "8080:80",
+        ]
+
+        result = _extract_env_vars_from_docker_args(args)
+
+        assert "VAR1" in result
+        assert "VAR2" in result
+        assert "VAR3" in result
+        assert "VAR4" in result
+        # FOO is not extracted because -eFOO compact form is not supported
+        assert len(result) == 4
+
+    def test_derive_remote_image(self):
+        """Test deriving remote image from lock data."""
+        from hud.cli.flows.tasks import _derive_remote_image
+
+        # The function derives remote image from images.local, not images.remote
+        lock_data = {"images": {"local": "test-env:v1.0.0"}}
+        result = _derive_remote_image(lock_data)
+        assert result == "test-env:v1.0.0"
+
+        # Test fallback to legacy format
+        lock_data = {
+            "image": "test-org/test-env:v1.0.0",
+        }
+        result = _derive_remote_image(lock_data)
+        assert result == "test-org/test-env:v1.0.0"
+
+    def test_extract_vars_from_task_configs(self):
+        """Test extraction of env vars from task configurations."""
+        from hud.cli.flows.tasks import _extract_vars_from_task_configs
+
+        raw_tasks = [
+            {
+                "prompt": "Task 1",
+                "mcp_config": {
+                    "local": {"command": "docker", "args": ["run", "-e", "API_KEY1", "image1"]}
+                },
+            },
+            {
+                "prompt": "Task 2",
+                "mcp_config": {
+                    "local": {
+                        "command": "docker",
+                        "args": ["run", "-e", "API_KEY2", "--env", "API_KEY3", "image2"],
+                    }
+                },
+            },
+            {"prompt": "Task 3", "mcp_config": {"remote": {"url": "https://mcp.hud.so"}}},
+        ]
+
+        result = _extract_vars_from_task_configs(raw_tasks)
+
+        assert "API_KEY1" in result
+        assert "API_KEY2" in result
+        assert "API_KEY3" in result
+        assert len(result) == 3

{hud_python-0.4.56 → hud_python-0.4.57}/hud/cli/utils/version_check.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import contextlib
 import json
+import logging
 import os
 import time
 from pathlib import Path
@@ -27,6 +28,9 @@ from packaging import version
 
 from hud.utils.hud_console import HUDConsole
 
+# Logger for version checking
+logger = logging.getLogger(__name__)
+
 # Cache location for version check data
 CACHE_DIR = Path.home() / ".hud" / ".cache"
 VERSION_CACHE_FILE = CACHE_DIR / "version_check.json"
@@ -218,7 +222,7 @@ def display_update_prompt(console: HUDConsole | None = None) -> None:
         console: HUDConsole instance for output. If None, creates a new one.
     """
     if console is None:
-        console = HUDConsole()
+        console = HUDConsole(logger=logger)
 
     try:
         info = check_for_updates()
@@ -231,11 +235,8 @@ def display_update_prompt(console: HUDConsole | None = None) -> None:
                 f"   Run: [bold yellow]uv tool upgrade hud-python[/bold yellow] to update"
             )
 
-            # Display as a subtle but noticeable panel
-            console._stdout_console.print(
-                f"\n[yellow]{update_msg}[/yellow]\n",
-                highlight=False,
-            )
+            # Display using console info
+            console.info(f"[yellow]{update_msg}[/yellow]")
     except Exception:  # noqa: S110
         # Never let version checking disrupt the user's workflow
         pass

{hud_python-0.4.56 → hud_python-0.4.57}/hud/clients/base.py

@@ -104,6 +104,7 @@ class BaseHUDClient(AgentMCPClient):
 
         self._initialized = False
         self._telemetry_data = {}  # Initialize telemetry data
+        self._cached_resources: list[types.Resource] = []  # Cache for resources
 
         if self.verbose:
             self._setup_verbose_logging()
@@ -170,6 +171,7 @@ class BaseHUDClient(AgentMCPClient):
         if self._initialized:
             await self._disconnect()
             self._initialized = False
+            self._cached_resources.clear()
             hud_console.info("Environment Shutdown completed")
         else:
             hud_console.debug("Client was not initialized, skipping disconnect")
@@ -211,9 +213,22 @@ class BaseHUDClient(AgentMCPClient):
         """List all available tools."""
         raise NotImplementedError
 
-    @abstractmethod
     async def list_resources(self) -> list[types.Resource]:
-        """List all available resources."""
+        """List all available resources.
+
+        Uses cached resources if available, otherwise fetches from the server.
+
+        Returns:
+            List of available resources.
+        """
+        # If cache is empty, populate it
+        if not self._cached_resources:
+            self._cached_resources = await self._list_resources_impl()
+        return self._cached_resources
+
+    @abstractmethod
+    async def _list_resources_impl(self) -> list[types.Resource]:
+        """Implementation-specific resource listing. Subclasses must implement this."""
         raise NotImplementedError
 
     @abstractmethod
@@ -270,6 +285,17 @@ class BaseHUDClient(AgentMCPClient):
     async def _fetch_telemetry(self) -> None:
         """Common telemetry fetching for all hud clients."""
         try:
+            # Get resources (will use cache if available, otherwise fetch)
+            resources = await self.list_resources()
+            telemetry_available = any(
+                str(resource.uri) == "telemetry://live" for resource in resources
+            )
+
+            if not telemetry_available:
+                if self.verbose:
+                    hud_console.debug("Telemetry resource not available from server")
+                return
+
             # Try to read telemetry resource directly
             result = await self.read_resource("telemetry://live")
             if result and result.contents:

{hud_python-0.4.56 → hud_python-0.4.57}/hud/clients/fastmcp.py

@@ -143,8 +143,8 @@ class FastMCPHUDClient(BaseHUDClient):
             structuredContent=result.structured_content,
         )
 
-    async def list_resources(self) -> list[types.Resource]:
-        """List all available resources."""
+    async def _list_resources_impl(self) -> list[types.Resource]:
+        """Implementation of resource listing for FastMCP client."""
         if self._client is None:
             raise ValueError("Client is not connected, call initialize() first")
         return await self._client.list_resources()

{hud_python-0.4.56 → hud_python-0.4.57}/hud/clients/mcp_use.py

@@ -243,8 +243,8 @@ class MCPUseHUDClient(BaseHUDClient):
             structuredContent=result.structuredContent,
         )
 
-    async def list_resources(self) -> list[types.Resource]:
-        """List all available resources."""
+    async def _list_resources_impl(self) -> list[types.Resource]:
+        """Implementation of resource listing for MCP-use client."""
         if self._client is None or not self._sessions:
             raise ValueError("Client is not connected, call initialize() first")
 

{hud_python-0.4.56 → hud_python-0.4.57}/hud/clients/tests/test_protocol.py

@@ -35,9 +35,15 @@ class MockClient(BaseHUDClient):
             raise RuntimeError("Not connected")
         return self._mock_tools
 
-    async def list_resources(self) -> list[types.Resource]:
-        """Minimal list_resources for protocol satisfaction in tests."""
-        return []
+    async def _list_resources_impl(self) -> list[types.Resource]:
+        """Minimal resource listing implementation for tests."""
+        from pydantic import AnyUrl
+
+        return [
+            types.Resource(
+                uri=AnyUrl("telemetry://live"), name="telemetry", description="Live telemetry data"
+            )
+        ]
 
     async def _call_tool(self, tool_call: MCPToolCall) -> MCPToolResult:
         if tool_call.name == "test_tool":