hud-python 0.4.35__py3-none-any.whl → 0.4.36__py3-none-any.whl

hud/cli/pull.py

@@ -154,6 +154,9 @@ def pull_environment(
             # Check for API key (not required for pulling, but good to inform)
             if not settings.api_key:
                 hud_console.info("No HUD API key set (pulling from public registry)")
+                hud_console.info(
+                    "Set it in your environment or run: hud set HUD_API_KEY=your-key-here"
+                )
 
             lock_data = fetch_lock_from_registry(target)
 
@@ -166,6 +169,9 @@ def pull_environment(
                     hud_console.info(
                         "Not found in HUD registry (try setting HUD_API_KEY for private environments)"  # noqa: E501
                     )
+                    hud_console.info(
+                        "Set it in your environment or run: hud set HUD_API_KEY=your-key-here"
+                    )
                 else:
                     hud_console.info("Not found in HUD registry, treating as Docker image")
 

hud/cli/push.py

@@ -144,7 +144,7 @@ def push_environment(
         hud_console.warning("A HUD API key is required to push environments.")
         hud_console.info("\nTo get started:")
         hud_console.info("1. Get your API key at: https://hud.so/settings")
-        hud_console.command_example("export HUD_API_KEY=your-key-here", "Set your API key")
+        hud_console.info("Set it in your environment or run: hud set HUD_API_KEY=your-key-here")
         hud_console.command_example("hud push", "Try again")
         hud_console.info("")
         raise typer.Exit(1)
@@ -414,6 +414,7 @@ def push_environment(
             hud_console.error("Authentication failed")
             hud_console.info("Check your HUD_API_KEY is valid")
             hud_console.info("Get a new key at: https://hud.so/settings")
+            hud_console.info("Set it in your environment or run: hud set HUD_API_KEY=your-key-here")
         elif response.status_code == 403:
             hud_console.error("Permission denied")
             hud_console.info("You may not have access to push to this namespace")

hud/cli/rl/remote_runner.py

@@ -76,7 +76,9 @@ def run_remote_training(
 
     if not settings.api_key:
         hud_console.error("API key not found")
-        console.print("[yellow]Please set HUD_API_KEY environment variable[/yellow]")
+        console.print(
+            "[yellow]Set it in your environment or run: hud set HUD_API_KEY=your-key-here[/yellow]"
+        )
         raise ValueError("API key not found")
 
     # Step 1: CONFIRMATION - Load tasks and show example

hud/cli/tests/test_build.py

@@ -235,14 +235,10 @@ class TestAnalyzeMcpEnvironment:
         # Setup mock client to fail
         mock_client = mock.AsyncMock()
         mock_client_class.return_value = mock_client
-        mock_client.initialize.side_effect = Exception("Connection failed")
+        mock_client.initialize.side_effect = ConnectionError("Connection failed")
 
-        result = await analyze_mcp_environment("test:latest")
-
-        assert result["success"] is False
-        assert result["toolCount"] == 0
-        assert "error" in result
-        assert "Connection failed" in result["error"]
+        with pytest.raises(ConnectionError):
+            await analyze_mcp_environment("test:latest")
 
     @mock.patch("hud.cli.build.MCPClient")
     async def test_analyze_verbose_mode(self, mock_client_class):
@@ -404,23 +400,3 @@ ENV API_KEY
 
         with pytest.raises(typer.Exit):
             build_environment(str(env_dir))
-
-    @mock.patch("hud.cli.build.build_docker_image")
-    @mock.patch("hud.cli.build.analyze_mcp_environment")
-    def test_build_environment_analysis_failure(self, mock_analyze, mock_build, tmp_path):
-        """Test when MCP analysis fails."""
-        env_dir = tmp_path / "test-env"
-        env_dir.mkdir()
-        (env_dir / "pyproject.toml").write_text("[tool.hud]")
-        (env_dir / "Dockerfile").write_text("FROM python:3.11")
-
-        mock_build.return_value = True
-        mock_analyze.return_value = {
-            "success": False,
-            "error": "Connection failed",
-            "toolCount": 0,
-            "tools": [],
-        }
-
-        with pytest.raises(typer.Exit):
-            build_environment(str(env_dir))

hud/cli/tests/test_mcp_server.py

@@ -11,7 +11,6 @@ from hud.cli.dev import (
     create_proxy_server,
     get_docker_cmd,
     get_image_name,
-    inject_supervisor,
     run_mcp_dev_server,
     update_pyproject_toml,
 )
@@ -52,16 +51,6 @@ class TestDockerUtils:
             cmd = get_docker_cmd("test-image:latest")
             assert cmd is None
 
-    def test_inject_supervisor(self) -> None:
-        """Test supervisor injection into Docker CMD."""
-        original_cmd = ["python", "-m", "server"]
-        modified = inject_supervisor(original_cmd)
-
-        assert modified[0] == "sh"
-        assert modified[1] == "-c"
-        assert "watchfiles" in modified[2]
-        assert "python -m server" in modified[2]
-
 
 class TestImageResolution:
     """Test image name resolution."""
@@ -90,7 +79,7 @@ image = "my-project:latest"
         test_dir.mkdir()
 
         name, source = get_image_name(str(test_dir))
-        assert name == "hud-my-test-project:dev"
+        assert name == "my-test-project:dev"
         assert source == "auto"
 
     def test_update_pyproject_toml(self, tmp_path: Path) -> None:

hud/cli/utils/config.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def get_config_dir() -> Path:
+    """Return the base HUD config directory in the user's home.
+
+    Uses ~/.hud across platforms for consistency with existing registry data.
+    """
+    return Path.home() / ".hud"
+
+
+def get_user_env_path() -> Path:
+    """Return the path to the persistent user-level env file (~/.hud/.env)."""
+    return get_config_dir() / ".env"
+
+
+def ensure_config_dir() -> Path:
+    """Ensure the HUD config directory exists and return it."""
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def parse_env_file(contents: str) -> dict[str, str]:
+    """Parse simple KEY=VALUE lines into a dict.
+
+    - Ignores blank lines and lines starting with '#'.
+    - Does not perform variable substitution or quoting.
+    """
+    data: dict[str, str] = {}
+    for raw_line in contents.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        key = key.strip()
+        value = value.strip()
+        if key:
+            data[key] = value
+    return data
+
+
+def render_env_file(env: dict[str, str]) -> str:
+    """Render a dict of env values to KEY=VALUE lines with a header."""
+    header = [
+        "# HUD CLI persistent environment file",
+        "# Keys set via `hud set KEY=VALUE`",
+        "# This file is read after process env and project .env",
+        "# so project overrides take precedence over these defaults.",
+        "",
+    ]
+    body = [f"{key}={env[key]}" for key in sorted(env.keys())]
+    return "\n".join([*header, *body, ""])
+
+
+def load_env_file(path: Path | None = None) -> dict[str, str]:
+    """Load env assignments from the given path (defaults to ~/.hud/.env)."""
+    env_path = path or get_user_env_path()
+    if not env_path.exists():
+        return {}
+    try:
+        contents = env_path.read_text(encoding="utf-8")
+    except Exception:
+        return {}
+    return parse_env_file(contents)
+
+
+def save_env_file(env: dict[str, str], path: Path | None = None) -> Path:
+    """Write env assignments to the given path and return the path."""
+    ensure_config_dir()
+    env_path = path or get_user_env_path()
+    rendered = render_env_file(env)
+    env_path.write_text(rendered, encoding="utf-8")
+    return env_path
+
+
+def set_env_values(values: dict[str, str]) -> Path:
+    """Persist provided KEY=VALUE pairs into ~/.hud/.env and return the path."""
+    current = load_env_file()
+    current.update(values)
+    return save_env_file(current)

hud/cli/utils/docker.py

@@ -36,45 +36,6 @@ def get_docker_cmd(image: str) -> list[str] | None:
         return None
 
 
-def inject_supervisor(cmd: list[str]) -> list[str]:
-    """
-    Inject watchfiles CLI supervisor into a Docker CMD.
-
-    For shell commands, we inject before the last exec command.
-    For direct commands, we wrap the entire command.
-
-    Args:
-        cmd: Original Docker CMD
-
-    Returns:
-        Modified CMD with watchfiles supervisor injected
-    """
-    if not cmd:
-        return cmd
-
-    # Handle shell commands that might have background processes
-    if cmd[0] in ["sh", "bash"] and len(cmd) >= 3 and cmd[1] == "-c":
-        shell_cmd = cmd[2]
-
-        # Look for 'exec' in the shell command - this is the last command
-        if " exec " in shell_cmd:
-            # Replace only the exec'd command with watchfiles
-            parts = shell_cmd.rsplit(" exec ", 1)
-            if len(parts) == 2:
-                # Extract the actual command after exec
-                last_cmd = parts[1].strip()
-                # Use watchfiles with logs redirected to stderr (which won't interfere with MCP on stdout)  # noqa: E501
-                new_shell_cmd = f"{parts[0]} exec watchfiles --verbose '{last_cmd}' /app/src"
-                return [cmd[0], cmd[1], new_shell_cmd]
-        else:
-            # No exec, the whole thing is the command
-            return ["sh", "-c", f"watchfiles --verbose '{shell_cmd}' /app/src"]
-
-    # Direct command - wrap with watchfiles
-    watchfiles_cmd = " ".join(cmd)
-    return ["sh", "-c", f"watchfiles --verbose '{watchfiles_cmd}' /app/src"]
-
-
 def image_exists(image_name: str) -> bool:
     """Check if a Docker image exists locally."""
     result = subprocess.run(  # noqa: S603
@@ -121,6 +82,27 @@ def generate_container_name(identifier: str, prefix: str = "hud") -> str:
     return f"{prefix}-{safe_name}"
 
 
+def build_run_command(image: str, docker_args: list[str] | None = None) -> list[str]:
+    """Construct a standard docker run command used across CLI commands.
+
+    Args:
+        image: Docker image name to run
+        docker_args: Additional docker args to pass before the image
+
+    Returns:
+        The docker run command list
+    """
+    args = docker_args or []
+    return [
+        "docker",
+        "run",
+        "--rm",
+        "-i",
+        *args,
+        image,
+    ]
+
+
 def _emit_docker_hints(error_text: str) -> None:
     """Parse common Docker connectivity errors and print platform-specific hints."""
     from hud.utils.hud_console import hud_console

hud/cli/utils/environment.py

@@ -33,14 +33,15 @@ def get_image_name(directory: str | Path, image_override: str | None = None) ->
         except Exception:
             hud_console.error("Error loading pyproject.toml")
 
-    # Auto-generate with :dev tag
+    # Auto-generate with :dev tag (replace underscores with hyphens)
     dir_path = Path(directory).resolve()  # Get absolute path first
     dir_name = dir_path.name
     if not dir_name or dir_name == ".":
         # If we're in root or have empty name, use parent directory
         dir_name = dir_path.parent.name
-    clean_name = dir_name.replace("_", "-")
-    return f"hud-{clean_name}:dev", "auto"
+    # Replace underscores with hyphens for Docker image names
+    dir_name = dir_name.replace("_", "-")
+    return f"{dir_name}:dev", "auto"
 
 
 def update_pyproject_toml(directory: str | Path, image_name: str, silent: bool = False) -> None:

hud/cli/utils/interactive.py

@@ -39,7 +39,8 @@ class InteractiveMCPTester:
         """Connect to the MCP server."""
         try:
             # Create MCP config for HTTP transport
-            config = {"server": {"url": self.server_url}}
+            # Note: We explicitly set auth to None to prevent OAuth discovery attempts
+            config = {"server": {"url": self.server_url, "auth": None}}
 
             self.client = MCPClient(
                 mcp_config=config,

hud/cli/utils/local_runner.py

@@ -0,0 +1,204 @@
+"""Run local Python files as MCP servers with reload support."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import os
+import signal
+import subprocess
+import sys
+from pathlib import Path
+
+from hud.utils.hud_console import HUDConsole
+
+hud_console = HUDConsole()
+
+
+async def run_with_reload(
+    server_file: str,
+    transport: str = "stdio",
+    port: int | None = None,
+    verbose: bool = False,
+    extra_args: list[str] | None = None,
+) -> None:
+    """Run Python server with auto-reload functionality."""
+    try:
+        import watchfiles
+    except ImportError:
+        hud_console.error(
+            "watchfiles is required for --reload. Install with: pip install watchfiles"
+        )
+        sys.exit(1)
+
+    # Parse server file path
+    if ":" in server_file:
+        file_path, _ = server_file.split(":", 1)
+    else:
+        file_path = server_file
+
+    file_path = Path(file_path).resolve()
+    if not file_path.exists():
+        hud_console.error(f"Server file not found: {file_path}")
+        sys.exit(1)
+
+    # Watch the directory containing the server file (like uvicorn)
+    watch_dir = file_path.parent
+
+    # Build command
+    cmd = [sys.executable, "-m", "fastmcp.cli", "run", server_file]
+    if transport:
+        cmd.extend(["--transport", transport])
+    if port and transport == "http":
+        cmd.extend(["--port", str(port)])
+    cmd.append("--no-banner")
+    if verbose:
+        cmd.extend(["--log-level", "DEBUG"])
+    if extra_args:
+        cmd.append("--")
+        cmd.extend(extra_args)
+
+    # Filter for Python files and important config files
+    def should_reload(change: watchfiles.Change, path: str) -> bool:
+        path_obj = Path(path)
+        # Ignore common non-code files
+        if any(part.startswith(".") for part in path_obj.parts):
+            return False
+        if "__pycache__" in path_obj.parts:
+            return False
+        return path_obj.suffix in {".py", ".json", ".toml", ".yaml", ".yml"}
+
+    process = None
+
+    async def run_server() -> int:
+        """Run the server process."""
+        nonlocal process
+
+        # For stdio transport, we need special handling to preserve stdout
+        if transport == "stdio":
+            # All server logs must go to stderr
+            env = os.environ.copy()
+            env["PYTHONUNBUFFERED"] = "1"
+
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdin=sys.stdin,
+                stdout=sys.stdout,  # Direct passthrough for MCP
+                stderr=sys.stderr,  # Logs and errors
+                env=env,
+            )
+        else:
+            # For HTTP transport, normal subprocess
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdin=sys.stdin,
+                stdout=sys.stdout,
+                stderr=sys.stderr,
+            )
+
+        return await process.wait()
+
+    async def stop_server() -> None:
+        """Stop the server process gracefully."""
+        if process and process.returncode is None:
+            if sys.platform == "win32":
+                # Windows: terminate directly
+                process.terminate()
+            else:
+                # Unix: send SIGINT for hot reload
+                process.send_signal(signal.SIGINT)
+
+            # Wait for graceful shutdown
+            try:
+                await asyncio.wait_for(process.wait(), timeout=5.0)
+            except TimeoutError:
+                # Force kill if not responding
+                if verbose:
+                    hud_console.warning("Server didn't stop gracefully, forcing shutdown...")
+                process.kill()
+                await process.wait()
+
+    # Initial server start
+    server_task = asyncio.create_task(run_server())
+
+    try:
+        # Watch for file changes
+        async for changes in watchfiles.awatch(watch_dir):
+            # Check if any change should trigger reload
+            if any(should_reload(change, path) for change, path in changes):
+                changed_files = [
+                    path for _, path in changes if should_reload(watchfiles.Change.modified, path)
+                ]
+                if verbose:
+                    for file in changed_files[:3]:  # Show first 3 files
+                        hud_console.info(f"File changed: {Path(file).relative_to(watch_dir)}")
+                    if len(changed_files) > 3:
+                        hud_console.info(f"... and {len(changed_files) - 3} more files")
+
+                hud_console.info("🔄 Reloading server...")
+
+                # Stop current server
+                await stop_server()
+
+                # Small delay to ensure clean restart
+                await asyncio.sleep(0.1)
+
+                # Start new server
+                server_task = asyncio.create_task(run_server())
+
+    except KeyboardInterrupt:
+        hud_console.info("\n👋 Shutting down...")
+        await stop_server()
+    except Exception as e:
+        if verbose:
+            hud_console.error(f"Reload error: {e}")
+        await stop_server()
+        raise
+    finally:
+        # Ensure server is stopped
+        if server_task and not server_task.done():
+            server_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await server_task
+
+
+def run_local_server(
+    server_file: str,
+    transport: str = "stdio",
+    port: int | None = None,
+    verbose: bool = False,
+    reload: bool = False,
+    extra_args: list[str] | None = None,
+) -> None:
+    """Run a local Python file as an MCP server."""
+    if reload:
+        # Run with reload support
+        asyncio.run(
+            run_with_reload(
+                server_file,
+                transport=transport,
+                port=port,
+                verbose=verbose,
+                extra_args=extra_args,
+            )
+        )
+    else:
+        # Run directly without reload
+        cmd = [sys.executable, "-m", "fastmcp.cli", "run", server_file]
+        if transport:
+            cmd.extend(["--transport", transport])
+        if port and transport == "http":
+            cmd.extend(["--port", str(port)])
+        cmd.append("--no-banner")
+        if verbose:
+            cmd.extend(["--log-level", "DEBUG"])
+        if extra_args:
+            cmd.append("--")
+            cmd.extend(extra_args)
+
+        try:
+            result = subprocess.run(cmd)  # noqa: S603
+            sys.exit(result.returncode)
+        except KeyboardInterrupt:
+            hud_console.info("\n👋 Shutting down...")
+            sys.exit(0)

hud/cli/utils/metadata.py

@@ -161,7 +161,9 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
         console.print(f"  1. Pull it first: [cyan]hud pull {reference}[/cyan]")
         console.print(f"  2. Run live analysis: [cyan]hud analyze {reference} --live[/cyan]")
         if not settings.api_key:
-            console.print("  3. Set HUD_API_KEY for private environments")
+            console.print(
+                "  3. Set HUD_API_KEY in your environment or run: hud set HUD_API_KEY=your-key-here"
+            )
         return
 
     # Convert lock data to analysis format