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

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

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

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

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

@@ -3,6 +3,7 @@
 Uses Click for command parsing and Rich for pretty output.
 """
 
+import os
 import sys
 import webbrowser
 
@@ -173,12 +174,18 @@ def session_join(ctx, session_id: str, force_setup: bool):
         sys.exit(1)
 
     # Check Docker is running before we start (with retry prompt)
+    # In non-interactive mode (CI/automation), fail immediately instead of prompting
+    non_interactive = os.environ.get("HTE_NON_INTERACTIVE", "").lower() in ("1", "true", "yes")
+
     while True:
         docker_ok, docker_error = _check_docker()
         if docker_ok:
             console.print("[dim]✓ Docker running[/dim]")
             break
         console.print(f"[red]{docker_error}[/red]")
+        if non_interactive:
+            console.print("[dim]Non-interactive mode - exiting[/dim]")
+            sys.exit(1)
         console.print()
         if not click.confirm("Start Docker and retry?", default=True):
             sys.exit(1)
@@ -238,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
@@ -317,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 = {}
@@ -327,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:
@@ -357,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]")
@@ -388,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-0.2.26 → hte_cli-0.2.28}/src/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.26 → hte_cli-0.2.28}/tests/e2e/automated_runner.py

@@ -476,11 +476,36 @@ def run_automated_test(task_id: str, benchmark: str, timeout: int = 300) -> list
     child.logfile = TeeWriter(log_file, sys.stdout)
 
     try:
-        # session join flow: no "Ready to start?" prompt - goes straight into setup
-        # Wait for "Session Joined" panel
-        console.print("Waiting for session join...")
-        idx = child.expect([r"Session Joined", pexpect.TIMEOUT, pexpect.EOF], timeout=60)
-        if idx != 0:
+        # session join flow: first checks Docker, then joins session
+        # Handle Docker check prompt if it appears (Docker not running = test failure)
+        console.print("Waiting for Docker check / session join...")
+        idx = child.expect(
+            [
+                r"Docker running",  # Docker OK - continue
+                r"Start Docker and retry\?",  # Docker not running - fail test
+                r"Session Joined",  # Skipped Docker message, got session
+                pexpect.TIMEOUT,
+                pexpect.EOF,
+            ],
+            timeout=60,
+        )
+
+        if idx == 1:  # Docker not running prompt
+            child.sendline("n")  # Don't retry - fail the test
+            results.append(
+                TestResult("Docker check", False, "", "Docker not running - test requires Docker")
+            )
+            return results
+        elif idx == 0:  # Docker OK
+            results.append(TestResult("Docker check", True, "Docker running"))
+            # Now wait for Session Joined
+            idx = child.expect([r"Session Joined", pexpect.TIMEOUT, pexpect.EOF], timeout=60)
+            if idx != 0:
+                results.append(TestResult("CLI startup", False, "", "Never got 'Session Joined'"))
+                return results
+        elif idx == 2:  # Got Session Joined directly
+            pass  # Continue below
+        else:  # TIMEOUT or EOF
             results.append(TestResult("CLI startup", False, "", "Never got 'Session Joined'"))
             return results
 

{hte_cli-0.2.26 → hte_cli-0.2.28}/tests/unit/test_image_utils.py

@@ -9,6 +9,13 @@ from hte_cli.image_utils import (
     extract_images_from_compose,
     prepull_compose_images,
     pull_image_with_progress,
+    get_host_architecture,
+    get_host_docker_platform,
+    get_image_architecture,
+    check_image_architecture_matches_host,
+    is_running_in_linux_vm_on_arm,
+    remove_image,
+    fix_image_architecture,
 )
 
 
@@ -396,3 +403,221 @@ services:
         assert pulled == 2
         assert failed == 0
         mock_pull.assert_called_once()  # Only one pull
+
+
+class TestGetHostArchitecture:
+    """Tests for get_host_architecture."""
+
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_returns_platform_machine(self, mock_machine):
+        """Returns the result of platform.machine()."""
+        mock_machine.return_value = "x86_64"
+        assert get_host_architecture() == "x86_64"
+
+        mock_machine.return_value = "aarch64"
+        assert get_host_architecture() == "aarch64"
+
+
+class TestGetHostDockerPlatform:
+    """Tests for get_host_docker_platform."""
+
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_returns_linux_amd64_for_x86(self, mock_machine):
+        """Maps x86_64 to linux/amd64."""
+        mock_machine.return_value = "x86_64"
+        assert get_host_docker_platform() == "linux/amd64"
+
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_returns_linux_arm64_for_aarch64(self, mock_machine):
+        """Maps aarch64 to linux/arm64."""
+        mock_machine.return_value = "aarch64"
+        assert get_host_docker_platform() == "linux/arm64"
+
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_returns_linux_arm64_for_arm64(self, mock_machine):
+        """Maps arm64 to linux/arm64."""
+        mock_machine.return_value = "arm64"
+        assert get_host_docker_platform() == "linux/arm64"
+
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_returns_none_for_unknown(self, mock_machine):
+        """Returns None for unknown architectures."""
+        mock_machine.return_value = "i386"
+        assert get_host_docker_platform() is None
+
+
+class TestGetImageArchitecture:
+    """Tests for get_image_architecture."""
+
+    @patch("subprocess.run")
+    def test_returns_architecture_from_docker(self, mock_run):
+        """Returns architecture string from docker inspect."""
+        mock_run.return_value = MagicMock(returncode=0, stdout="amd64\n")
+        assert get_image_architecture("python:3.12-slim") == "amd64"
+
+    @patch("subprocess.run")
+    def test_returns_none_when_image_not_found(self, mock_run):
+        """Returns None when image doesn't exist."""
+        mock_run.return_value = MagicMock(returncode=1, stdout="")
+        assert get_image_architecture("nonexistent:image") is None
+
+    @patch("subprocess.run")
+    def test_returns_none_on_timeout(self, mock_run):
+        """Returns None on subprocess timeout."""
+        mock_run.side_effect = subprocess.TimeoutExpired(cmd="docker", timeout=10)
+        assert get_image_architecture("python:3.12-slim") is None
+
+
+class TestCheckImageArchitectureMatchesHost:
+    """Tests for check_image_architecture_matches_host."""
+
+    @patch("hte_cli.image_utils.get_image_architecture")
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_matches_when_both_amd64(self, mock_machine, mock_get_arch):
+        """Returns True when both image and host are amd64."""
+        mock_machine.return_value = "x86_64"
+        mock_get_arch.return_value = "amd64"
+
+        matches, image_arch, host_arch = check_image_architecture_matches_host("python:3.12-slim")
+
+        assert matches is True
+        assert image_arch == "amd64"
+        assert host_arch == "x86_64"
+
+    @patch("hte_cli.image_utils.get_image_architecture")
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_matches_when_both_arm64(self, mock_machine, mock_get_arch):
+        """Returns True when both image and host are arm64."""
+        mock_machine.return_value = "aarch64"
+        mock_get_arch.return_value = "arm64"
+
+        matches, image_arch, host_arch = check_image_architecture_matches_host("python:3.12-slim")
+
+        assert matches is True
+        assert image_arch == "arm64"
+        assert host_arch == "aarch64"
+
+    @patch("hte_cli.image_utils.get_image_architecture")
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_mismatch_amd64_on_arm_host(self, mock_machine, mock_get_arch):
+        """Returns False when amd64 image on arm64 host."""
+        mock_machine.return_value = "aarch64"
+        mock_get_arch.return_value = "amd64"
+
+        matches, image_arch, host_arch = check_image_architecture_matches_host("python:3.12-slim")
+
+        assert matches is False
+        assert image_arch == "amd64"
+        assert host_arch == "aarch64"
+
+    @patch("hte_cli.image_utils.get_image_architecture")
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_returns_true_when_image_not_cached(self, mock_machine, mock_get_arch):
+        """Returns True (no issue) when image isn't cached."""
+        mock_machine.return_value = "aarch64"
+        mock_get_arch.return_value = None  # Not cached
+
+        matches, image_arch, host_arch = check_image_architecture_matches_host("python:3.12-slim")
+
+        assert matches is True
+        assert image_arch is None
+
+
+class TestIsRunningInLinuxVmOnArm:
+    """Tests for is_running_in_linux_vm_on_arm."""
+
+    @patch("hte_cli.image_utils.platform.machine")
+    @patch("sys.platform", "linux")
+    def test_true_for_linux_aarch64(self, mock_machine):
+        """Returns True for Linux on aarch64."""
+        mock_machine.return_value = "aarch64"
+        assert is_running_in_linux_vm_on_arm() is True
+
+    @patch("hte_cli.image_utils.platform.machine")
+    @patch("sys.platform", "linux")
+    def test_true_for_linux_arm64(self, mock_machine):
+        """Returns True for Linux on arm64."""
+        mock_machine.return_value = "arm64"
+        assert is_running_in_linux_vm_on_arm() is True
+
+    @patch("hte_cli.image_utils.platform.machine")
+    @patch("sys.platform", "darwin")
+    def test_false_for_macos_arm64(self, mock_machine):
+        """Returns False for macOS even on ARM."""
+        mock_machine.return_value = "arm64"
+        assert is_running_in_linux_vm_on_arm() is False
+
+    @patch("hte_cli.image_utils.platform.machine")
+    @patch("sys.platform", "linux")
+    def test_false_for_linux_x86(self, mock_machine):
+        """Returns False for Linux on x86."""
+        mock_machine.return_value = "x86_64"
+        assert is_running_in_linux_vm_on_arm() is False
+
+
+class TestRemoveImage:
+    """Tests for remove_image."""
+
+    @patch("subprocess.run")
+    def test_returns_true_on_success(self, mock_run):
+        """Returns True when docker rmi succeeds."""
+        mock_run.return_value = MagicMock(returncode=0)
+        assert remove_image("python:3.12-slim") is True
+
+    @patch("subprocess.run")
+    def test_returns_false_on_failure(self, mock_run):
+        """Returns False when docker rmi fails."""
+        mock_run.return_value = MagicMock(returncode=1)
+        assert remove_image("python:3.12-slim") is False
+
+
+class TestFixImageArchitecture:
+    """Tests for fix_image_architecture."""
+
+    @patch("hte_cli.image_utils.pull_image_with_progress")
+    @patch("hte_cli.image_utils.remove_image")
+    @patch("hte_cli.image_utils.check_image_architecture_matches_host")
+    def test_no_fix_needed_when_matches(self, mock_check, mock_remove, mock_pull):
+        """Returns (False, message) when architecture already matches."""
+        mock_check.return_value = (True, "arm64", "aarch64")
+
+        needed_fix, message = fix_image_architecture("python:3.12-slim")
+
+        assert needed_fix is False
+        assert "architecture OK" in message
+        mock_remove.assert_not_called()
+        mock_pull.assert_not_called()
+
+    @patch("hte_cli.image_utils.pull_image_with_progress")
+    @patch("hte_cli.image_utils.remove_image")
+    @patch("hte_cli.image_utils.check_image_architecture_matches_host")
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_fixes_mismatch_by_repulling(self, mock_machine, mock_check, mock_remove, mock_pull):
+        """Removes and re-pulls when architecture mismatches."""
+        mock_machine.return_value = "aarch64"
+        mock_check.return_value = (False, "amd64", "aarch64")  # Mismatch!
+        mock_remove.return_value = True
+        mock_pull.return_value = True
+
+        needed_fix, message = fix_image_architecture("python:3.12-slim")
+
+        assert needed_fix is True
+        assert "re-pulled" in message
+        mock_remove.assert_called_once_with("python:3.12-slim")
+        mock_pull.assert_called_once_with("python:3.12-slim", platform="linux/arm64")
+
+    @patch("hte_cli.image_utils.pull_image_with_progress")
+    @patch("hte_cli.image_utils.remove_image")
+    @patch("hte_cli.image_utils.check_image_architecture_matches_host")
+    @patch("hte_cli.image_utils.platform.machine")
+    def test_returns_false_when_repull_fails(self, mock_machine, mock_check, mock_remove, mock_pull):
+        """Returns (False, message) when re-pull fails."""
+        mock_machine.return_value = "aarch64"
+        mock_check.return_value = (False, "amd64", "aarch64")
+        mock_remove.return_value = True
+        mock_pull.return_value = False  # Pull fails
+
+        needed_fix, message = fix_image_architecture("python:3.12-slim")
+
+        assert needed_fix is False
+        assert "failed to re-pull" in message

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

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