hte-cli 0.2.31__tar.gz → 0.2.33__tar.gz

{hte_cli-0.2.31 → hte_cli-0.2.33}/PKG-INFO

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

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

{hte_cli-0.2.31 → hte_cli-0.2.33}/src/hte_cli/cli.py

@@ -4,7 +4,9 @@ Uses Click for command parsing and Rich for pretty output.
 """
 
 import os
+import signal
 import sys
+import threading
 import webbrowser
 
 import click
@@ -22,6 +24,83 @@ console = Console()
 # Support email per spec
 SUPPORT_EMAIL = "jacktpayne51@gmail.com"
 
+# Warning before cap (15 minutes)
+CAP_WARNING_SECONDS = 15 * 60
+
+
+class CapEnforcer:
+    """Background timer that enforces time cap on capped_completion tasks.
+
+    Shows warning 15 minutes before cap and terminates the task when cap is reached.
+    """
+
+    def __init__(
+        self,
+        time_cap_seconds: int,
+        start_time: float,
+        console: Console,
+        main_thread_id: int,
+    ):
+        self.time_cap_seconds = time_cap_seconds
+        self.start_time = start_time
+        self.console = console
+        self.main_thread_id = main_thread_id
+        self._stop_event = threading.Event()
+        self._warning_shown = False
+        self._thread: threading.Thread | None = None
+        self.cap_reached = False
+
+    def start(self):
+        """Start the background timer thread."""
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        """Stop the background timer."""
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join(timeout=1.0)
+
+    def _run(self):
+        """Timer loop that checks elapsed time."""
+        import time
+
+        warning_threshold = self.time_cap_seconds - CAP_WARNING_SECONDS
+
+        while not self._stop_event.is_set():
+            elapsed = time.monotonic() - self.start_time
+
+            # Show warning at 15 minutes before cap
+            if elapsed >= warning_threshold and not self._warning_shown:
+                self._warning_shown = True
+                remaining = self.time_cap_seconds - elapsed
+                minutes = int(remaining // 60)
+                self.console.print()
+                self.console.print(
+                    f"[yellow bold]Warning: Time cap approaching - {minutes} minutes remaining[/yellow bold]"
+                )
+                self.console.print(
+                    "[yellow]When cap is reached, session will end and you'll need to record progress in the web UI.[/yellow]"
+                )
+                self.console.print()
+
+            # Cap reached - terminate the main thread
+            if elapsed >= self.time_cap_seconds:
+                self.cap_reached = True
+                self.console.print()
+                self.console.print(
+                    f"[red bold]Time cap reached ({self.time_cap_seconds // 60} minutes). Session ending.[/red bold]"
+                )
+                self.console.print(
+                    "[yellow]Return to the web UI to record your progress and estimate completion time.[/yellow]"
+                )
+                # Send SIGINT to main thread to trigger KeyboardInterrupt
+                os.kill(os.getpid(), signal.SIGINT)
+                break
+
+            # Check every second
+            self._stop_event.wait(1.0)
+
 
 def _find_eval_log_bytes(runner) -> bytes | None:
     """Find and read eval log bytes from runner's work directory.
@@ -45,7 +124,9 @@ def _find_eval_log_bytes(runner) -> bytes | None:
         return None
 
 
-def _upload_partial_log(api: APIClient, session_id: str, eval_log_bytes: bytes, console: Console) -> None:
+def _upload_partial_log(
+    api: APIClient, session_id: str, eval_log_bytes: bytes, console: Console
+) -> None:
     """Upload partial eval log for interrupted session.
 
     Best-effort: silently handles failures to not block exit.
@@ -282,7 +363,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
         extract_image_platforms_from_compose,
         pull_image_with_progress,
         check_image_architecture_matches_host,
-        fix_image_architecture,
+        remove_image,
         get_host_docker_platform,
         is_running_in_linux_vm_on_arm,
     )
@@ -406,34 +487,69 @@ def session_join(ctx, session_id: str, force_setup: bool):
                         cached_images.append(img)
                         continue
                     else:
-                        # Architecture mismatch detected - this is the key fix for Linux ARM64
+                        # Architecture mismatch detected - remove and re-pull with correct arch
                         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(
-                            "      [dim]Removing cached image and re-pulling correct architecture...[/dim]"
-                        )
 
-                        needed_fix, fix_msg = fix_image_architecture(img)
-                        if needed_fix:
+                        # Remove the wrongly-cached image
+                        if not remove_image(img):
+                            console.print(
+                                f"  [red]✗[/red] {short_name} [dim](failed to remove cached image)[/dim]"
+                            )
+                            failed_images.append(img)
+                            pull_errors[img] = "failed to remove cached image"
+                            continue
+
+                        # Re-pull with correct platform and progress display
+                        last_status = ["connecting..."]
+                        last_error = [""]
+
+                        with console.status(
+                            f"[yellow]↓[/yellow] {short_name} [dim]re-pulling for {host_arch}...[/dim]"
+                        ) as status:
+
+                            def show_progress(image: str, line: str):
+                                if ": " in line:
+                                    parts = line.split(": ", 1)
+                                    if len(parts) == 2:
+                                        layer_id = parts[0][-8:]
+                                        layer_status = parts[1][:85]
+                                        display = f"{layer_id}: {layer_status}"
+                                        if display != last_status[0]:
+                                            last_status[0] = display
+                                            status.update(
+                                                f"[yellow]↓[/yellow] {short_name} [dim]{display}[/dim]"
+                                            )
+                                if "error" in line.lower() or "denied" in line.lower():
+                                    last_error[0] = line
+
+                            success = pull_image_with_progress(
+                                img, platform=host_platform, on_progress=show_progress
+                            )
+
+                        if success:
                             console.print(
-                                f"  [green]✓[/green] {short_name} [green]fixed![/green] [dim]({fix_msg})[/dim]"
+                                f"  [green]✓[/green] {short_name} [green]fixed![/green] [dim](re-pulled as {host_platform.split('/')[-1]})[/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
+                        else:
+                            # ARM re-pull failed - try without platform constraint (x86 fallback)
                             console.print(
-                                "      [dim]No ARM variant available - re-pulling x86 version...[/dim]"
+                                "      [dim]No ARM variant - trying x86 fallback...[/dim]"
                             )
-                            success = pull_image_with_progress(img)
+                            with console.status(
+                                f"[yellow]↓[/yellow] {short_name} [dim]pulling x86...[/dim]"
+                            ) as status:
+                                success = pull_image_with_progress(img, on_progress=show_progress)
+
                             if success:
                                 console.print(
-                                    f"  [yellow]![/yellow] {short_name} [dim](x86-only image, needs QEMU)[/dim]"
+                                    f"  [yellow]![/yellow] {short_name} [dim](x86-only, needs QEMU)[/dim]"
                                 )
                                 x86_images_on_arm.append(img)
                                 pulled_images.append(img)
@@ -442,14 +558,11 @@ def session_join(ctx, session_id: str, force_setup: bool):
                                 console.print(
                                     f"  [red]✗[/red] {short_name} [dim](failed to pull)[/dim]"
                                 )
+                                if last_error[0]:
+                                    console.print(f"      [dim]{last_error[0][:60]}[/dim]")
+                                    pull_errors[img] = last_error[0]
                                 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..."]
@@ -470,7 +583,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
                             parts = line.split(": ", 1)
                             if len(parts) == 2:
                                 layer_id = parts[0][-8:]
-                                layer_status = parts[1][:70]  # Increased to include size info
+                                layer_status = parts[1][:85]  # Include full progress bar + size
                                 display = f"{layer_id}: {layer_status}"
                                 if display != last_status[0]:
                                     last_status[0] = display
@@ -606,6 +719,23 @@ def session_join(ctx, session_id: str, force_setup: bool):
 
     events.docker_started()
 
+    # Start cap enforcer if this is a capped_completion task
+    time_cap_seconds = assignment.get("time_cap_seconds")
+    cap_enforcer: CapEnforcer | None = None
+    if time_cap_seconds and session_info.get("mode") == "capped_completion":
+        cap_enforcer = CapEnforcer(
+            time_cap_seconds=time_cap_seconds,
+            start_time=time.monotonic(),
+            console=console,
+            main_thread_id=threading.get_ident(),
+        )
+        cap_enforcer.start()
+        console.print(
+            f"[dim]Time cap: {time_cap_seconds // 60} minutes "
+            f"(warning at {(time_cap_seconds - CAP_WARNING_SECONDS) // 60} min)[/dim]"
+        )
+        console.print()
+
     runner = TaskRunner()
     eval_log_bytes = None
     try:
@@ -624,9 +754,15 @@ def session_join(ctx, session_id: str, force_setup: bool):
         if eval_log_bytes:
             _upload_partial_log(api, session_id, eval_log_bytes, console)
         console.print()
-        console.print(
-            "[yellow]Interrupted. Session remains active - you can reconnect later.[/yellow]"
-        )
+        # Different message if cap was reached vs user interrupt
+        if cap_enforcer and cap_enforcer.cap_reached:
+            console.print(
+                "[yellow]Time cap reached. Return to web UI to record progress and estimate completion time.[/yellow]"
+            )
+        else:
+            console.print(
+                "[yellow]Interrupted. Session remains active - you can reconnect later.[/yellow]"
+            )
         sys.exit(0)
     except Exception as e:
         events.docker_stopped(exit_code=1)
@@ -637,6 +773,9 @@ def session_join(ctx, session_id: str, force_setup: bool):
         console.print(f"[red]Task execution failed: {e}[/red]")
         sys.exit(1)
     finally:
+        # Stop cap enforcer
+        if cap_enforcer:
+            cap_enforcer.stop()
         runner.cleanup()
 
     events.docker_stopped(exit_code=0)

{hte_cli-0.2.31 → hte_cli-0.2.33}/src/hte_cli/image_utils.py

@@ -222,58 +222,6 @@ def remove_image(image: str) -> bool:
         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.31 → hte_cli-0.2.33}/tests/unit/test_image_utils.py

@@ -15,7 +15,6 @@ from hte_cli.image_utils import (
     check_image_architecture_matches_host,
     is_running_in_linux_vm_on_arm,
     remove_image,
-    fix_image_architecture,
 )
 
 
@@ -569,57 +568,3 @@ class TestRemoveImage:
         """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.31 → hte_cli-0.2.33}/uv.lock

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