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

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

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

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

{hte_cli-0.2.30 → hte_cli-0.2.32}/src/hte_cli/api_client.py

@@ -265,3 +265,27 @@ class APIClient:
             json=payload,
             timeout=UPLOAD_TIMEOUT,
         )
+
+    def upload_partial_log(
+        self,
+        session_id: str,
+        eval_log_bytes: bytes,
+    ) -> dict:
+        """Upload partial eval log for interrupted sessions.
+
+        Args:
+            session_id: The session ID
+            eval_log_bytes: Partial eval log content
+
+        Returns:
+            Response dict with status and log_path
+        """
+        payload = {
+            "eval_log_base64": base64.b64encode(eval_log_bytes).decode("ascii"),
+        }
+
+        return self.post(
+            f"/sessions/{session_id}/partial-log",
+            json=payload,
+            timeout=UPLOAD_TIMEOUT,
+        )

{hte_cli-0.2.30 → hte_cli-0.2.32}/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,121 @@ 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.
+
+    Used for interrupted sessions to upload partial logs.
+    """
+    try:
+        # Look for eval logs in the work directory
+        if not runner.work_dir.exists():
+            return None
+
+        # Find any .eval files in the work directory tree
+        eval_files = list(runner.work_dir.rglob("*.eval"))
+        if not eval_files:
+            return None
+
+        # Get the most recent one
+        eval_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+        return eval_files[0].read_bytes()
+    except Exception:
+        return 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.
+    """
+    try:
+        size_kb = len(eval_log_bytes) / 1024
+        console.print(f"[dim]Uploading partial eval log ({size_kb:.0f} KB)...[/dim]")
+        api.upload_partial_log(session_id, eval_log_bytes)
+        console.print("[dim]Partial eval log uploaded.[/dim]")
+    except Exception as e:
+        console.print(f"[dim]Could not upload partial log: {e}[/dim]")
+
 
 @click.group()
 @click.version_option(__version__, prog_name="hte-cli")
@@ -338,15 +455,11 @@ def session_join(ctx, session_id: str, force_setup: bool):
             host_platform = get_host_docker_platform()
 
             if is_linux_arm:
-                console.print(
-                    f"[yellow]![/yellow] Detected [bold]Linux ARM64[/bold] environment"
-                )
+                console.print("[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("  [dim]Mismatched images will be automatically re-pulled[/dim]")
                 console.print()
 
             console.print(f"[bold]Step 2:[/bold] Pulling {len(images)} Docker image(s)...")
@@ -382,7 +495,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
                             f"      [dim]Cached image: {image_arch} | Host: {host_arch}[/dim]"
                         )
                         console.print(
-                            f"      [dim]Removing cached image and re-pulling correct architecture...[/dim]"
+                            "      [dim]Removing cached image and re-pulling correct architecture...[/dim]"
                         )
 
                         needed_fix, fix_msg = fix_image_architecture(img)
@@ -396,7 +509,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
                             # 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]"
+                                "      [dim]No ARM variant available - re-pulling x86 version...[/dim]"
                             )
                             success = pull_image_with_progress(img)
                             if success:
@@ -407,7 +520,9 @@ def session_join(ctx, session_id: str, force_setup: bool):
                                 pulled_images.append(img)
                                 continue
                             else:
-                                console.print(f"  [red]✗[/red] {short_name} [dim](failed to pull)[/dim]")
+                                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
@@ -431,12 +546,12 @@ def session_join(ctx, session_id: str, force_setup: bool):
 
                     def show_progress(image: str, line: str):
                         # Show docker output directly - includes MB progress from PTY
-                        # Lines look like: "abc123: Downloading  360.9MB/4.075GB"
+                        # Lines look like: "abc123: Downloading [======>    ]  360.9MB/4.075GB"
                         if ": " in line:
                             parts = line.split(": ", 1)
                             if len(parts) == 2:
                                 layer_id = parts[0][-8:]
-                                layer_status = parts[1][:45]
+                                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
@@ -455,6 +570,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
                     # 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":
@@ -467,7 +583,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
                                 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]"
+                                "      [yellow]This is an x86 image - requires QEMU emulation on ARM[/yellow]"
                             )
                             x86_images_on_arm.append(img)
                         else:
@@ -499,9 +615,7 @@ def session_join(ctx, session_id: str, force_setup: bool):
                 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("  These require QEMU emulation. If container fails to start, run:")
                 console.print(
                     "  [bold]docker run --privileged --rm tonistiigi/binfmt --install all[/bold]"
                 )
@@ -518,14 +632,21 @@ def session_join(ctx, session_id: str, force_setup: bool):
 
                 # 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")
+                    console.print(
+                        "  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)
+                console.print(
+                    "Session remains active - you can retry with: hte-cli session join "
+                    + session_id
+                )
                 sys.exit(1)
 
         # Send setup_completed - THIS STARTS THE TIMER ON SERVER
@@ -566,6 +687,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:
@@ -579,16 +717,33 @@ def session_join(ctx, session_id: str, force_setup: bool):
             eval_log_bytes = result.eval_log_path.read_bytes()
     except KeyboardInterrupt:
         events.docker_stopped(exit_code=130)
+        # Try to find and upload any partial eval log before exiting
+        eval_log_bytes = _find_eval_log_bytes(runner)
+        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)
+        # Try to upload partial log on failure too
+        eval_log_bytes = _find_eval_log_bytes(runner)
+        if eval_log_bytes:
+            _upload_partial_log(api, session_id, eval_log_bytes, console)
         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)
@@ -935,7 +1090,9 @@ def diagnose_cmd():
                 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]")
+                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:
@@ -979,7 +1136,10 @@ def _check_docker() -> tuple[bool, str | None]:
             timeout=10,
         )
         if result.returncode != 0:
-            return False, "Docker is not running. Start Docker (Docker Desktop, colima, or dockerd)."
+            return (
+                False,
+                "Docker is not running. Start Docker (Docker Desktop, colima, or dockerd).",
+            )
     except FileNotFoundError:
         return False, "Docker is not installed. Install from https://docs.docker.com/get-docker/"
     except Exception as e:

{hte_cli-0.2.30 → hte_cli-0.2.32}/src/hte_cli/image_utils.py

@@ -124,6 +124,7 @@ def is_running_in_linux_vm_on_arm() -> bool:
         True if running Linux on ARM64
     """
     import sys
+
     return sys.platform == "linux" and get_host_architecture() in ("aarch64", "arm64")
 
 
@@ -313,10 +314,6 @@ def pull_image_with_progress(
 
         # Read output from master with timeout
         output_buffer = ""
-        # Regex to parse docker progress: "abc123: Downloading [===>  ] 10.5MB/50MB"
-        progress_pattern = re.compile(
-            r"([a-f0-9]+):\s*(Downloading|Extracting|Verifying Checksum|Download complete|Pull complete|Already exists|Waiting)(?:\s+\[.*?\]\s+)?(\d+\.?\d*\s*[kMG]?B)?(?:/(\d+\.?\d*\s*[kMG]?B))?"
-        )
 
         while True:
             # Check if process is done

{hte_cli-0.2.30 → hte_cli-0.2.32}/tests/unit/test_image_utils.py

@@ -610,7 +610,9 @@ class TestFixImageArchitecture:
     @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):
+    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")