hte-cli 0.2.27__py3-none-any.whl → 0.2.28__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,6 +328,22 @@ 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 = {}
@@ -334,13 +354,57 @@ 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
+                        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 = [""]
+
+                # On Linux ARM64, use host platform if no explicit platform in compose
+                # This prevents pulling amd64 images that won't run
+                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]"
                 ) as status:
@@ -364,14 +428,21 @@ 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]")
+                    # 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]"
+                        )
+                    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]")
@@ -395,8 +466,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)

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.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hte-cli
-Version: 0.2.27
+Version: 0.2.28
 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.28.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=EgL9nlQ2R0TSp8qUtPe5YwTN3KlrNCQ8tRQnUhnFrP4,30647
 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.28.dist-info/METADATA,sha256=cBb8EnxzFdZrsodJ3icqvprVywpeYJDb1__AI6Lm99A,3820
+hte_cli-0.2.28.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hte_cli-0.2.28.dist-info/entry_points.txt,sha256=XbyEEi1H14DFAt0Kdl22e_IRVEGzimSzYSh5HlhKlFA,41
+hte_cli-0.2.28.dist-info/RECORD,,