hte-cli 0.2.28__tar.gz → 0.2.30__tar.gz

{hte_cli-0.2.28 → hte_cli-0.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hte-cli
-Version: 0.2.28
+Version: 0.2.30
 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.28 → hte_cli-0.2.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hte-cli"
-version = "0.2.28"
+version = "0.2.30"
 description = "Human Time-to-Completion Evaluation CLI"
 readme = "README.md"
 requires-python = ">=3.11"

{hte_cli-0.2.28 → hte_cli-0.2.30}/src/hte_cli/cli.py

@@ -282,6 +282,11 @@ def session_join(ctx, session_id: str, force_setup: bool):
     # Validate compose for sandbox-required benchmarks
     benchmark = session_info.get("benchmark", "").lower()
     SANDBOX_REQUIRED_BENCHMARKS = {"cybench", "intercode-ctf", "cvebench", "cybergym", "nyuctf"}
+
+    # NYU CTF requires a shared Docker network for agent/game-server communication
+    if benchmark == "nyuctf":
+        _ensure_nyuctf_network()
+
     if benchmark in SANDBOX_REQUIRED_BENCHMARKS and not compose_yaml and not is_reconnect:
         console.print(
             f"[red]Error: {benchmark} requires a Docker sandbox but no compose file was found.[/red]"
@@ -347,6 +352,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
             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]
@@ -386,6 +392,25 @@ def session_join(ctx, session_id: str, force_setup: bool):
                             )
                             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)
@@ -396,14 +421,9 @@ def session_join(ctx, session_id: str, force_setup: bool):
                 last_status = ["connecting..."]
                 last_error = [""]
 
-                # On Linux ARM64, use host platform if no explicit platform in compose
-                # This prevents pulling amd64 images that won't run
+                # 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
-                if not pull_platform and is_linux_arm and host_platform:
-                    pull_platform = host_platform
-                    console.print(
-                        f"  [dim]Pulling {short_name} with platform {host_platform}...[/dim]"
-                    )
 
                 with console.status(
                     f"[yellow]↓[/yellow] {short_name} [dim]connecting...[/dim]"
@@ -432,12 +452,28 @@ def session_join(ctx, session_id: str, force_setup: bool):
                     )
 
                 if success:
-                    # Show platform info on Linux ARM64 for confirmation
-                    if is_linux_arm and pull_platform:
-                        arch_short = pull_platform.split("/")[-1]  # e.g., "arm64"
-                        console.print(
-                            f"  [green]✓[/green] {short_name} [dim](downloaded, arch: {arch_short})[/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)
@@ -458,6 +494,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(
@@ -750,6 +799,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
 # =============================================================================
@@ -825,5 +1028,41 @@ def _check_docker() -> tuple[bool, str | None]:
     return True, None
 
 
+def _ensure_nyuctf_network() -> None:
+    """Ensure the ctfnet Docker network exists for NYU CTF challenges.
+
+    NYU CTF tasks use a shared Docker network ('ctfnet') for communication
+    between the agent container and game-server container. This network must
+    exist before docker compose up is called, since it's declared as external.
+    """
+    import subprocess
+
+    NETWORK_NAME = "ctfnet"
+
+    try:
+        # Check if network exists
+        result = subprocess.run(
+            ["docker", "network", "inspect", NETWORK_NAME],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            return  # Network exists
+
+        # Create the network
+        subprocess.run(
+            ["docker", "network", "create", NETWORK_NAME],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=10,
+        )
+    except subprocess.CalledProcessError:
+        pass  # Network creation failed, will error later with clearer message
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        pass  # Docker not available, will error later
+
+
 if __name__ == "__main__":
     cli()

{hte_cli-0.2.28 → hte_cli-0.2.30}/uv.lock

@@ -625,7 +625,7 @@ wheels = [
 
 [[package]]
 name = "hte-cli"
-version = "0.2.28"
+version = "0.2.30"
 source = { editable = "." }
 dependencies = [
     { name = "click" },