hud-python 0.4.56__py3-none-any.whl → 0.4.58__py3-none-any.whl

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/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/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()
@@ -139,7 +140,7 @@ class BaseHUDClient(AgentMCPClient):
                     raise HudAuthenticationError(
                         f'Sending authorization "{headers.get("Authorization", "")}", which may'
                         " be incomplete. Ensure HUD_API_KEY environment variable is set or send it"
-                        " as a header. You can get an API key at https://hud.so"
+                        " as a header. You can get an API key at https://hud.ai"
                     )
             # Subclasses implement connection
             await self._connect(self._mcp_config)
@@ -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/clients/fastmcp.py

@@ -95,7 +95,7 @@ class FastMCPHUDClient(BaseHUDClient):
                             raise RuntimeError(
                                 "Authentication failed for HUD API. "
                                 "Please ensure your HUD_API_KEY environment variable is set correctly."  # noqa: E501
-                                "You can get an API key at https://hud.so"
+                                "You can get an API key at https://hud.ai"
                             ) from e
                     # Generic 401 error
                     raise RuntimeError(
@@ -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/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/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":

hud/otel/config.py

@@ -113,7 +113,7 @@ def configure_telemetry(
         # Error if no exporters are configured
         raise ValueError(
             "No telemetry backend configured. Either:\n"
-            "1. Set HUD_API_KEY environment variable for HUD telemetry (https://hud.so)\n"
+            "1. Set HUD_API_KEY environment variable for HUD telemetry (https://hud.ai)\n"
             "2. Use enable_otlp=True with configure_telemetry() for alternative backends (e.g., Jaeger)\n"  # noqa: E501
         )
     elif not settings.telemetry_enabled:

hud/otel/context.py

@@ -408,7 +408,7 @@ def _print_trace_url(task_run_id: str) -> None:
     if not (settings.telemetry_enabled and settings.api_key):
         return
 
-    url = f"https://hud.so/trace/{task_run_id}"
+    url = f"https://hud.ai/trace/{task_run_id}"
     header = "🚀 See your agent live at:"
 
     # ANSI color codes
@@ -447,7 +447,7 @@ def _print_trace_complete_url(task_run_id: str, error_occurred: bool = False) ->
     if not (settings.telemetry_enabled and settings.api_key):
         return
 
-    url = f"https://hud.so/trace/{task_run_id}"
+    url = f"https://hud.ai/trace/{task_run_id}"
 
     # ANSI color codes
     GREEN = "\033[92m"