hte-cli 0.2.27__py3-none-any.whl → 0.2.29__py3-none-any.whl

hte_cli/cli.py

@@ -245,6 +245,10 @@ def session_join(ctx, session_id: str, force_setup: bool):
         extract_images_from_compose,
         extract_image_platforms_from_compose,
         pull_image_with_progress,
+        check_image_architecture_matches_host,
+        fix_image_architecture,
+        get_host_docker_platform,
+        is_running_in_linux_vm_on_arm,
     )
 
     # Create event streamer
@@ -324,9 +328,26 @@ def session_join(ctx, session_id: str, force_setup: bool):
         if images:
             from hte_cli.image_utils import check_image_exists_locally
 
+            # Detect host architecture for smart image handling
+            is_linux_arm = is_running_in_linux_vm_on_arm()
+            host_platform = get_host_docker_platform()
+
+            if is_linux_arm:
+                console.print(
+                    f"[yellow]![/yellow] Detected [bold]Linux ARM64[/bold] environment"
+                )
+                console.print(
+                    f"  [dim]Will verify cached images match host architecture ({host_platform})[/dim]"
+                )
+                console.print(
+                    f"  [dim]Mismatched images will be automatically re-pulled[/dim]"
+                )
+                console.print()
+
             console.print(f"[bold]Step 2:[/bold] Pulling {len(images)} Docker image(s)...")
             pull_start = time.monotonic()
             pull_errors = {}
+            x86_images_on_arm = []  # Track x86 images that need QEMU
 
             for img in images:
                 short_name = img.split("/")[-1][:40]
@@ -334,13 +355,71 @@ def session_join(ctx, session_id: str, force_setup: bool):
 
                 # Check if already cached
                 if check_image_exists_locally(img):
-                    console.print(f"  [green]✓[/green] {short_name} [dim](cached)[/dim]")
-                    cached_images.append(img)
-                    continue
+                    # Verify architecture matches host (important for Linux ARM64)
+                    matches, image_arch, host_arch = check_image_architecture_matches_host(img)
+
+                    if matches:
+                        # Show architecture info on Linux ARM64 for transparency
+                        if is_linux_arm and image_arch:
+                            console.print(
+                                f"  [green]✓[/green] {short_name} [dim](cached, arch: {image_arch})[/dim]"
+                            )
+                        else:
+                            console.print(f"  [green]✓[/green] {short_name} [dim](cached)[/dim]")
+                        cached_images.append(img)
+                        continue
+                    else:
+                        # Architecture mismatch detected - this is the key fix for Linux ARM64
+                        console.print(
+                            f"  [yellow]⚠[/yellow] {short_name} [yellow]architecture mismatch![/yellow]"
+                        )
+                        console.print(
+                            f"      [dim]Cached image: {image_arch} | Host: {host_arch}[/dim]"
+                        )
+                        console.print(
+                            f"      [dim]Removing cached image and re-pulling correct architecture...[/dim]"
+                        )
+
+                        needed_fix, fix_msg = fix_image_architecture(img)
+                        if needed_fix:
+                            console.print(
+                                f"  [green]✓[/green] {short_name} [green]fixed![/green] [dim]({fix_msg})[/dim]"
+                            )
+                            pulled_images.append(img)
+                            continue
+                        elif "failed to re-pull" in fix_msg:
+                            # No ARM variant available - this is an x86-only image
+                            # Re-pull the amd64 version and warn about QEMU
+                            console.print(
+                                f"      [dim]No ARM variant available - re-pulling x86 version...[/dim]"
+                            )
+                            success = pull_image_with_progress(img)
+                            if success:
+                                console.print(
+                                    f"  [yellow]![/yellow] {short_name} [dim](x86-only image, needs QEMU)[/dim]"
+                                )
+                                x86_images_on_arm.append(img)
+                                pulled_images.append(img)
+                                continue
+                            else:
+                                console.print(f"  [red]✗[/red] {short_name} [dim](failed to pull)[/dim]")
+                                failed_images.append(img)
+                                pull_errors[img] = "failed to pull x86 fallback"
+                                continue
+                        else:
+                            console.print(f"  [red]✗[/red] {short_name} [dim]({fix_msg})[/dim]")
+                            failed_images.append(img)
+                            pull_errors[img] = fix_msg
+                            continue
 
                 # Need to pull - show progress
                 last_status = ["connecting..."]
                 last_error = [""]
+
+                # Use platform from compose if specified, otherwise let Docker decide
+                # (Docker will prefer native arch for multi-arch images, or pull what's available)
+                pull_platform = platform
+
                 with console.status(
                     f"[yellow]↓[/yellow] {short_name} [dim]connecting...[/dim]"
                 ) as status:
@@ -364,14 +443,37 @@ def session_join(ctx, session_id: str, force_setup: bool):
                             last_error[0] = line
 
                     success = pull_image_with_progress(
-                        img, platform=platform, on_progress=show_progress
+                        img, platform=pull_platform, on_progress=show_progress
                     )
 
                 if success:
-                    console.print(f"  [green]✓[/green] {short_name} [dim](downloaded)[/dim]")
+                    # On Linux ARM64, verify pulled image architecture
+                    if is_linux_arm:
+                        from hte_cli.image_utils import get_image_architecture
+                        pulled_arch = get_image_architecture(img)
+
+                        if pulled_arch == "arm64":
+                            console.print(
+                                f"  [green]✓[/green] {short_name} [dim](downloaded, arch: arm64)[/dim]"
+                            )
+                        elif pulled_arch == "amd64":
+                            # x86 image on ARM host - needs QEMU emulation
+                            console.print(
+                                f"  [yellow]![/yellow] {short_name} [dim](downloaded, arch: amd64)[/dim]"
+                            )
+                            console.print(
+                                f"      [yellow]This is an x86 image - requires QEMU emulation on ARM[/yellow]"
+                            )
+                            x86_images_on_arm.append(img)
+                        else:
+                            console.print(
+                                f"  [green]✓[/green] {short_name} [dim](downloaded)[/dim]"
+                            )
+                    else:
+                        console.print(f"  [green]✓[/green] {short_name} [dim](downloaded)[/dim]")
                     pulled_images.append(img)
                 else:
-                    platform_note = f" (platform: {platform})" if platform else ""
+                    platform_note = f" (platform: {pull_platform})" if pull_platform else ""
                     console.print(f"  [red]✗[/red] {short_name}{platform_note} [dim](failed)[/dim]")
                     if last_error[0]:
                         console.print(f"      [dim]{last_error[0][:60]}[/dim]")
@@ -387,6 +489,19 @@ def session_join(ctx, session_id: str, force_setup: bool):
             )
             console.print()
 
+            # Warn about x86 images on ARM that need QEMU
+            if x86_images_on_arm:
+                console.print(
+                    f"[yellow]⚠ Warning:[/yellow] {len(x86_images_on_arm)} x86 image(s) detected on ARM host"
+                )
+                console.print(
+                    "  These require QEMU emulation. If container fails to start, run:"
+                )
+                console.print(
+                    "  [bold]docker run --privileged --rm tonistiigi/binfmt --install all[/bold]"
+                )
+                console.print()
+
             # Fail fast if any required image couldn't be pulled
             if failed_images:
                 console.print(
@@ -395,8 +510,15 @@ def session_join(ctx, session_id: str, force_setup: bool):
                 console.print()
                 console.print("[yellow]Troubleshooting:[/yellow]")
                 console.print("  1. Check Docker is running: docker info")
-                console.print("  2. Try manual pull: docker pull python:3.12-slim --platform linux/amd64")
-                console.print("  3. Check network connectivity")
+
+                # Architecture-specific advice
+                if is_linux_arm:
+                    console.print(f"  2. You're on Linux ARM64 - try: docker pull <image> --platform linux/arm64")
+                    console.print("  3. For x86-only images, enable QEMU: docker run --privileged --rm tonistiigi/binfmt --install all")
+                else:
+                    console.print("  2. Try manual pull: docker pull <image>")
+
+                console.print("  4. Check network connectivity")
                 console.print()
                 console.print("Session remains active - you can retry with: hte-cli session join " + session_id)
                 sys.exit(1)
@@ -672,6 +794,160 @@ def tasks_pull_images(ctx, count: int):
     console.print("[yellow]Image pulling not yet implemented.[/yellow]")
 
 
+@cli.command("diagnose")
+def diagnose_cmd():
+    """
+    Diagnose Docker and architecture setup.
+
+    Checks Docker installation, architecture detection, and image compatibility.
+    Useful for troubleshooting before running tasks.
+    """
+    import subprocess
+    import sys as system_module
+    from hte_cli.image_utils import (
+        get_host_architecture,
+        get_host_docker_platform,
+        is_running_in_linux_vm_on_arm,
+        get_image_architecture,
+        check_image_exists_locally,
+    )
+
+    console.print("[bold]HTE-CLI Diagnostics[/bold]")
+    console.print("=" * 50)
+    console.print()
+
+    # CLI version
+    console.print(f"[bold]CLI Version:[/bold] {__version__}")
+    console.print()
+
+    # Platform info
+    console.print("[bold]Platform:[/bold]")
+    host_arch = get_host_architecture()
+    host_platform = get_host_docker_platform()
+    is_linux_arm = is_running_in_linux_vm_on_arm()
+
+    console.print(f"  OS: {system_module.platform}")
+    console.print(f"  Architecture: {host_arch}")
+    console.print(f"  Docker platform: {host_platform or 'unknown'}")
+
+    if is_linux_arm:
+        console.print()
+        console.print("[yellow]⚠ Linux ARM64 detected![/yellow]")
+        console.print("  This environment may have architecture compatibility issues.")
+        console.print("  The CLI will automatically handle multi-arch images.")
+        console.print("  For x86-only images (CTF challenges), QEMU emulation is required.")
+    console.print()
+
+    # Docker checks
+    console.print("[bold]Docker:[/bold]")
+
+    # Check Docker installed
+    try:
+        result = subprocess.run(
+            ["docker", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            console.print(f"  [green]✓[/green] Docker: {result.stdout.strip()}")
+        else:
+            console.print("  [red]✗[/red] Docker not working")
+    except Exception as e:
+        console.print(f"  [red]✗[/red] Docker not found: {e}")
+
+    # Check Docker daemon
+    try:
+        result = subprocess.run(
+            ["docker", "info"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            console.print("  [green]✓[/green] Docker daemon running")
+        else:
+            console.print("  [red]✗[/red] Docker daemon not running")
+    except Exception:
+        console.print("  [red]✗[/red] Cannot connect to Docker daemon")
+
+    # Check Compose version
+    try:
+        result = subprocess.run(
+            ["docker", "compose", "version", "--short"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            version = result.stdout.strip()
+            console.print(f"  [green]✓[/green] Docker Compose: {version}")
+        else:
+            console.print("  [yellow]![/yellow] Docker Compose not available")
+    except Exception:
+        console.print("  [yellow]![/yellow] Docker Compose not found")
+
+    console.print()
+
+    # Test images
+    console.print("[bold]Image Architecture Test:[/bold]")
+    test_images = [
+        ("python:3.12-slim", "multi-arch (nl2bash/cybashbench)"),
+        ("cybench/cybench:latest", "x86-only (cybench/cybergym)"),
+    ]
+
+    for image, description in test_images:
+        if check_image_exists_locally(image):
+            arch = get_image_architecture(image)
+            if arch:
+                if is_linux_arm and arch == "amd64":
+                    console.print(
+                        f"  [yellow]![/yellow] {image}: {arch} [dim](x86 on ARM - needs QEMU)[/dim]"
+                    )
+                else:
+                    console.print(f"  [green]✓[/green] {image}: {arch}")
+            else:
+                console.print(f"  [dim]?[/dim] {image}: cached (unknown arch)")
+        else:
+            console.print(f"  [dim]-[/dim] {image}: not cached - {description}")
+
+    console.print()
+
+    # QEMU check (for Linux ARM64)
+    if is_linux_arm:
+        console.print("[bold]QEMU Emulation:[/bold]")
+        try:
+            # Check if binfmt is set up for x86
+            result = subprocess.run(
+                ["docker", "run", "--rm", "--platform", "linux/amd64", "alpine", "uname", "-m"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            if result.returncode == 0 and "x86_64" in result.stdout:
+                console.print("  [green]✓[/green] QEMU x86 emulation working")
+            else:
+                console.print("  [red]✗[/red] QEMU x86 emulation NOT working")
+                console.print()
+                console.print("  [yellow]To enable QEMU emulation, run:[/yellow]")
+                console.print("  [bold]docker run --privileged --rm tonistiigi/binfmt --install all[/bold]")
+        except subprocess.TimeoutExpired:
+            console.print("  [yellow]![/yellow] QEMU test timed out")
+        except Exception as e:
+            console.print(f"  [red]✗[/red] QEMU test failed: {e}")
+        console.print()
+
+    console.print("[bold]Recommendation:[/bold]")
+    if is_linux_arm:
+        console.print("  For nl2bash/cybashbench: Should work with native ARM images")
+        console.print("  For CTF challenges (cybench, nyuctf, etc.): Requires QEMU emulation")
+    else:
+        console.print("  [green]✓[/green] Standard platform - all benchmarks should work")
+
+    console.print()
+    console.print("[dim]Run 'hte-cli session join <id>' to test with a real task[/dim]")
+
+
 # =============================================================================
 # Helper Functions
 # =============================================================================

hte_cli/image_utils.py

@@ -2,6 +2,7 @@
 
 import logging
 import os
+import platform
 import pty
 import re
 import select
@@ -13,6 +14,119 @@ import yaml
 logger = logging.getLogger(__name__)
 
 
+# Architecture mapping: Python's platform.machine() -> Docker platform
+ARCH_TO_DOCKER_PLATFORM = {
+    "x86_64": "linux/amd64",
+    "amd64": "linux/amd64",
+    "aarch64": "linux/arm64",
+    "arm64": "linux/arm64",
+}
+
+# Docker image architecture names (from docker inspect)
+DOCKER_ARCH_TO_PLATFORM = {
+    "amd64": "linux/amd64",
+    "arm64": "linux/arm64",
+}
+
+
+def get_host_architecture() -> str:
+    """
+    Get the host machine's architecture.
+
+    Returns:
+        Architecture string (e.g., "x86_64", "arm64", "aarch64")
+    """
+    return platform.machine()
+
+
+def get_host_docker_platform() -> str | None:
+    """
+    Get the Docker platform string for the host architecture.
+
+    Returns:
+        Docker platform (e.g., "linux/amd64", "linux/arm64") or None if unknown
+    """
+    arch = get_host_architecture()
+    return ARCH_TO_DOCKER_PLATFORM.get(arch)
+
+
+def get_image_architecture(image: str) -> str | None:
+    """
+    Get the architecture of a locally cached Docker image.
+
+    Args:
+        image: Image name (e.g., "python:3.12-slim")
+
+    Returns:
+        Architecture string (e.g., "amd64", "arm64") or None if not found/error
+    """
+    try:
+        result = subprocess.run(
+            ["docker", "image", "inspect", image, "--format", "{{.Architecture}}"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return None
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return None
+
+
+def check_image_architecture_matches_host(image: str) -> tuple[bool, str | None, str | None]:
+    """
+    Check if a cached image's architecture matches the host.
+
+    Args:
+        image: Image name to check
+
+    Returns:
+        Tuple of (matches, image_arch, host_arch):
+        - matches: True if architectures match or image not cached
+        - image_arch: The cached image's architecture (None if not cached)
+        - host_arch: The host's architecture
+    """
+    host_arch = get_host_architecture()
+    host_platform = get_host_docker_platform()
+
+    if not host_platform:
+        # Unknown host architecture - can't check
+        logger.warning(f"Unknown host architecture: {host_arch}")
+        return (True, None, host_arch)
+
+    image_arch = get_image_architecture(image)
+    if not image_arch:
+        # Image not cached - nothing to check
+        return (True, None, host_arch)
+
+    image_platform = DOCKER_ARCH_TO_PLATFORM.get(image_arch)
+    matches = image_platform == host_platform
+
+    if not matches:
+        logger.info(
+            f"Architecture mismatch for {image}: "
+            f"cached={image_arch} ({image_platform}), host={host_arch} ({host_platform})"
+        )
+
+    return (matches, image_arch, host_arch)
+
+
+def is_running_in_linux_vm_on_arm() -> bool:
+    """
+    Detect if running Linux ARM64 (likely a VM on Apple Silicon).
+
+    This is a common setup that causes architecture issues because:
+    - macOS Docker Desktop handles multi-arch via Rosetta
+    - Linux ARM64 in a VM doesn't have that, needs explicit platform handling
+
+    Returns:
+        True if running Linux on ARM64
+    """
+    import sys
+    return sys.platform == "linux" and get_host_architecture() in ("aarch64", "arm64")
+
+
 def extract_images_from_compose(compose_yaml: str) -> list[str]:
     """
     Extract Docker image names from a compose.yaml string.
@@ -86,6 +200,79 @@ def check_image_exists_locally(image: str) -> bool:
         return False
 
 
+def remove_image(image: str) -> bool:
+    """
+    Remove a Docker image from local cache.
+
+    Args:
+        image: Image name to remove
+
+    Returns:
+        True if removed successfully, False otherwise
+    """
+    try:
+        result = subprocess.run(
+            ["docker", "rmi", image],
+            capture_output=True,
+            timeout=30,
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False
+
+
+def fix_image_architecture(
+    image: str,
+    on_status: Callable[[str], None] | None = None,
+) -> tuple[bool, str]:
+    """
+    Check if a cached image has wrong architecture and fix it if needed.
+
+    For Linux ARM64 hosts (e.g., VM on Apple Silicon), this:
+    1. Checks if the cached image is amd64 when host is arm64
+    2. Removes the wrongly-cached image
+    3. Re-pulls with explicit --platform linux/arm64
+
+    Args:
+        image: Image name to check/fix
+        on_status: Callback for status updates
+
+    Returns:
+        Tuple of (needed_fix, message):
+        - needed_fix: True if image was re-pulled
+        - message: Description of what happened
+    """
+    matches, image_arch, host_arch = check_image_architecture_matches_host(image)
+
+    if matches:
+        if image_arch:
+            return (False, f"architecture OK ({image_arch})")
+        else:
+            return (False, "not cached")
+
+    # Architecture mismatch detected
+    host_platform = get_host_docker_platform()
+    if not host_platform:
+        return (False, f"unknown host architecture: {host_arch}")
+
+    if on_status:
+        on_status(f"Cached image is {image_arch}, host is {host_arch} - re-pulling...")
+
+    # Remove the wrongly-cached image
+    logger.info(f"Removing wrongly-cached {image_arch} image: {image}")
+    if not remove_image(image):
+        return (False, f"failed to remove cached {image_arch} image")
+
+    # Re-pull with correct platform
+    logger.info(f"Re-pulling {image} with platform {host_platform}")
+    success = pull_image_with_progress(image, platform=host_platform)
+
+    if success:
+        return (True, f"re-pulled as {host_platform.split('/')[-1]}")
+    else:
+        return (False, f"failed to re-pull with platform {host_platform}")
+
+
 def pull_image_with_progress(
     image: str,
     platform: str | None = None,

{hte_cli-0.2.27.dist-info → hte_cli-0.2.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hte-cli
-Version: 0.2.27
+Version: 0.2.29
 Summary: Human Time-to-Completion Evaluation CLI
 Project-URL: Homepage, https://github.com/sean-peters-au/lyptus-mono
 Author: Lyptus Research

{hte_cli-0.2.27.dist-info → hte_cli-0.2.29.dist-info}/RECORD

@@ -1,15 +1,15 @@
 hte_cli/__init__.py,sha256=fDGXp-r8bIoLtlQnn5xJ_CpwMhonvk9bGjZQsjA2mDI,914
 hte_cli/__main__.py,sha256=63n0gNGfskidWDU0aAIF2N8lylVCLYKVIkrN9QiORoo,107
 hte_cli/api_client.py,sha256=m42kfFZS72Nu_VuDwxRsLNy4ziCcvgk7KNWBh9gwqy0,9257
-hte_cli/cli.py,sha256=MSzswNhW3Pp2TUneIvoqsrdvkxIdMYNm5_uDUKFEcG0,26728
+hte_cli/cli.py,sha256=KpDuJp4VRTfjyVG_ZK3zVCgdDD2qaNjtqBFDHlofUnE,38678
 hte_cli/config.py,sha256=42Xv__YMSeRLs2zhGukJkIXFKtnBtYCHnONfViGyt2g,3387
 hte_cli/errors.py,sha256=1J5PpxcUKBu6XjigMMCPOq4Zc12tnv8LhAsiaVFWLQM,2762
 hte_cli/events.py,sha256=oDKCS-a0IZ7bz7xkwQj5eM4DoDCYvnclAGohrMTWf8s,5644
-hte_cli/image_utils.py,sha256=nVHhUY-QZ4uPpGSx3ByOiVGOnm9T11p_cVlb39FQb_Y,7717
+hte_cli/image_utils.py,sha256=n4AmbaR9tbH0ahXbTOn7Rr_VeRbhg1RgWknsWwI_83c,13249
 hte_cli/runner.py,sha256=SWl9FF4X3e9eBbZyL0ujhmmSL5OK8J6st-Ty0jD5AWM,14550
 hte_cli/scorers.py,sha256=B0ZjQ3Fh-VDkc_8CDc86yW7vpdimbV3RSqs7l-VeUIg,6629
 hte_cli/version_check.py,sha256=WVZyGy2XfAghQYdd2N9-0Qfg-7pgp9gt4761-PnmacI,1708
-hte_cli-0.2.27.dist-info/METADATA,sha256=ault1aIoseAbJzWU9TcAjkqTggxOUyO5w_DUaX1lUTs,3820
-hte_cli-0.2.27.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-hte_cli-0.2.27.dist-info/entry_points.txt,sha256=XbyEEi1H14DFAt0Kdl22e_IRVEGzimSzYSh5HlhKlFA,41
-hte_cli-0.2.27.dist-info/RECORD,,
+hte_cli-0.2.29.dist-info/METADATA,sha256=upaON6sKmJaItR2khC6Sc2-9UFYu7wyuy9-yG2lq5MQ,3820
+hte_cli-0.2.29.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hte_cli-0.2.29.dist-info/entry_points.txt,sha256=XbyEEi1H14DFAt0Kdl22e_IRVEGzimSzYSh5HlhKlFA,41
+hte_cli-0.2.29.dist-info/RECORD,,