hud-python 0.4.22__py3-none-any.whl → 0.4.24__py3-none-any.whl

hud/cli/tests/test_push.py

@@ -110,24 +110,24 @@ class TestGetDockerImageLabels:
 class TestPushEnvironment:
     """Test the main push_environment function."""
 
-    @mock.patch("hud.cli.push.HUDDesign")
-    def test_push_no_lock_file(self, mock_design_class, tmp_path):
+    @mock.patch("hud.cli.push.HUDConsole")
+    def test_push_no_lock_file(self, mock_hud_console_class, tmp_path):
         """Test pushing when no lock file exists."""
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
 
         with pytest.raises(typer.Exit) as exc_info:
             push_environment(str(tmp_path))
 
         assert exc_info.value.exit_code == 1
-        mock_design.error.assert_called()
+        mock_hud_console.error.assert_called()
 
-    @mock.patch("hud.cli.push.HUDDesign")
+    @mock.patch("hud.cli.push.HUDConsole")
     @mock.patch("hud.settings.settings")
-    def test_push_no_api_key(self, mock_settings, mock_design_class, tmp_path):
+    def test_push_no_api_key(self, mock_settings, mock_hud_console_class, tmp_path):
         """Test pushing without API key."""
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
         mock_settings.api_key = None
 
         # Create lock file
@@ -144,10 +144,10 @@ class TestPushEnvironment:
     @mock.patch("subprocess.run")
     @mock.patch("hud.cli.push.get_docker_username")
     @mock.patch("hud.settings.settings")
-    @mock.patch("hud.cli.push.HUDDesign")
+    @mock.patch("hud.cli.push.HUDConsole")
     def test_push_auto_detect_username(
         self,
-        mock_design_class,
+        mock_hud_console_class,
         mock_settings,
         mock_get_username,
         mock_run,
@@ -157,8 +157,8 @@ class TestPushEnvironment:
     ):
         """Test auto-detecting Docker username and pushing."""
         # Setup mocks
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
         mock_settings.api_key = "test-key"
         mock_settings.hud_telemetry_url = "https://api.hud.test"
         mock_get_username.return_value = "testuser"
@@ -206,11 +206,11 @@ class TestPushEnvironment:
 
     @mock.patch("subprocess.run")
     @mock.patch("hud.settings.settings")
-    @mock.patch("hud.cli.push.HUDDesign")
-    def test_push_explicit_image(self, mock_design_class, mock_settings, mock_run, tmp_path):
+    @mock.patch("hud.cli.push.HUDConsole")
+    def test_push_explicit_image(self, mock_hud_console_class, mock_settings, mock_run, tmp_path):
         """Test pushing with explicit image name."""
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
         mock_settings.api_key = "test-key"
 
         # Create lock file
@@ -227,11 +227,13 @@ class TestPushEnvironment:
     @mock.patch("subprocess.Popen")
     @mock.patch("subprocess.run")
     @mock.patch("hud.settings.settings")
-    @mock.patch("hud.cli.push.HUDDesign")
-    def test_push_with_tag(self, mock_design_class, mock_settings, mock_run, mock_popen, tmp_path):
+    @mock.patch("hud.cli.push.HUDConsole")
+    def test_push_with_tag(
+        self, mock_hud_console_class, mock_settings, mock_run, mock_popen, tmp_path
+    ):
         """Test pushing with explicit tag."""
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
         mock_settings.api_key = "test-key"
 
         # Create lock file
@@ -269,11 +271,11 @@ class TestPushEnvironment:
         assert "user/test:v2.0" in tag_call[0][0][0]
 
     @mock.patch("subprocess.Popen")
-    @mock.patch("hud.cli.push.HUDDesign")
-    def test_push_docker_failure(self, mock_design_class, mock_popen):
+    @mock.patch("hud.cli.push.HUDConsole")
+    def test_push_docker_failure(self, mock_hud_console_class, mock_popen):
         """Test handling Docker push failure."""
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
 
         # Mock docker push failure
         mock_process = mock.Mock()
@@ -293,13 +295,13 @@ class TestPushEnvironment:
     @mock.patch("hud.cli.push.get_docker_image_labels")
     @mock.patch("subprocess.run")
     @mock.patch("hud.settings.settings")
-    @mock.patch("hud.cli.push.HUDDesign")
+    @mock.patch("hud.cli.push.HUDConsole")
     def test_push_with_labels(
-        self, mock_design_class, mock_settings, mock_run, mock_get_labels, tmp_path
+        self, mock_hud_console_class, mock_settings, mock_run, mock_get_labels, tmp_path
     ):
         """Test pushing with image labels."""
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
         mock_settings.api_key = "test-key"
 
         # Create lock file

hud/cli/tests/test_registry.py

@@ -118,11 +118,11 @@ class TestExtractNameAndTag:
 class TestSaveToRegistry:
     """Test saving to local registry."""
 
-    @mock.patch("hud.cli.utils.registry.HUDDesign")
-    def test_save_success(self, mock_design_class, tmp_path):
+    @mock.patch("hud.cli.utils.registry.HUDConsole")
+    def test_save_success(self, mock_hud_console_class, tmp_path):
         """Test successful save to registry."""
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
 
         # Mock home directory
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
@@ -142,13 +142,13 @@ class TestSaveToRegistry:
             # Verify directory structure
             assert result.parent.name == "abc123def456"
 
-            mock_design.success.assert_called_once()
+            mock_hud_console.success.assert_called_once()
 
-    @mock.patch("hud.cli.utils.registry.HUDDesign")
-    def test_save_verbose(self, mock_design_class, tmp_path):
+    @mock.patch("hud.cli.utils.registry.HUDConsole")
+    def test_save_verbose(self, mock_hud_console_class, tmp_path):
         """Test save with verbose output."""
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
 
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             lock_data = {"image": "test:v1"}
@@ -157,13 +157,13 @@ class TestSaveToRegistry:
 
             assert result is not None
             # Should show verbose info
-            assert mock_design.info.call_count >= 1
+            assert mock_hud_console.info.call_count >= 1
 
-    @mock.patch("hud.cli.utils.registry.HUDDesign")
-    def test_save_failure(self, mock_design_class):
+    @mock.patch("hud.cli.utils.registry.HUDConsole")
+    def test_save_failure(self, mock_hud_console_class):
         """Test handling save failure."""
-        mock_design = mock.Mock()
-        mock_design_class.return_value = mock_design
+        mock_hud_console = mock.Mock()
+        mock_hud_console_class.return_value = mock_hud_console
 
         # Mock file operations to fail
         with (
@@ -175,7 +175,7 @@ class TestSaveToRegistry:
             result = save_to_registry(lock_data, "test:latest", verbose=True)
 
             assert result is None
-            mock_design.warning.assert_called_once()
+            mock_hud_console.warning.assert_called_once()
 
 
 class TestLoadFromRegistry:

hud/cli/utils/environment.py

@@ -7,9 +7,9 @@ from pathlib import Path
 
 import toml
 
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 
-design = HUDDesign()
+hud_console = HUDConsole()
 
 
 def get_image_name(directory: str | Path, image_override: str | None = None) -> tuple[str, str]:
@@ -31,7 +31,7 @@ def get_image_name(directory: str | Path, image_override: str | None = None) ->
             if config.get("tool", {}).get("hud", {}).get("image"):
                 return config["tool"]["hud"]["image"], "cache"
         except Exception:
-            design.error("Error loading pyproject.toml")
+            hud_console.error("Error loading pyproject.toml")
 
     # Auto-generate with :dev tag
     dir_path = Path(directory).resolve()  # Get absolute path first
@@ -65,10 +65,10 @@ def update_pyproject_toml(directory: str | Path, image_name: str, silent: bool =
                 toml.dump(config, f)
 
             if not silent:
-                design.success(f"Updated pyproject.toml with image: {image_name}")
+                hud_console.success(f"Updated pyproject.toml with image: {image_name}")
         except Exception as e:
             if not silent:
-                design.warning(f"Could not update pyproject.toml: {e}")
+                hud_console.warning(f"Could not update pyproject.toml: {e}")
 
 
 def build_environment(directory: str | Path, image_name: str, no_cache: bool = False) -> bool:
@@ -82,20 +82,20 @@ def build_environment(directory: str | Path, image_name: str, no_cache: bool = F
         build_cmd.append("--no-cache")
     build_cmd.append(str(directory))
 
-    design.info(f"🔨 Building image: {image_name}{' (no cache)' if no_cache else ''}")
-    design.info("")  # Empty line before Docker output
+    hud_console.info(f"🔨 Building image: {image_name}{' (no cache)' if no_cache else ''}")
+    hud_console.info("")  # Empty line before Docker output
 
     # Just run Docker build directly - it has its own nice live display
     result = subprocess.run(build_cmd)  # noqa: S603
 
     if result.returncode == 0:
-        design.info("")  # Empty line after Docker output
-        design.success(f"Build successful! Image: {image_name}")
+        hud_console.info("")  # Empty line after Docker output
+        hud_console.success(f"Build successful! Image: {image_name}")
         # Update pyproject.toml (silently since we already showed success)
         update_pyproject_toml(directory, image_name, silent=True)
         return True
     else:
-        design.error("Build failed!")
+        hud_console.error("Build failed!")
         return False
 
 
@@ -127,7 +127,7 @@ def is_environment_directory(path: str | Path) -> bool:
 
     # Must have pyproject.toml
     if not (dir_path / "pyproject.toml").exists():
-        design.error("pyproject.toml not found")
+        hud_console.error("pyproject.toml not found")
         return False
 
     return True

hud/cli/utils/interactive.py

@@ -14,7 +14,7 @@ from rich.syntax import Syntax
 from rich.tree import Tree
 
 from hud.clients import MCPClient
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 
 console = Console()
 
@@ -33,7 +33,7 @@ class InteractiveMCPTester:
         self.verbose = verbose
         self.client: MCPClient | None = None
         self.tools: list[Any] = []
-        self.design = HUDDesign()
+        self.console = HUDConsole()
 
     async def connect(self) -> bool:
         """Connect to the MCP server."""
@@ -53,7 +53,7 @@ class InteractiveMCPTester:
 
             return True
         except Exception as e:
-            self.design.error(f"Failed to connect: {e}")
+            self.console.error(f"Failed to connect: {e}")
             return False
 
     async def disconnect(self) -> None:
@@ -361,7 +361,7 @@ class InteractiveMCPTester:
 
     async def run(self) -> None:
         """Run the interactive testing loop."""
-        self.design.header("Interactive MCP Tester")
+        self.console.header("Interactive MCP Tester")
 
         # Connect to server
         console.print(f"[cyan]Connecting to {self.server_url}...[/cyan]")
@@ -397,19 +397,19 @@ class InteractiveMCPTester:
             await self.disconnect()
 
             # Show next steps tutorial
-            self.design.section_title("Next Steps")
-            self.design.info("🏗️  Ready to test with real agents? Run:")
-            self.design.info("    [cyan]hud build[/cyan]")
-            self.design.info("")
-            self.design.info("This will:")
-            self.design.info("  1. Build your environment image")
-            self.design.info("  2. Generate a hud.lock.yaml file")
-            self.design.info("  3. Prepare it for testing with agents")
-            self.design.info("")
-            self.design.info("Then you can:")
-            self.design.info("  • Test locally: [cyan]hud run <image>[/cyan]")
-            self.design.info("  • Push to registry: [cyan]hud push --image <registry/name>[/cyan]")
-            self.design.info("  • Use with agents via the lock file")
+            self.console.section_title("Next Steps")
+            self.console.info("🏗️  Ready to test with real agents? Run:")
+            self.console.info("    [cyan]hud build[/cyan]")
+            self.console.info("")
+            self.console.info("This will:")
+            self.console.info("  1. Build your environment image")
+            self.console.info("  2. Generate a hud.lock.yaml file")
+            self.console.info("  3. Prepare it for testing with agents")
+            self.console.info("")
+            self.console.info("Then you can:")
+            self.console.info("  • Test locally: [cyan]hud run <image>[/cyan]")
+            self.console.info("  • Push to registry: [cyan]hud push --image <registry/name>[/cyan]")
+            self.console.info("  • Use with agents via the lock file")
 
             console.print("\n[dim]Happy testing! 🎉[/dim]")
 

hud/cli/utils/logging.py

@@ -15,18 +15,18 @@ if sys.platform == "win32":
 
 
 class Colors:
-    """ANSI color codes for terminal output."""
-
-    HEADER = "\033[95m"
-    BLUE = "\033[94m"
-    CYAN = "\033[96m"
-    GREEN = "\033[92m"
-    YELLOW = "\033[93m"
-    GOLD = "\033[33m"
-    RED = "\033[91m"
-    GRAY = "\033[90m"
-    ENDC = "\033[0m"
-    BOLD = "\033[1m"
+    """ANSI color codes for terminal output - optimized for both light and dark modes."""
+
+    HEADER = "\033[95m"  # Light magenta
+    BLUE = "\033[94m"  # Light blue
+    CYAN = "\033[96m"  # Light cyan
+    GREEN = "\033[92m"  # Light green
+    YELLOW = "\033[93m"  # Light yellow
+    GOLD = "\033[33m"  # Gold/orange
+    RED = "\033[91m"  # Light red
+    GRAY = "\033[37m"  # Light gray
+    ENDC = "\033[0m"  # Reset
+    BOLD = "\033[1m"  # Bold
 
 
 class CaptureLogger:

hud/cli/utils/metadata.py

@@ -10,7 +10,7 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from hud.settings import settings
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 
 from .registry import (
     extract_digest_from_image,
@@ -19,7 +19,7 @@ from .registry import (
 )
 
 console = Console()
-design = HUDDesign()
+hud_console = HUDConsole()
 
 
 def fetch_lock_from_registry(reference: str) -> dict | None:
@@ -81,7 +81,7 @@ def check_local_cache(reference: str) -> dict | None:
                     if ref_base in img_base or img_base in ref_base:
                         return lock_data
             except Exception:
-                design.error("Error loading lock file")
+                hud_console.error("Error loading lock file")
 
     return None
 
@@ -92,9 +92,9 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
 
     from hud.cli.analyze import display_interactive, display_markdown
 
-    design.header("MCP Environment Analysis", icon="🔍")
-    design.info(f"Looking up: {reference}")
-    design.info("")
+    hud_console.header("MCP Environment Analysis", icon="🔍")
+    hud_console.info(f"Looking up: {reference}")
+    hud_console.info("")
 
     lock_data = None
     source = None
@@ -155,7 +155,7 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
                 progress.update(task, description="[red]✗ Not found[/red]")
 
     if not lock_data:
-        design.error("Environment metadata not found")
+        hud_console.error("Environment metadata not found")
         console.print("\n[yellow]This environment hasn't been analyzed yet.[/yellow]")
         console.print("\nOptions:")
         console.print(f"  1. Pull it first: [cyan]hud pull {reference}[/cyan]")
@@ -205,16 +205,16 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
             )
 
     # Display results
-    design.info("")
+    hud_console.info("")
     if source == "local":
-        design.dim_info("Source:", "Local cache")
+        hud_console.dim_info("Source:", "Local cache")
     else:
-        design.dim_info("Source:", "HUD registry")
+        hud_console.dim_info("Source:", "HUD registry")
 
     if "image" in analysis:
-        design.dim_info("Image:", analysis["image"])
+        hud_console.dim_info("Image:", analysis["image"])
 
-    design.info("")
+    hud_console.info("")
 
     # Display results based on format
     if output_format == "json":

hud/cli/utils/registry.py

@@ -7,7 +7,7 @@ from typing import Any
 
 import yaml
 
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 
 
 def get_registry_dir() -> Path:
@@ -84,7 +84,7 @@ def save_to_registry(
     Returns:
         Path to the saved lock file, or None if save failed
     """
-    design = HUDDesign()
+    hud_console = HUDConsole()
 
     try:
         # Extract digest for registry storage
@@ -98,14 +98,14 @@ def save_to_registry(
         with open(local_lock_path, "w") as f:
             yaml.dump(lock_data, f, default_flow_style=False, sort_keys=False)
 
-        design.success(f"Added to local registry: {digest}")
+        hud_console.success(f"Added to local registry: {digest}")
         if verbose:
-            design.info(f"Registry location: {local_lock_path}")
+            hud_console.info(f"Registry location: {local_lock_path}")
 
         return local_lock_path
     except Exception as e:
         if verbose:
-            design.warning(f"Failed to save to registry: {e}")
+            hud_console.warning(f"Failed to save to registry: {e}")
         return None
 
 

hud/cli/utils/runner.py

@@ -6,7 +6,7 @@ import asyncio
 import subprocess
 import sys
 
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 
 from .logging import find_free_port
 from .server import MCPServerManager, run_server_with_interactive
@@ -14,29 +14,29 @@ from .server import MCPServerManager, run_server_with_interactive
 
 def run_stdio_server(image: str, docker_args: list[str], verbose: bool) -> None:
     """Run Docker image as stdio MCP server (direct passthrough)."""
-    design = HUDDesign()  # Use stderr for stdio mode
+    hud_console = HUDConsole()  # Use stderr for stdio mode
 
     # Build docker command
     docker_cmd = ["docker", "run", "--rm", "-i", *docker_args, image]
 
     if verbose:
-        design.info(f"🐳 Running: {' '.join(docker_cmd)}")
+        hud_console.info(f"🐳 Running: {' '.join(docker_cmd)}")
 
     # Run docker directly with stdio passthrough
     try:
         result = subprocess.run(docker_cmd, stdin=sys.stdin)  # noqa: S603
         sys.exit(result.returncode)
     except KeyboardInterrupt:
-        design.info("\n👋 Shutting down...")
+        hud_console.info("\n👋 Shutting down...")
         sys.exit(0)
     except Exception as e:
-        design.error(f"Error: {e}")
+        hud_console.error(f"Error: {e}")
         sys.exit(1)
 
 
 async def run_http_server(image: str, docker_args: list[str], port: int, verbose: bool) -> None:
     """Run Docker image as HTTP MCP server (proxy mode)."""
-    design = HUDDesign()
+    hud_console = HUDConsole()
 
     # Create server manager
     server_manager = MCPServerManager(image, docker_args)
@@ -44,11 +44,11 @@ async def run_http_server(image: str, docker_args: list[str], port: int, verbose
     # Find available port
     actual_port = find_free_port(port)
     if actual_port is None:
-        design.error(f"No available ports found starting from {port}")
+        hud_console.error(f"No available ports found starting from {port}")
         return
 
     if actual_port != port:
-        design.warning(f"Port {port} in use, using port {actual_port} instead")
+        hud_console.warning(f"Port {port} in use, using port {actual_port} instead")
 
     # Clean up any existing container
     server_manager.cleanup_container()
@@ -63,21 +63,21 @@ async def run_http_server(image: str, docker_args: list[str], port: int, verbose
     proxy = server_manager.create_proxy(config)
 
     # Show header
-    design.info("")  # Empty line
-    design.header("HUD MCP Server", icon="🌐")
+    hud_console.info("")  # Empty line
+    hud_console.header("HUD MCP Server", icon="🌐")
 
     # Show configuration
-    design.section_title("Server Information")
-    design.info(f"Port: {actual_port}")
-    design.info(f"URL: http://localhost:{actual_port}/mcp")
-    design.info(f"Container: {server_manager.container_name}")
-    design.info("")
-    design.progress_message("Press Ctrl+C to stop")
+    hud_console.section_title("Server Information")
+    hud_console.info(f"Port: {actual_port}")
+    hud_console.info(f"URL: http://localhost:{actual_port}/mcp")
+    hud_console.info(f"Container: {server_manager.container_name}")
+    hud_console.info("")
+    hud_console.progress_message("Press Ctrl+C to stop")
 
     try:
         await server_manager.run_http_server(proxy, actual_port, verbose)
     except KeyboardInterrupt:
-        design.info("\n👋 Shutting down...")
+        hud_console.info("\n👋 Shutting down...")
     finally:
         # Clean up container
         server_manager.cleanup_container()
@@ -105,8 +105,8 @@ def run_mcp_server(
     """Run Docker image as MCP server with specified transport."""
     if transport == "stdio":
         if interactive:
-            design = HUDDesign()
-            design.error("Interactive mode requires HTTP transport")
+            hud_console = HUDConsole()
+            hud_console.error("Interactive mode requires HTTP transport")
             sys.exit(1)
         run_stdio_server(image, docker_args, verbose)
     elif transport == "http":
@@ -126,9 +126,9 @@ def run_mcp_server(
                         "Application shutdown complete",
                     ]
                 ):
-                    design = HUDDesign()
-                    design.error(f"Unexpected error: {e}")
+                    hud_console = HUDConsole()
+                    hud_console.error(f"Unexpected error: {e}")
     else:
-        design = HUDDesign()
-        design.error(f"Unknown transport: {transport}")
+        hud_console = HUDConsole()
+        hud_console.error(f"Unknown transport: {transport}")
         sys.exit(1)

hud/cli/utils/server.py

@@ -7,7 +7,7 @@ from typing import Any
 
 from fastmcp import FastMCP
 
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 
 from .docker import generate_container_name, remove_container
 
@@ -24,7 +24,7 @@ class MCPServerManager:
         """
         self.image = image
         self.docker_args = docker_args or []
-        self.design = HUDDesign()
+        self.console = HUDConsole()
         self.container_name = self._generate_container_name()
 
     def _generate_container_name(self) -> str:
@@ -155,7 +155,7 @@ class MCPServerManager:
             pass  # Normal cancellation
         except Exception as e:
             if verbose:
-                self.design.error(f"Server error: {e}")
+                self.console.error(f"Server error: {e}")
             raise
 
 
@@ -174,16 +174,16 @@ async def run_server_with_interactive(
     from .interactive import run_interactive_mode
     from .logging import find_free_port
 
-    design = HUDDesign()
+    hud_console = HUDConsole()
 
     # Find available port
     actual_port = find_free_port(port)
     if actual_port is None:
-        design.error(f"No available ports found starting from {port}")
+        hud_console.error(f"No available ports found starting from {port}")
         return
 
     if actual_port != port:
-        design.warning(f"Port {port} in use, using port {actual_port} instead")
+        hud_console.warning(f"Port {port} in use, using port {actual_port} instead")
 
     # Clean up any existing container
     server_manager.cleanup_container()
@@ -198,16 +198,16 @@ async def run_server_with_interactive(
     proxy = server_manager.create_proxy(config, f"HUD Interactive - {server_manager.image}")
 
     # Show header
-    design.info("")  # Empty line
-    design.header("HUD MCP Server - Interactive Mode", icon="🎮")
+    hud_console.info("")  # Empty line
+    hud_console.header("HUD MCP Server - Interactive Mode", icon="🎮")
 
     # Show configuration
-    design.section_title("Server Information")
-    design.info(f"Image: {server_manager.image}")
-    design.info(f"Port: {actual_port}")
-    design.info(f"URL: http://localhost:{actual_port}/mcp")
-    design.info(f"Container: {server_manager.container_name}")
-    design.info("")
+    hud_console.section_title("Server Information")
+    hud_console.info(f"Image: {server_manager.image}")
+    hud_console.info(f"Port: {actual_port}")
+    hud_console.info(f"URL: http://localhost:{actual_port}/mcp")
+    hud_console.info(f"Container: {server_manager.container_name}")
+    hud_console.info("")
 
     # Create event to signal server is ready
     server_ready = asyncio.Event()
@@ -236,7 +236,7 @@ async def run_server_with_interactive(
         await run_interactive_mode(server_url, verbose=verbose)
 
     except KeyboardInterrupt:
-        design.info("\n👋 Shutting down...")
+        hud_console.info("\n👋 Shutting down...")
     finally:
         # Cancel server task
         if server_task and not server_task.done():
@@ -244,7 +244,7 @@ async def run_server_with_interactive(
             try:
                 await server_task
             except asyncio.CancelledError:
-                design.error("Server task cancelled")
+                hud_console.error("Server task cancelled")
 
         # Clean up container
         server_manager.cleanup_container()