foodforthought-cli 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

ate/__init__.py

@@ -2,3 +2,9 @@
 
 __version__ = "0.2.7"
 
+# LLM Proxy for metered AI access
+try:
+    from .llm_proxy import LLMProxy, LLMProxyError, LLMResponse, get_proxy
+except ImportError:
+    pass  # Optional dependency
+

ate/__main__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+"""
+Enable running ate as a module: python -m ate
+
+This allows the CLI to be invoked via:
+    python -m ate --help
+    python -m ate robot upload mechdog --dry-run
+    python -m ate login
+
+Instead of requiring the installed entry point.
+"""
+
+from ate.cli import main
+
+if __name__ == "__main__":
+    main()

ate/auth/__init__.py

@@ -0,0 +1 @@
+"""OAuth 2.0 Device Authorization Grant (RFC 8628) auth package."""

ate/auth/device_flow.py

@@ -0,0 +1,141 @@
+"""
+OAuth 2.0 Device Authorization Grant (RFC 8628) client.
+
+Provides agent-friendly authentication for the `ate` CLI.
+The device flow allows headless/CLI clients to authenticate
+by having the user authorize on a separate device with a browser.
+"""
+
+import time
+from dataclasses import dataclass
+
+import requests
+
+
+class DeviceFlowError(Exception):
+    """General device flow error."""
+    pass
+
+
+class DeviceFlowTimeout(DeviceFlowError):
+    """Polling timed out waiting for user authorization."""
+    pass
+
+
+class DeviceFlowDenied(DeviceFlowError):
+    """User denied the authorization request."""
+    pass
+
+
+@dataclass
+class DeviceCodeResponse:
+    """Response from the device authorization endpoint."""
+    device_code: str
+    user_code: str           # e.g. "ABCD-1234" — human types this
+    verification_uri: str    # e.g. "https://kindly.fyi/device"
+    expires_in: int          # seconds (default 600)
+    interval: int            # polling interval seconds (default 5)
+
+
+@dataclass
+class TokenResponse:
+    """Token response from the token endpoint."""
+    access_token: str
+    refresh_token: str
+    expires_in: int          # seconds
+    token_type: str          # "Bearer"
+
+
+class DeviceFlowClient:
+    """OAuth 2.0 Device Authorization Grant (RFC 8628) client."""
+
+    def __init__(self, server_url: str = "https://kindly.fyi"):
+        self.server_url = server_url
+
+    def request_code(self) -> DeviceCodeResponse:
+        """POST /api/auth/device/code → DeviceCodeResponse.
+
+        Raises DeviceFlowError on HTTP or network errors.
+        """
+        try:
+            resp = requests.post(
+                f"{self.server_url}/api/auth/device/code",
+                json={"client_id": "ate-cli"},
+                timeout=10,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            return DeviceCodeResponse(
+                device_code=data["device_code"],
+                user_code=data["user_code"],
+                verification_uri=data["verification_uri"],
+                expires_in=data["expires_in"],
+                interval=data["interval"],
+            )
+        except Exception as e:
+            if isinstance(e, DeviceFlowError):
+                raise
+            raise DeviceFlowError(f"Failed to request device code: {e}") from e
+
+    def poll_for_token(
+        self,
+        device_code: str,
+        interval: int = 5,
+        expires_in: int = 600,
+    ) -> TokenResponse:
+        """Poll POST /api/auth/device/token until authorized or expired.
+
+        Returns TokenResponse on success.
+        Raises DeviceFlowTimeout if expires_in exceeded.
+        Raises DeviceFlowDenied if user denied.
+        """
+        current_interval = interval
+        start_time = time.time()
+
+        while True:
+            time.sleep(current_interval)
+
+            elapsed = time.time() - start_time
+            if elapsed > expires_in:
+                raise DeviceFlowTimeout(
+                    f"Device authorization timed out after {expires_in}s"
+                )
+
+            resp = requests.post(
+                f"{self.server_url}/api/auth/device/token",
+                json={
+                    "client_id": "ate-cli",
+                    "device_code": device_code,
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                },
+                timeout=10,
+            )
+
+            if resp.status_code == 200:
+                data = resp.json()
+                return TokenResponse(
+                    access_token=data["access_token"],
+                    refresh_token=data["refresh_token"],
+                    expires_in=data["expires_in"],
+                    token_type=data["token_type"],
+                )
+
+            # Handle error responses (400-level)
+            try:
+                error_data = resp.json()
+            except Exception:
+                continue
+
+            error = error_data.get("error", "")
+
+            if error == "authorization_pending":
+                continue
+            elif error == "slow_down":
+                current_interval += 5
+                continue
+            elif error == "access_denied":
+                raise DeviceFlowDenied("User denied the authorization request")
+            elif error == "expired_token":
+                raise DeviceFlowTimeout("Device code expired")
+            else:
+                continue

ate/auth/token_store.py

@@ -0,0 +1,96 @@
+"""
+Token persistence for OAuth 2.0 device flow credentials.
+
+Stores tokens at ~/.ate/credentials.json with expiry tracking.
+"""
+
+import json
+import os
+import time
+from typing import Optional
+
+from ate.auth.device_flow import TokenResponse
+
+
+class TokenStore:
+    """Manages token persistence at ~/.ate/credentials.json."""
+
+    def __init__(self, path: str = None):
+        self.path = path or os.path.expanduser("~/.ate/credentials.json")
+
+    def save(self, token_response: TokenResponse) -> None:
+        """Save tokens to disk (creates parent dirs).
+
+        Records saved_at timestamp for expiry calculations.
+        """
+        parent = os.path.dirname(self.path)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+
+        data = {
+            "access_token": token_response.access_token,
+            "refresh_token": token_response.refresh_token,
+            "expires_in": token_response.expires_in,
+            "token_type": token_response.token_type,
+            "saved_at": time.time(),
+        }
+
+        with open(self.path, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def load(self) -> Optional[TokenResponse]:
+        """Load tokens from disk. Returns None if no credentials or invalid."""
+        if not os.path.exists(self.path):
+            return None
+
+        try:
+            with open(self.path) as f:
+                data = json.load(f)
+            return TokenResponse(
+                access_token=data["access_token"],
+                refresh_token=data["refresh_token"],
+                expires_in=data["expires_in"],
+                token_type=data["token_type"],
+            )
+        except (json.JSONDecodeError, KeyError, TypeError):
+            return None
+
+    def clear(self) -> None:
+        """Delete stored credentials."""
+        try:
+            os.remove(self.path)
+        except FileNotFoundError:
+            pass
+
+    def _load_raw(self) -> Optional[dict]:
+        """Load raw JSON data including saved_at."""
+        if not os.path.exists(self.path):
+            return None
+        try:
+            with open(self.path) as f:
+                return json.load(f)
+        except (json.JSONDecodeError, TypeError):
+            return None
+
+    def _expires_at(self) -> Optional[float]:
+        """Calculate the absolute expiry time."""
+        data = self._load_raw()
+        if data is None:
+            return None
+        saved_at = data.get("saved_at", 0)
+        expires_in = data.get("expires_in", 0)
+        return saved_at + expires_in
+
+    def is_expired(self) -> bool:
+        """Check if the access token has expired."""
+        expires_at = self._expires_at()
+        if expires_at is None:
+            return True
+        return time.time() >= expires_at
+
+    def needs_refresh(self) -> bool:
+        """Check if token is within 5 minutes of expiry."""
+        expires_at = self._expires_at()
+        if expires_at is None:
+            return True
+        return time.time() >= (expires_at - 300)

ate/behaviors/__init__.py

@@ -0,0 +1,100 @@
+"""
+Behavior Tree framework for composing robot skills.
+
+Behavior trees allow complex behaviors to be built from simple skills
+using a tree structure of:
+- Sequences (do A, then B, then C)
+- Selectors (try A, if fails try B)
+- Conditions (if X is true...)
+- Actions (do X)
+
+This is how we turn small demos into valuable composite behaviors.
+"""
+
+from .tree import (
+    BehaviorNode,
+    BehaviorStatus,
+    Sequence,
+    Selector,
+    Parallel,
+    Action,
+    Condition,
+    Inverter,
+    Succeeder,
+    Repeater,
+    RepeatUntilFail,
+    BehaviorTree,
+)
+
+from .common import (
+    # Navigation
+    NavigateToPoint,
+    NavigateToPose,
+    Patrol,
+    ReturnHome,
+    # Detection
+    DetectObject,
+    IsObjectVisible,
+    FindNearest,
+    ApproachObject,
+    # Manipulation
+    PickUp,
+    PlaceAt,
+    DropInBin,
+    # Conditions
+    IsBatteryLow,
+    IsPathClear,
+    HasObject,
+    # Composite behaviors
+    PatrolAndCleanup,
+    SearchAndRetrieve,
+)
+
+from .approach import (
+    ApproachState,
+    ApproachConfig,
+    ApproachTarget,
+    VisualServoApproach,
+)
+
+__all__ = [
+    # Core tree nodes
+    "BehaviorNode",
+    "BehaviorStatus",
+    "Sequence",
+    "Selector",
+    "Parallel",
+    "Action",
+    "Condition",
+    "Inverter",
+    "Succeeder",
+    "Repeater",
+    "RepeatUntilFail",
+    "BehaviorTree",
+    # Navigation actions
+    "NavigateToPoint",
+    "NavigateToPose",
+    "Patrol",
+    "ReturnHome",
+    # Detection actions
+    "DetectObject",
+    "IsObjectVisible",
+    "FindNearest",
+    "ApproachObject",
+    # Manipulation actions
+    "PickUp",
+    "PlaceAt",
+    "DropInBin",
+    # Conditions
+    "IsBatteryLow",
+    "IsPathClear",
+    "HasObject",
+    # Composite behaviors
+    "PatrolAndCleanup",
+    "SearchAndRetrieve",
+    # Approach behaviors (locomotion-agnostic)
+    "ApproachState",
+    "ApproachConfig",
+    "ApproachTarget",
+    "VisualServoApproach",
+]