hud-python 0.4.8__py3-none-any.whl → 0.4.10__py3-none-any.whl

hud/cli/push.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import subprocess
 from pathlib import Path
+from urllib.parse import quote
 
 import requests
 import typer
@@ -14,6 +15,12 @@ from hud.settings import settings
 from hud.utils.design import HUDDesign
 
 
+def _get_response_text(response: requests.Response) -> str:
+    try:
+        return response.json().get("detail", "No detail available")
+    except Exception:
+        return response.text
+
 def get_docker_username() -> str | None:
     """Get the current Docker username if logged in."""
     try:
@@ -312,11 +319,11 @@ def push_environment(
     lock_data["image"] = pushed_digest
 
     # Add push information
-    from datetime import datetime
+    from datetime import datetime, UTC
 
     lock_data["push"] = {
         "source": local_image,
-        "pushedAt": datetime.utcnow().isoformat() + "Z",
+        "pushedAt": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
         "registry": pushed_digest.split("/")[0] if "/" in pushed_digest else "docker.io",
     }
 
@@ -331,52 +338,88 @@ def push_environment(
         # Extract org/name:tag from the pushed image
         # e.g., "docker.io/hudpython/test_init:latest@sha256:..." -> "hudpython/test_init:latest"
         # e.g., "hudpython/test_init:v1.0" -> "hudpython/test_init:v1.0"
-        registry_parts = pushed_digest.split("/")
+        # Use the original image name for the registry path, not the digest
+        # The digest might not contain the tag information
+        registry_image = image  # This is the image we tagged and pushed (e.g., hudpython/hud-text-2048:0.1.2)
+        
+        # Remove any registry prefix for the HUD registry path
+        registry_parts = registry_image.split("/")
         if len(registry_parts) >= 2:
             # Handle docker.io/org/name or just org/name
-            if registry_parts[0] in ["docker.io", "registry-1.docker.io", "index.docker.io"]:
-                # Remove registry prefix and get org/name:tag
-                name_with_tag = "/".join(registry_parts[1:]).split("@")[0]
+            if registry_parts[0] in ["docker.io", "registry-1.docker.io", "index.docker.io", "ghcr.io"]:
+                # Remove registry prefix
+                name_with_tag = "/".join(registry_parts[1:])
+            elif "." in registry_parts[0] or ":" in registry_parts[0]:
+                # Likely a registry URL (has dots or port)
+                name_with_tag = "/".join(registry_parts[1:])
             else:
-                # Just org/name:tag
-                name_with_tag = "/".join(registry_parts[:2]).split("@")[0]
-
-            # If no tag specified, use "latest"
-            if ":" not in name_with_tag:
-                name_with_tag = f"{name_with_tag}:latest"
-
-            # Upload to HUD registry
-            design.progress_message("Uploading metadata to HUD registry...")
-
-            registry_url = f"{settings.hud_telemetry_url.rstrip('/')}/registry/envs/{name_with_tag}"
-
-            # Prepare the payload
-            payload = {
-                "lock": yaml.dump(lock_data, default_flow_style=False, sort_keys=False),
-                "digest": pushed_digest.split("@")[-1] if "@" in pushed_digest else "latest",
-            }
-
-            headers = {"Authorization": f"Bearer {settings.api_key}"}
-
-            response = requests.post(registry_url, json=payload, headers=headers, timeout=10)
+                # No registry prefix, use as-is
+                name_with_tag = registry_image
+        else:
+            name_with_tag = registry_image
 
-            if response.status_code in [200, 201]:
-                design.success("Metadata uploaded to HUD registry")
-                design.info("Others can now pull with:")
-                design.command_example(f"hud pull {name_with_tag}")
-                design.info("")
-            else:
-                design.warning(f"Could not upload to registry: {response.status_code}")
-                if verbose:
-                    design.info(f"Response: {response.text}")
-                design.info("Share hud.lock.yaml manually\n")
+        # The image variable already has the tag, no need to add :latest
+        
+        # Validate the image format
+        if not name_with_tag:
+            design.warning("Could not determine image name for registry upload")
+            raise typer.Exit(0)
+        
+        # For HUD registry, we need org/name format
+        if "/" not in name_with_tag:
+            design.warning("Image name must include organization/namespace for HUD registry")
+            design.info(f"Current format: {name_with_tag}")
+            design.info("Expected format: org/name:tag (e.g., hudpython/myenv:v1.0)")
+            design.info("\nYour Docker push succeeded - share hud.lock.yaml manually")
+            raise typer.Exit(0)
+
+        # Upload to HUD registry
+        design.progress_message("Uploading metadata to HUD registry...")
+
+        # URL-encode the path segments to handle special characters in tags
+        url_safe_path = "/".join(quote(part, safe="") for part in name_with_tag.split("/"))
+        registry_url = f"{settings.hud_telemetry_url.rstrip('/')}/registry/envs/{url_safe_path}"
+
+        # Prepare the payload
+        payload = {
+            "lock": yaml.dump(lock_data, default_flow_style=False, sort_keys=False),
+            "digest": pushed_digest.split("@")[-1] if "@" in pushed_digest else None,
+        }
+
+        headers = {"Authorization": f"Bearer {settings.api_key}"}
+
+        response = requests.post(registry_url, json=payload, headers=headers, timeout=10)
+
+        if response.status_code in [200, 201]:
+            design.success("Metadata uploaded to HUD registry")
+            design.info("Others can now pull with:")
+            design.command_example(f"hud pull {name_with_tag}")
+            design.info("")
+        elif response.status_code == 401:
+            design.error("Authentication failed")
+            design.info("Check your HUD_API_KEY is valid")
+            design.info("Get a new key at: https://hud.so/settings")
+        elif response.status_code == 403:
+            design.error("Permission denied")
+            design.info("You may not have access to push to this namespace")
+        elif response.status_code == 409:
+            design.warning("This version already exists in the registry")
+            design.info("Consider using a different tag if you want to update")
         else:
-            if verbose:
-                design.info("Could not parse registry path for upload")
-            design.info("Share hud.lock.yaml to let others reproduce your exact environment\n")
+            design.warning(f"Could not upload to registry: {response.status_code}")
+            design.warning(_get_response_text(response))
+            design.info("Share hud.lock.yaml manually\n")
+    except requests.exceptions.Timeout:
+        design.warning("Registry upload timed out")
+        design.info("The registry might be slow or unavailable")
+        design.info("Your Docker push succeeded - share hud.lock.yaml manually")
+    except requests.exceptions.ConnectionError:
+        design.warning("Could not connect to HUD registry")
+        design.info("Check your internet connection")
+        design.info("Your Docker push succeeded - share hud.lock.yaml manually")
     except Exception as e:
         design.warning(f"Registry upload failed: {e}")
-        design.info("Share hud.lock.yaml manually\n")
+        design.info("Share hud.lock.yaml manually")
 
     # Show usage examples
     design.section_title("What's Next?")

hud/cli/registry.py

@@ -0,0 +1,155 @@
+"""Local registry management for HUD environments."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Optional, Any
+
+import yaml
+
+from hud.utils.design import HUDDesign
+
+
+def get_registry_dir() -> Path:
+    """Get the base directory for the local HUD registry."""
+    return Path.home() / ".hud" / "envs"
+
+
+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)
+    """
+    if "@sha256:" in image_ref:
+        # Extract from digest reference: image@sha256:abc123...
+        return image_ref.split("@sha256:")[-1][:12]
+    elif image_ref.startswith("sha256:"):
+        # Direct digest format
+        return image_ref.split(":")[-1][:12]
+    elif ":" in image_ref and "/" not in image_ref.split(":")[-1]:
+        # Has a tag but no slashes after colon (not a port)
+        tag = image_ref.split(":")[-1]
+        return tag[:12] if tag else "latest"
+    else:
+        # No tag specified or complex format
+        return "latest"
+
+
+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)
+        myorg/myapp -> (myorg/myapp, latest)
+    """
+    # 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]:
+    """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:
+            design.warning(f"Failed to save to registry: {e}")
+        return None
+
+
+def load_from_registry(digest: str) -> Optional[Dict[str, Any]]:
+    """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)
+    except Exception:
+        return None
+
+
+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/remove.py

@@ -0,0 +1,200 @@
+"""Remove HUD environments from local registry."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+import typer
+import yaml
+
+from hud.utils.design import HUDDesign
+
+from .registry import get_registry_dir, list_registry_entries, load_from_registry
+
+
+def remove_environment(
+    target: str,
+    yes: bool = False,
+    verbose: bool = False,
+) -> None:
+    """Remove an environment from the local registry."""
+    design = HUDDesign()
+    design.header("HUD Environment Removal")
+    
+    # Find the environment to remove
+    found_entry = None
+    found_digest = None
+    
+    # First check if target is a digest
+    for digest, lock_file in list_registry_entries():
+        if digest.startswith(target):
+            found_entry = lock_file
+            found_digest = digest
+            break
+    
+    # If not found by digest, search by name
+    if not found_entry:
+        for digest, lock_file in list_registry_entries():
+            try:
+                lock_data = load_from_registry(digest)
+                if lock_data and "image" in lock_data:
+                    image = lock_data["image"]
+                    # Extract name and tag
+                    name = image.split("@")[0] if "@" in image else image
+                    if "/" in name:
+                        # Match by repo/name or just name
+                        if target in name or name.endswith(f"/{target}"):
+                            found_entry = lock_file
+                            found_digest = digest
+                            break
+            except Exception:
+                continue
+    
+    if not found_entry:
+        design.error(f"Environment not found: {target}")
+        design.info("Use 'hud list' to see available environments")
+        raise typer.Exit(1)
+    
+    # Load and display environment info
+    try:
+        lock_data = load_from_registry(found_digest)
+        if lock_data:
+            image = lock_data.get("image", "unknown")
+            metadata = lock_data.get("metadata", {})
+            description = metadata.get("description", "No description")
+            
+            design.section_title("Environment Details")
+            design.status_item("Image", image)
+            design.status_item("Digest", found_digest)
+            design.status_item("Description", description)
+            design.status_item("Location", str(found_entry.parent))
+    except Exception as e:
+        if verbose:
+            design.warning(f"Could not read environment details: {e}")
+    
+    # Confirm deletion
+    if not yes:
+        design.info("")
+        if not typer.confirm(f"Remove environment {found_digest}?"):
+            design.info("Aborted")
+            raise typer.Exit(0)
+    
+    # Remove the environment directory
+    try:
+        env_dir = found_entry.parent
+        shutil.rmtree(env_dir)
+        design.success(f"Removed environment: {found_digest}")
+        
+        # Check if the image is still available locally
+        if lock_data:
+            image = lock_data.get("image", "")
+            if image:
+                design.info("")
+                design.info("Note: The Docker image may still exist locally.")
+                design.info(f"To remove it, run: [cyan]docker rmi {image.split('@')[0]}[/cyan]")
+    except Exception as e:
+        design.error(f"Failed to remove environment: {e}")
+        raise typer.Exit(1)
+
+
+def remove_all_environments(
+    yes: bool = False,
+    verbose: bool = False,
+) -> None:
+    """Remove all environments from the local registry."""
+    design = HUDDesign()
+    design.header("Remove All HUD Environments")
+    
+    registry_dir = get_registry_dir()
+    if not registry_dir.exists():
+        design.info("No environments found in local registry.")
+        return
+    
+    # Count environments
+    entries = list(list_registry_entries())
+    if not entries:
+        design.info("No environments found in local registry.")
+        return
+    
+    design.warning(f"This will remove {len(entries)} environment(s) from the local registry!")
+    
+    # List environments that will be removed
+    design.section_title("Environments to Remove")
+    for digest, lock_file in entries:
+        try:
+            lock_data = load_from_registry(digest)
+            if lock_data:
+                image = lock_data.get("image", "unknown")
+                design.info(f"  • {digest[:12]} - {image}")
+        except Exception:
+            design.info(f"  • {digest[:12]}")
+    
+    # Confirm deletion
+    if not yes:
+        design.info("")
+        if not typer.confirm("Remove ALL environments?", default=False):
+            design.info("Aborted")
+            raise typer.Exit(0)
+    
+    # Remove all environments
+    removed = 0
+    failed = 0
+    
+    for digest, lock_file in entries:
+        try:
+            env_dir = lock_file.parent
+            shutil.rmtree(env_dir)
+            removed += 1
+            if verbose:
+                design.success(f"Removed: {digest}")
+        except Exception as e:
+            failed += 1
+            if verbose:
+                design.error(f"Failed to remove {digest}: {e}")
+    
+    design.info("")
+    if failed == 0:
+        design.success(f"Successfully removed {removed} environment(s)")
+    else:
+        design.warning(f"Removed {removed} environment(s), failed to remove {failed}")
+    
+    design.info("")
+    design.info("Note: Docker images may still exist locally.")
+    design.info("To remove them, use: [cyan]docker image prune[/cyan]")
+
+
+def remove_command(
+    target: str | None = typer.Argument(
+        None, 
+        help="Environment to remove (digest, name, or 'all' for all environments)"
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip confirmation prompt"
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Show detailed output"
+    ),
+) -> None:
+    """🗑️ Remove HUD environments from local registry.
+    
+    Removes environment metadata from ~/.hud/envs/
+    Note: This does not remove the Docker images.
+    
+    Examples:
+        hud remove abc123              # Remove by digest
+        hud remove text_2048           # Remove by name
+        hud remove hudpython/test_init # Remove by full name
+        hud remove all                 # Remove all environments
+        hud remove all --yes           # Remove all without confirmation
+    """
+    if not target:
+        design = HUDDesign()
+        design.error("Please specify an environment to remove or 'all'")
+        design.info("Use 'hud list' to see available environments")
+        raise typer.Exit(1)
+    
+    if target.lower() == "all":
+        remove_all_environments(yes, verbose)
+    else:
+        remove_environment(target, yes, verbose)

hud/cli/runner.py

@@ -14,7 +14,7 @@ from hud.utils.design import HUDDesign
 
 def run_stdio_server(image: str, docker_args: list[str], verbose: bool) -> None:
     """Run Docker image as stdio MCP server (direct passthrough)."""
-    design = HUDDesign(stderr=True)  # Use stderr for stdio mode
+    design = HUDDesign()  # Use stderr for stdio mode
 
     # Build docker command
     docker_cmd = ["docker", "run", "--rm", "-i", *docker_args, image]