hud-python 0.4.11__py3-none-any.whl → 0.4.13__py3-none-any.whl

hud/cli/{interactive.py → utils/interactive.py}

@@ -112,52 +112,103 @@ class InteractiveMCPTester:
         choices = []
         tool_map = {}
 
-        for _, tool in enumerate(self.tools):
-            # Create display name
+        # Group tools by hub for better organization
+        hub_groups = {}
+        regular_tools = []
+
+        for tool in self.tools:
             if "/" in tool.name:
                 hub, name = tool.name.split("/", 1)
-                display = f"[{hub}] {name}"
+                if hub not in hub_groups:
+                    hub_groups[hub] = []
+                hub_groups[hub].append((name, tool))
             else:
-                display = tool.name
+                regular_tools.append(tool)
+
+        # Add regular tools first
+        if regular_tools:
+            # Add a separator for regular tools section
+            if len(hub_groups) > 0:
+                choices.append("───── Regular Tools ─────")
+
+            for tool in regular_tools:
+                # Format: Bold tool name with color + dim description
+                if tool.description:
+                    display = f"• {tool.name} │ {tool.description}"
+                else:
+                    display = f"• {tool.name}"
+
+                choices.append(display)
+                tool_map[display] = tool
 
-            # Add description if available
-            if tool.description:
-                display += f" - {tool.description}"
+        # Add hub-grouped tools with visual separation
+        for hub_name, tools in sorted(hub_groups.items()):
+            # Add a visual separator for each hub
+            choices.append(f"───── {hub_name} ─────")
 
-            choices.append(display)
-            tool_map[display] = tool
+            for name, tool in sorted(tools, key=lambda x: x[0]):
+                # Format with hub indicator and better separation
+                if tool.description:
+                    # Remove redundant description text
+                    desc = tool.description
+                    # Truncate long descriptions
+                    if len(desc) > 60:
+                        desc = desc[:57] + "..."
+                    display = f"• {name} │ {desc}"
+                else:
+                    display = f"• {name}"
+
+                choices.append(display)
+                tool_map[display] = tool
 
-        # Add quit option
+        # Add quit option with spacing
+        choices.append("─────────────────────")
         choices.append("❌ Quit")
 
         # Show selection menu with arrow keys
         console.print("\n[cyan]Select a tool (use arrow keys):[/cyan]")
 
         try:
-            # Use questionary's async select with custom styling
+            # Create custom Choice objects for better formatting
+            from questionary import Choice
+
+            formatted_choices = []
+            for choice in choices:
+                if choice.startswith("─────"):
+                    # Separator - make it unselectable and styled
+                    formatted_choices.append(Choice(title=choice, disabled=True, shortcut_key=None))  # type: ignore[arg-type]
+                elif choice == "❌ Quit":
+                    formatted_choices.append(choice)
+                else:
+                    formatted_choices.append(choice)
+
+            # Use questionary's async select with enhanced styling
             selected = await questionary.select(
                 "",
-                choices=choices,
+                choices=formatted_choices,
                 style=questionary.Style(
                     [
                         ("question", ""),
-                        ("pointer", "fg:#ff9d00 bold"),
-                        ("highlighted", "fg:#ff9d00 bold"),
-                        ("selected", "fg:#cc5454"),
-                        ("separator", "fg:#6c6c6c"),
-                        ("instruction", "fg:#858585 italic"),
+                        ("pointer", "fg:#ff9d00 bold"),  # Orange pointer
+                        ("highlighted", "fg:#00d7ff bold"),  # Bright cyan for highlighted
+                        ("selected", "fg:#00ff00 bold"),  # Green for selected
+                        ("separator", "fg:#666666"),  # Gray for separators
+                        ("instruction", "fg:#858585 italic"),  # Dim instructions
+                        ("disabled", "fg:#666666"),  # Gray for disabled items
+                        ("text", "fg:#ffffff"),  # White text
                     ]
                 ),
+                instruction="(Use ↑/↓ arrows, Enter to select, Esc to cancel)",
             ).unsafe_ask_async()
 
             if selected is None:
                 console.print("[yellow]No selection made (ESC or Ctrl+C pressed)[/yellow]")
                 return None
 
-            if selected == "❌ Quit":
+            if selected == "❌ Quit" or selected.startswith("─────"):
                 return None
 
-            return tool_map[selected]
+            return tool_map.get(selected)
 
         except KeyboardInterrupt:
             console.print("[yellow]Interrupted by user[/yellow]")
@@ -236,6 +287,27 @@ class InteractiveMCPTester:
                     if not value_str and not is_required:
                         continue
                     value = [v.strip() for v in value_str.split(",")]
+                elif prop_type == "object":
+                    # For object types, allow JSON input
+                    console.print(f"[dim]Enter JSON object for {prop_name}:[/dim]")
+                    value_str = await questionary.text(
+                        prompt + " (JSON format)", default="{}"
+                    ).unsafe_ask_async()
+                    if not value_str and not is_required:
+                        continue
+                    try:
+                        value = json.loads(value_str)
+                    except json.JSONDecodeError as e:
+                        console.print(f"[red]Invalid JSON: {e}[/red]")
+                        # Try again
+                        value_str = await questionary.text(
+                            prompt + " (JSON format, please fix the error)", default=value_str
+                        ).unsafe_ask_async()
+                        try:
+                            value = json.loads(value_str)
+                        except json.JSONDecodeError:
+                            console.print("[red]Still invalid JSON, using empty object[/red]")
+                            value = {}
                 else:  # string or unknown
                     value = await questionary.text(prompt, default="").unsafe_ask_async()
                     if not value and not is_required:

hud/cli/{analyze_metadata.py → utils/metadata.py}

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from pathlib import Path
 from urllib.parse import quote
 
 import requests
@@ -13,7 +12,11 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 from hud.settings import settings
 from hud.utils.design import HUDDesign
 
-from .registry import get_registry_dir, list_registry_entries, extract_digest_from_image, load_from_registry
+from .registry import (
+    extract_digest_from_image,
+    list_registry_entries,
+    load_from_registry,
+)
 
 console = Console()
 design = HUDDesign()
@@ -60,13 +63,13 @@ def check_local_cache(reference: str) -> dict | None:
     lock_data = load_from_registry(digest)
     if lock_data:
         return lock_data
-    
+
     # If not found and reference has a name, search by name pattern
     if "/" in reference:
         # Look for any cached version of this image
         ref_base = reference.split("@")[0].split(":")[0]
-        
-        for digest, lock_file in list_registry_entries():
+
+        for _, lock_file in list_registry_entries():
             try:
                 with open(lock_file) as f:
                     lock_data = yaml.safe_load(f)
@@ -78,8 +81,8 @@ 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:
-                continue
-    
+                design.error("Error loading lock file")
+
     return None
 
 
@@ -87,7 +90,7 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
     """Analyze environment from cached or registry metadata."""
     import json
 
-    from .analyze import display_interactive, display_markdown
+    from hud.cli.analyze import display_interactive, display_markdown
 
     design.header("MCP Environment Analysis", icon="🔍")
     design.info(f"Looking up: {reference}")
@@ -146,6 +149,7 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
 
                 # Save to local cache for next time
                 from .registry import save_to_registry
+
                 save_to_registry(lock_data, lock_data.get("image", ""), verbose=False)
             else:
                 progress.update(task, description="[red]✗ Not found[/red]")

hud/cli/{registry.py → utils/registry.py}

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, Optional, Any
+from typing import Any
 
 import yaml
 
@@ -17,10 +17,10 @@ def get_registry_dir() -> Path:
 
 def extract_digest_from_image(image_ref: str) -> str:
     """Extract a digest identifier from a Docker image reference.
-    
+
     Args:
         image_ref: Docker image reference (e.g., "image:tag@sha256:abc123...")
-        
+
     Returns:
         Digest string for use as directory name (max 12 chars)
     """
@@ -41,13 +41,13 @@ def extract_digest_from_image(image_ref: str) -> str:
 
 def extract_name_and_tag(image_ref: str) -> tuple[str, str]:
     """Extract organization/name and tag from Docker image reference.
-    
+
     Args:
         image_ref: Docker image reference
-        
+
     Returns:
         Tuple of (name, tag) where name includes org/repo
-        
+
     Examples:
         docker.io/hudpython/test_init:latest@sha256:... -> (hudpython/test_init, latest)
         hudpython/myenv:v1.0 -> (hudpython/myenv, v1.0)
@@ -56,54 +56,52 @@ def extract_name_and_tag(image_ref: str) -> tuple[str, str]:
     # Remove digest if present
     if "@" in image_ref:
         image_ref = image_ref.split("@")[0]
-    
+
     # Remove registry prefix if present
     if image_ref.startswith(("docker.io/", "registry-1.docker.io/", "index.docker.io/")):
         image_ref = "/".join(image_ref.split("/")[1:])
-    
+
     # Extract tag
     if ":" in image_ref:
         name, tag = image_ref.rsplit(":", 1)
     else:
         name = image_ref
         tag = "latest"
-    
+
     return name, tag
 
 
 def save_to_registry(
-    lock_data: Dict[str, Any], 
-    image_ref: str,
-    verbose: bool = False
-) -> Optional[Path]:
+    lock_data: dict[str, Any], image_ref: str, verbose: bool = False
+) -> Path | None:
     """Save environment lock data to the local registry.
-    
+
     Args:
         lock_data: The lock file data to save
         image_ref: Docker image reference for digest extraction
         verbose: Whether to show verbose output
-        
+
     Returns:
         Path to the saved lock file, or None if save failed
     """
     design = HUDDesign()
-    
+
     try:
         # Extract digest for registry storage
         digest = extract_digest_from_image(image_ref)
-        
+
         # Store under ~/.hud/envs/<digest>/
         local_env_dir = get_registry_dir() / digest
         local_env_dir.mkdir(parents=True, exist_ok=True)
-        
+
         local_lock_path = local_env_dir / "hud.lock.yaml"
         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}")
         if verbose:
             design.info(f"Registry location: {local_lock_path}")
-            
+
         return local_lock_path
     except Exception as e:
         if verbose:
@@ -111,20 +109,20 @@ def save_to_registry(
         return None
 
 
-def load_from_registry(digest: str) -> Optional[Dict[str, Any]]:
+def load_from_registry(digest: str) -> dict[str, Any] | None:
     """Load environment lock data from the local registry.
-    
+
     Args:
         digest: The digest/identifier of the environment
-        
+
     Returns:
         Lock data dictionary, or None if not found
     """
     lock_path = get_registry_dir() / digest / "hud.lock.yaml"
-    
+
     if not lock_path.exists():
         return None
-        
+
     try:
         with open(lock_path) as f:
             return yaml.safe_load(f)
@@ -134,22 +132,22 @@ def load_from_registry(digest: str) -> Optional[Dict[str, Any]]:
 
 def list_registry_entries() -> list[tuple[str, Path]]:
     """List all entries in the local registry.
-    
+
     Returns:
         List of (digest, lock_path) tuples
     """
     registry_dir = get_registry_dir()
-    
+
     if not registry_dir.exists():
         return []
-        
+
     entries = []
     for digest_dir in registry_dir.iterdir():
         if not digest_dir.is_dir():
             continue
-            
+
         lock_file = digest_dir / "hud.lock.yaml"
         if lock_file.exists():
             entries.append((digest_dir.name, lock_file))
-            
+
     return entries

hud/cli/{remote_runner.py → utils/remote_runner.py}

@@ -199,7 +199,7 @@ async def run_remote_http(
     verbose: bool = False,
 ) -> None:
     """Run remote MCP server with HTTP transport."""
-    from .utils import find_free_port
+    from .logging import find_free_port
 
     # Find available port
     actual_port = find_free_port(port)

hud/cli/utils/runner.py

@@ -0,0 +1,134 @@
+"""Run Docker images as MCP servers."""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+import sys
+
+from hud.utils.design import HUDDesign
+
+from .logging import find_free_port
+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
+
+    # Build docker command
+    docker_cmd = ["docker", "run", "--rm", "-i", *docker_args, image]
+
+    if verbose:
+        design.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...")
+        sys.exit(0)
+    except Exception as e:
+        design.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()
+
+    # Create server manager
+    server_manager = MCPServerManager(image, docker_args)
+
+    # Find available port
+    actual_port = find_free_port(port)
+    if actual_port is None:
+        design.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")
+
+    # Clean up any existing container
+    server_manager.cleanup_container()
+
+    # Build docker command
+    docker_cmd = server_manager.build_docker_command()
+
+    # Create MCP config
+    config = server_manager.create_mcp_config(docker_cmd)
+
+    # Create proxy
+    proxy = server_manager.create_proxy(config)
+
+    # Show header
+    design.info("")  # Empty line
+    design.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")
+
+    try:
+        await server_manager.run_http_server(proxy, actual_port, verbose)
+    except KeyboardInterrupt:
+        design.info("\n👋 Shutting down...")
+    finally:
+        # Clean up container
+        server_manager.cleanup_container()
+
+
+async def run_http_server_interactive(
+    image: str, docker_args: list[str], port: int, verbose: bool
+) -> None:
+    """Run Docker image as HTTP MCP server with interactive testing."""
+    # Create server manager
+    server_manager = MCPServerManager(image, docker_args)
+
+    # Use the shared utility function
+    await run_server_with_interactive(server_manager, port, verbose)
+
+
+def run_mcp_server(
+    image: str,
+    docker_args: list[str],
+    transport: str,
+    port: int,
+    verbose: bool,
+    interactive: bool = False,
+) -> None:
+    """Run Docker image as MCP server with specified transport."""
+    if transport == "stdio":
+        if interactive:
+            design = HUDDesign()
+            design.error("Interactive mode requires HTTP transport")
+            sys.exit(1)
+        run_stdio_server(image, docker_args, verbose)
+    elif transport == "http":
+        if interactive:
+            # Run in interactive mode
+            asyncio.run(run_http_server_interactive(image, docker_args, port, verbose))
+        else:
+            try:
+                asyncio.run(run_http_server(image, docker_args, port, verbose))
+            except Exception as e:
+                # Suppress the graceful shutdown errors
+                if not any(
+                    x in str(e)
+                    for x in [
+                        "timeout graceful shutdown exceeded",
+                        "Cancel 0 running task(s)",
+                        "Application shutdown complete",
+                    ]
+                ):
+                    design = HUDDesign()
+                    design.error(f"Unexpected error: {e}")
+    else:
+        design = HUDDesign()
+        design.error(f"Unknown transport: {transport}")
+        sys.exit(1)