hte-cli 0.1.0__tar.gz

hte_cli-0.1.0/.gitignore

@@ -0,0 +1,43 @@
+.env
+
+docs/build/
+logs/
+data/*
+!data/keep
+results/
+docs/working-docs
+
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# cloned repos
+third-party/**
+# Continuous Claude cache (local only)
+.claude/cache/
+.claude/tsc-cache/
+.claude/hooks/node_modules/
+.claude/settings.local.json
+
+# Continuity ledgers (session-specific, not shared)
+CONTINUITY_CLAUDE-*
+
+# Thoughts directory (user-specific research and plans)
+thoughts/
+!thoughts/shared/
+!thoughts/shared/.gitkeep
+!thoughts/shared/plans/.gitkeep
+!thoughts/shared/handoffs/.gitkeep
+
+# Web UI
+web/frontend/node_modules/
+web/**/*.db
+web/backups/
+*.db

hte_cli-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: hte-cli
+Version: 0.1.0
+Summary: Human Time-to-Completion Evaluation CLI
+Project-URL: Homepage, https://github.com/sean-peters-au/lyptus-mono
+Author: Lyptus Research
+License: MIT
+Keywords: cli,cybersecurity,evaluation,human-baseline
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.24
+Requires-Dist: inspect-ai>=0.3.89
+Requires-Dist: keyring>=24.0
+Requires-Dist: platformdirs>=4.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: rich>=13.0
+Description-Content-Type: text/markdown
+
+# hte-cli
+
+Human Time-to-Completion Evaluation CLI - A tool for running assigned cybersecurity tasks with timing and result tracking.
+
+## Installation
+
+```bash
+# Recommended (pipx)
+pipx install hte-cli
+
+# Or with pip
+pip install hte-cli
+```
+
+## Quick Start
+
+1. **Login** (get credentials from your coordinator):
+   ```bash
+   hte-cli auth login
+   ```
+
+2. **View your assigned tasks**:
+   ```bash
+   hte-cli tasks list
+   ```
+
+3. **Run a task**:
+   ```bash
+   hte-cli tasks run
+   ```
+
+## Commands
+
+- `hte-cli auth login` - Authenticate with the API
+- `hte-cli auth status` - Check authentication status
+- `hte-cli tasks list` - List your pending tasks
+- `hte-cli tasks run [TASK_ID]` - Run a task (defaults to highest priority)
+- `hte-cli tasks pull-images` - Pre-pull Docker images for upcoming tasks
+- `hte-cli version` - Show version info
+
+## Requirements
+
+- Python 3.11+
+- Docker (for running tasks)
+
+## Configuration
+
+Set `HTE_API_URL` environment variable to use a custom API endpoint:
+
+```bash
+export HTE_API_URL="http://your-server.com/api/v1/cli"
+```
+
+## Support
+
+For issues, contact your study coordinator or open an issue at:
+https://github.com/sean-peters-au/lyptus-mono

hte_cli-0.1.0/README.md

@@ -0,0 +1,57 @@
+# hte-cli
+
+Human Time-to-Completion Evaluation CLI - A tool for running assigned cybersecurity tasks with timing and result tracking.
+
+## Installation
+
+```bash
+# Recommended (pipx)
+pipx install hte-cli
+
+# Or with pip
+pip install hte-cli
+```
+
+## Quick Start
+
+1. **Login** (get credentials from your coordinator):
+   ```bash
+   hte-cli auth login
+   ```
+
+2. **View your assigned tasks**:
+   ```bash
+   hte-cli tasks list
+   ```
+
+3. **Run a task**:
+   ```bash
+   hte-cli tasks run
+   ```
+
+## Commands
+
+- `hte-cli auth login` - Authenticate with the API
+- `hte-cli auth status` - Check authentication status
+- `hte-cli tasks list` - List your pending tasks
+- `hte-cli tasks run [TASK_ID]` - Run a task (defaults to highest priority)
+- `hte-cli tasks pull-images` - Pre-pull Docker images for upcoming tasks
+- `hte-cli version` - Show version info
+
+## Requirements
+
+- Python 3.11+
+- Docker (for running tasks)
+
+## Configuration
+
+Set `HTE_API_URL` environment variable to use a custom API endpoint:
+
+```bash
+export HTE_API_URL="http://your-server.com/api/v1/cli"
+```
+
+## Support
+
+For issues, contact your study coordinator or open an issue at:
+https://github.com/sean-peters-au/lyptus-mono

hte_cli-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "hte-cli"
+version = "0.1.0"
+description = "Human Time-to-Completion Evaluation CLI"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [
+    { name = "Lyptus Research" }
+]
+keywords = ["cli", "evaluation", "human-baseline", "cybersecurity"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "click>=8.0",
+    "httpx>=0.24",
+    "pydantic>=2.0",
+    "rich>=13.0",
+    "platformdirs>=4.0",
+    "keyring>=24.0",
+    "inspect-ai>=0.3.89",
+]
+
+[project.scripts]
+hte-cli = "hte_cli:main"
+
+[project.urls]
+Homepage = "https://github.com/sean-peters-au/lyptus-mono"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hte_cli"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"

hte_cli-0.1.0/src/hte_cli/__init__.py

@@ -0,0 +1,24 @@
+"""HTE-CLI: Human Time-to-Completion Evaluation CLI.
+
+A standalone CLI for experts to run assigned tasks via Docker + Inspect's human_cli,
+with results synced back to the web API.
+"""
+
+import os
+
+__version__ = "0.1.0"
+
+# Minimum API version required
+MIN_API_VERSION = "0.1.0"
+
+# API URL - configurable via HTE_API_URL env var for custom deployments
+# Default points to production deployment
+_DEFAULT_API_URL = "https://hte.lyptus.dev/api/v1/cli"
+API_BASE_URL = os.environ.get("HTE_API_URL", _DEFAULT_API_URL)
+
+
+def main():
+    """Entry point for hte-cli command."""
+    from hte_cli.cli import cli
+
+    cli()

hte_cli-0.1.0/src/hte_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as python -m hte_cli."""
+
+from hte_cli import main
+
+if __name__ == "__main__":
+    main()

hte_cli-0.1.0/src/hte_cli/api_client.py

@@ -0,0 +1,228 @@
+"""HTTP API client for HTE web backend.
+
+Handles authentication, retry logic, and API calls.
+"""
+
+import base64
+import logging
+from datetime import datetime
+from typing import Any
+
+import httpx
+
+from hte_cli import API_BASE_URL, __version__
+from hte_cli.config import Config
+
+logger = logging.getLogger(__name__)
+
+# Timeouts
+DEFAULT_TIMEOUT = 30.0  # seconds
+UPLOAD_TIMEOUT = 300.0  # 5 minutes for large eval log uploads
+
+# Retry configuration
+MAX_RETRIES = 3
+RETRY_DELAYS = [1, 5, 30]  # seconds
+
+
+class APIError(Exception):
+    """API request error."""
+
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class APIClient:
+    """HTTP client for HTE API."""
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.base_url = config.api_url or API_BASE_URL
+        self._client: httpx.Client | None = None
+
+    @property
+    def client(self) -> httpx.Client:
+        """Get or create HTTP client."""
+        if self._client is None:
+            self._client = httpx.Client(
+                base_url=self.base_url,
+                timeout=DEFAULT_TIMEOUT,
+                headers={
+                    "User-Agent": f"hte-cli/{__version__}",
+                    "X-CLI-Version": __version__,
+                },
+            )
+        return self._client
+
+    def _get_auth_headers(self) -> dict[str, str]:
+        """Get authentication headers."""
+        if not self.config.api_key:
+            raise APIError("Not authenticated. Run: hte-cli auth login")
+        return {"Authorization": f"Bearer {self.config.api_key}"}
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        """Handle API response, raising appropriate errors."""
+        if response.status_code == 401:
+            raise APIError("Authentication failed. Run: hte-cli auth login", 401)
+
+        if response.status_code == 403:
+            raise APIError("Access denied", 403)
+
+        if response.status_code == 404:
+            raise APIError("Resource not found", 404)
+
+        if response.status_code == 413:
+            raise APIError("Upload too large (max 200MB)", 413)
+
+        if response.status_code == 426:
+            raise APIError(
+                "CLI version too old. Run: pip install --upgrade hte-cli",
+                426,
+            )
+
+        if response.status_code >= 400:
+            try:
+                detail = response.json().get("detail", response.text)
+            except Exception:
+                detail = response.text
+            raise APIError(f"API error: {detail}", response.status_code)
+
+        if response.status_code == 204:
+            return None
+
+        return response.json()
+
+    def get(self, path: str, **kwargs) -> Any:
+        """Make GET request."""
+        headers = self._get_auth_headers()
+        headers.update(kwargs.pop("headers", {}))
+
+        response = self.client.get(path, headers=headers, **kwargs)
+        return self._handle_response(response)
+
+    def post(self, path: str, json: dict | None = None, **kwargs) -> Any:
+        """Make POST request with retry for transient failures."""
+        headers = self._get_auth_headers()
+        headers.update(kwargs.pop("headers", {}))
+
+        timeout = kwargs.pop("timeout", DEFAULT_TIMEOUT)
+
+        last_error = None
+        for attempt, delay in enumerate(RETRY_DELAYS):
+            try:
+                response = self.client.post(
+                    path,
+                    json=json,
+                    headers=headers,
+                    timeout=timeout,
+                    **kwargs,
+                )
+                return self._handle_response(response)
+            except httpx.TimeoutException as e:
+                last_error = APIError(f"Request timed out: {e}")
+                logger.warning(f"Attempt {attempt + 1} failed: timeout. Retrying in {delay}s...")
+            except httpx.NetworkError as e:
+                last_error = APIError(f"Network error: {e}")
+                logger.warning(f"Attempt {attempt + 1} failed: network. Retrying in {delay}s...")
+            except APIError as e:
+                # Don't retry client errors (4xx)
+                if e.status_code and 400 <= e.status_code < 500:
+                    raise
+                last_error = e
+                logger.warning(f"Attempt {attempt + 1} failed: {e}. Retrying in {delay}s...")
+
+            import time
+
+            time.sleep(delay)
+
+        raise last_error or APIError("Request failed after retries")
+
+    def get_raw(self, path: str, **kwargs) -> bytes:
+        """Make GET request returning raw bytes (for file downloads)."""
+        headers = self._get_auth_headers()
+        headers.update(kwargs.pop("headers", {}))
+
+        response = self.client.get(path, headers=headers, **kwargs)
+
+        if response.status_code >= 400:
+            self._handle_response(response)  # Will raise
+
+        return response.content
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        if self._client:
+            self._client.close()
+            self._client = None
+
+    # =========================================================================
+    # API Methods
+    # =========================================================================
+
+    def exchange_code_for_token(self, code: str) -> dict:
+        """Exchange one-time code for API key."""
+        # This endpoint doesn't require auth
+        response = self.client.post(
+            "/token",
+            json={"code": code},
+            headers={"X-CLI-Version": __version__},
+        )
+        return self._handle_response(response)
+
+    def get_assignments(self) -> list[dict]:
+        """Get pending assignments for current user."""
+        return self.get("/assignments")
+
+    def get_assignment_files(self, assignment_id: str) -> bytes:
+        """Download task files as zip."""
+        return self.get_raw(f"/assignments/{assignment_id}/files")
+
+    def get_assignment_compose(self, assignment_id: str) -> str:
+        """Get compose.yaml content."""
+        content = self.get_raw(f"/assignments/{assignment_id}/compose")
+        return content.decode("utf-8")
+
+    def start_session(self, assignment_id: str) -> dict:
+        """Start a session for an assignment.
+
+        Returns session info including session_id.
+        If session already exists, returns that session.
+        """
+        return self.post(f"/assignments/{assignment_id}/start")
+
+    def post_event(self, session_id: str, event_type: str, event_data: dict | None = None) -> dict:
+        """Post a session event."""
+        return self.post(
+            f"/sessions/{session_id}/events",
+            json={
+                "event_type": event_type,
+                "event_data": event_data,
+                "client_timestamp": datetime.utcnow().isoformat() + "Z",
+            },
+        )
+
+    def upload_result(
+        self,
+        session_id: str,
+        answer: str,
+        client_active_seconds: float,
+        eval_log_bytes: bytes | None = None,
+        score: float | None = None,
+        score_binarized: int | None = None,
+    ) -> dict:
+        """Upload task result with optional eval log."""
+        payload = {
+            "answer": answer,
+            "client_active_seconds": client_active_seconds,
+            "score": score,
+            "score_binarized": score_binarized,
+        }
+
+        if eval_log_bytes:
+            payload["eval_log_base64"] = base64.b64encode(eval_log_bytes).decode("ascii")
+
+        return self.post(
+            f"/sessions/{session_id}/result",
+            json=payload,
+            timeout=UPLOAD_TIMEOUT,
+        )