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

hud/cli/list_func.py

@@ -0,0 +1,212 @@
+"""List HUD environments from local registry."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from pathlib import Path
+
+import typer
+import yaml
+from rich.table import Table
+
+from hud.utils.design import HUDDesign
+
+from .registry import get_registry_dir, list_registry_entries, extract_name_and_tag
+
+
+def format_timestamp(timestamp: float | None) -> str:
+    """Format timestamp to human-readable relative time."""
+    if not timestamp:
+        return "unknown"
+    
+    dt = datetime.fromtimestamp(timestamp)
+    now = datetime.now()
+    delta = now - dt
+    
+    if delta.days > 365:
+        return f"{delta.days // 365}y ago"
+    elif delta.days > 30:
+        return f"{delta.days // 30}mo ago"
+    elif delta.days > 0:
+        return f"{delta.days}d ago"
+    elif delta.seconds > 3600:
+        return f"{delta.seconds // 3600}h ago"
+    elif delta.seconds > 60:
+        return f"{delta.seconds // 60}m ago"
+    else:
+        return "just now"
+
+
+def list_environments(
+    filter_name: str | None = None,
+    json_output: bool = False,
+    show_all: bool = False,
+    verbose: bool = False,
+) -> None:
+    """List all HUD environments in the local registry."""
+    design = HUDDesign()
+    
+    if not json_output:
+        design.header("HUD Environment Registry")
+    
+    # Check for environment directory
+    env_dir = get_registry_dir()
+    if not env_dir.exists():
+        if json_output:
+            print("[]")
+        else:
+            design.info("No environments found in local registry.")
+            design.info("")
+            design.info("Pull environments with: [cyan]hud pull <org/name:tag>[/cyan]")
+            design.info("Build environments with: [cyan]hud build[/cyan]")
+        return
+    
+    # Collect all environments using the registry helper
+    environments = []
+    
+    for digest, lock_file in list_registry_entries():
+        try:
+            # Read lock file
+            with open(lock_file) as f:
+                lock_data = yaml.safe_load(f)
+            
+            # Extract metadata
+            image = lock_data.get("image", "unknown")
+            name, tag = extract_name_and_tag(image)
+            
+            # Apply filter if specified
+            if filter_name and filter_name.lower() not in name.lower():
+                continue
+            
+            # Get additional metadata
+            metadata = lock_data.get("metadata", {})
+            description = metadata.get("description", "")
+            tools_count = len(metadata.get("tools", []))
+            
+            # Get file modification time as pulled time
+            pulled_time = lock_file.stat().st_mtime
+            
+            environments.append({
+                "name": name,
+                "tag": tag,
+                "digest": digest,
+                "description": description,
+                "tools_count": tools_count,
+                "pulled_time": pulled_time,
+                "image": image,
+                "path": str(lock_file),
+            })
+            
+        except Exception as e:
+            if verbose:
+                design.warning(f"Failed to read {lock_file}: {e}")
+    
+    # Sort by pulled time (newest first)
+    environments.sort(key=lambda x: x["pulled_time"], reverse=True)
+    
+    if json_output:
+        # Output as JSON
+        import json
+        json_data = []
+        for env in environments:
+            json_data.append({
+                "name": env["name"],
+                "tag": env["tag"],
+                "digest": env["digest"],
+                "description": env["description"],
+                "tools_count": env["tools_count"],
+                "pulled_time": env["pulled_time"],
+                "image": env["image"],
+                "path": env["path"],
+            })
+        print(json.dumps(json_data, indent=2))
+        return
+    
+    if not environments:
+        design.info("No environments found matching criteria.")
+        design.info("")
+        design.info("Pull environments with: [cyan]hud pull <org/name:tag>[/cyan]")
+        design.info("Build environments with: [cyan]hud build[/cyan]")
+        return
+    
+    # Create table
+    table = Table(title=f"Found {len(environments)} environment{'s' if len(environments) != 1 else ''}")
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Tag", style="green")
+    table.add_column("Description", style="white")
+    table.add_column("Tools", justify="right", style="yellow")
+    table.add_column("Pulled", style="dim")
+    
+    if show_all or verbose:
+        table.add_column("Digest", style="dim")
+    
+    # Add rows
+    for env in environments:
+        # Truncate description if too long
+        desc = env["description"]
+        if desc and len(desc) > 50 and not verbose:
+            desc = desc[:47] + "..."
+        
+        row = [
+            env["name"],
+            env["tag"],
+            desc or "[dim]No description[/dim]",
+            str(env["tools_count"]),
+            format_timestamp(env["pulled_time"]),
+        ]
+        
+        if show_all or verbose:
+            row.append(env["digest"][:12])
+        
+        table.add_row(*row)
+    
+    design.print(table)
+    design.info("")
+    
+    # Show usage hints
+    design.section_title("Usage")
+    if environments:
+        # Use the most recently pulled environment as example
+        example_env = environments[0]
+        example_ref = f"{example_env['name']}:{example_env['tag']}"
+        
+        design.info(f"Run an environment: [cyan]hud run {example_ref}[/cyan]")
+        design.info(f"Analyze tools: [cyan]hud analyze {example_ref}[/cyan]")
+        design.info(f"Debug server: [cyan]hud debug {example_ref}[/cyan]")
+    
+    design.info("Pull more environments: [cyan]hud pull <org/name:tag>[/cyan]")
+    design.info("Build new environments: [cyan]hud build[/cyan]")
+    
+    if verbose:
+        design.info("")
+        design.info(f"[dim]Registry location: {env_dir}[/dim]")
+
+
+def list_command(
+    filter_name: str | None = typer.Option(
+        None, "--filter", "-f", help="Filter environments by name (case-insensitive)"
+    ),
+    json_output: bool = typer.Option(
+        False, "--json", help="Output as JSON"
+    ),
+    show_all: bool = typer.Option(
+        False, "--all", "-a", help="Show all columns including digest"
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Show detailed output"
+    ),
+) -> None:
+    """📋 List all HUD environments in local registry.
+    
+    Shows environments pulled with 'hud pull' or built with 'hud build',
+    stored in ~/.hud/envs/
+    
+    Examples:
+        hud list                    # List all environments
+        hud list --filter text      # Filter by name
+        hud list --json            # Output as JSON
+        hud list --all             # Show digest column
+        hud list --verbose         # Show full descriptions
+    """
+    list_environments(filter_name, json_output, show_all, verbose)

hud/cli/pull.py

@@ -14,6 +14,8 @@ from rich.table import Table
 from hud.settings import settings
 from hud.utils.design import HUDDesign
 
+from .registry import save_to_registry
+
 
 def get_docker_manifest(image: str) -> dict | None:
     """Get manifest from Docker registry without pulling the image."""
@@ -282,19 +284,8 @@ def pull_environment(
 
     # Store lock file locally if we have full lock data (not minimal manifest data)
     if lock_data and lock_data.get("source") != "docker-manifest":
-        # Extract digest from image ref
-        digest = image_ref.split("@sha256:")[-1][:12] if "@sha256:" in image_ref else "latest"
-
-        # Store under ~/.hud/envs/<digest>/
-        local_env_dir = Path.home() / ".hud" / "envs" / 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)
-
-        if verbose:
-            design.info(f"Stored lock file: {local_lock_path}")
+        # Save to local registry using the helper
+        save_to_registry(lock_data, image_ref, verbose)
 
     # Success!
     design.success("Pull complete!")

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