foodforthought-cli 0.2.4__py3-none-any.whl → 0.2.8__py3-none-any.whl

ate/cli.py

@@ -30,30 +30,37 @@ class ATEClient:
         self.headers = {
             "Content-Type": "application/json",
         }
-        
-        # Priority: Explicit Arg > Env Var > Global Default
+        self._config = {}
+        self._device_id = None
+
+        # Try to load from config file first (device auth flow)
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE) as f:
+                    self._config = json.load(f)
+
+                    # Prefer access_token from device auth flow
+                    access_token = self._config.get("access_token")
+                    if access_token:
+                        self.headers["Authorization"] = f"Bearer {access_token}"
+                        self._device_id = self._config.get("device_id")
+                    else:
+                        # Fall back to legacy api_key
+                        stored_key = self._config.get("api_key")
+                        if stored_key:
+                            self.headers["Authorization"] = f"Bearer {stored_key}"
+            except Exception:
+                pass
+
+        # Override with explicit api_key or env var if provided
         if api_key is None:
             api_key = os.getenv("ATE_API_KEY", API_KEY)
-            
+
         if api_key:
-            # Ensure API key has correct format
-            if not api_key.startswith("ate_"):
-                print("Warning: API key should start with 'ate_'", file=sys.stderr)
             self.headers["Authorization"] = f"Bearer {api_key}"
-        else:
-            # Try to load from config file
-            if CONFIG_FILE.exists():
-                try:
-                    with open(CONFIG_FILE) as f:
-                        config = json.load(f)
-                        stored_key = config.get("api_key")
-                        if stored_key:
-                            self.headers["Authorization"] = f"Bearer {stored_key}"
-                except Exception:
-                    pass
-            
-            if "Authorization" not in self.headers:
-                print("Warning: No API key found. Set ATE_API_KEY environment variable or run 'ate login'.", file=sys.stderr)
+
+        if "Authorization" not in self.headers:
+            print("Warning: Not logged in. Run 'ate login' to authenticate.", file=sys.stderr)
 
     def _request(self, method: str, endpoint: str, **kwargs) -> Dict:
         """Make HTTP request to API"""
@@ -583,7 +590,259 @@ class ATEClient:
             print(f"\n✗ Upload failed: {e}", file=sys.stderr)
             sys.exit(1)
 
-    def check_transfer(self, skill: Optional[str], source: str, target: str, 
+    # ========================================================================
+    # Recording Methods (Data Flywheel)
+    # ========================================================================
+
+    def record_start(self, robot_id: str, skill_id: str, task_description: Optional[str] = None) -> None:
+        """Start recording telemetry from a robot"""
+        import uuid
+
+        # Store recording state in a file
+        recording_file = CONFIG_DIR / "active_recording.json"
+        CONFIG_DIR.mkdir(exist_ok=True)
+
+        if recording_file.exists():
+            print("Error: Recording already in progress. Run 'ate record stop' first.", file=sys.stderr)
+            sys.exit(1)
+
+        recording_id = str(uuid.uuid4())
+        recording_state = {
+            "id": recording_id,
+            "robot_id": robot_id,
+            "skill_id": skill_id,
+            "task_description": task_description or "",
+            "start_time": time.time(),
+            "frames": [],
+        }
+
+        with open(recording_file, "w") as f:
+            json.dump(recording_state, f, indent=2)
+
+        print(f"Recording started!")
+        print(f"  Recording ID: {recording_id}")
+        print(f"  Robot: {robot_id}")
+        print(f"  Skill: {skill_id}")
+        if task_description:
+            print(f"  Task: {task_description}")
+        print(f"\nRun 'ate record stop' when finished.")
+
+    def record_stop(self, success: bool = True, notes: Optional[str] = None,
+                   upload: bool = True, create_labeling_task: bool = False) -> None:
+        """Stop recording and optionally upload to FoodforThought"""
+        from datetime import datetime
+
+        recording_file = CONFIG_DIR / "active_recording.json"
+
+        if not recording_file.exists():
+            print("Error: No active recording. Start one with 'ate record start'.", file=sys.stderr)
+            sys.exit(1)
+
+        with open(recording_file, "r") as f:
+            recording_state = json.load(f)
+
+        # Calculate duration
+        end_time = time.time()
+        duration = end_time - recording_state["start_time"]
+        frame_count = len(recording_state.get("frames", []))
+
+        print(f"Recording stopped!")
+        print(f"  Recording ID: {recording_state['id']}")
+        print(f"  Duration: {duration:.1f}s")
+        print(f"  Frames: {frame_count}")
+        print(f"  Success: {'Yes' if success else 'No'}")
+
+        if upload:
+            print(f"\nUploading to FoodforThought...")
+
+            try:
+                recording_data = {
+                    "recording": {
+                        "id": recording_state["id"],
+                        "robotId": recording_state["robot_id"],
+                        "skillId": recording_state["skill_id"],
+                        "source": "hardware",
+                        "startTime": datetime.fromtimestamp(recording_state["start_time"]).isoformat(),
+                        "endTime": datetime.fromtimestamp(end_time).isoformat(),
+                        "success": success,
+                        "metadata": {
+                            "duration": duration,
+                            "frameRate": frame_count / duration if duration > 0 else 0,
+                            "totalFrames": frame_count,
+                            "tags": ["edge_recording", "cli"],
+                            "notes": notes,
+                        },
+                        "frames": recording_state.get("frames", []),
+                        "events": [],
+                    },
+                }
+
+                if create_labeling_task:
+                    recording_data["createLabelingTask"] = True
+
+                response = self._request("POST", "/telemetry/ingest", json=recording_data)
+
+                artifact_id = response.get("data", {}).get("artifactId", "")
+                print(f"\n✓ Uploaded successfully!")
+                print(f"  Artifact ID: {artifact_id}")
+                print(f"  View at: https://foodforthought.kindly.fyi/artifacts/{artifact_id}")
+
+                if create_labeling_task:
+                    task_id = response.get("data", {}).get("taskId", "")
+                    if task_id:
+                        print(f"  Labeling Task: https://foodforthought.kindly.fyi/labeling/{task_id}")
+
+            except Exception as e:
+                print(f"\n✗ Upload failed: {e}", file=sys.stderr)
+                print("Recording saved locally. You can upload later.", file=sys.stderr)
+
+        if notes:
+            print(f"\nNotes: {notes}")
+
+        # Remove recording state file
+        recording_file.unlink()
+
+    def record_status(self) -> None:
+        """Get current recording status"""
+        recording_file = CONFIG_DIR / "active_recording.json"
+
+        if not recording_file.exists():
+            print("No active recording session.")
+            return
+
+        with open(recording_file, "r") as f:
+            recording_state = json.load(f)
+
+        elapsed = time.time() - recording_state["start_time"]
+        frame_count = len(recording_state.get("frames", []))
+
+        print(f"Recording in progress")
+        print(f"  Recording ID: {recording_state['id']}")
+        print(f"  Robot: {recording_state['robot_id']}")
+        print(f"  Skill: {recording_state['skill_id']}")
+        print(f"  Elapsed: {elapsed:.1f}s")
+        print(f"  Frames: {frame_count}")
+        if recording_state.get("task_description"):
+            print(f"  Task: {recording_state['task_description']}")
+
+    def record_demo(self, robot_id: str, skill_id: str, task_description: str,
+                   duration_seconds: float = 30.0, create_labeling_task: bool = True) -> None:
+        """Record a timed demonstration"""
+        import uuid
+        from datetime import datetime
+
+        recording_id = str(uuid.uuid4())
+        print(f"Recording demonstration...")
+        print(f"  Recording ID: {recording_id}")
+        print(f"  Robot: {robot_id}")
+        print(f"  Skill: {skill_id}")
+        print(f"  Task: {task_description}")
+        print(f"  Duration: {duration_seconds}s")
+        print()
+
+        start_time = time.time()
+
+        # Show a countdown/progress indicator
+        elapsed = 0
+        while elapsed < duration_seconds:
+            remaining = duration_seconds - elapsed
+            print(f"\rRecording... {remaining:.0f}s remaining", end="", flush=True)
+            time.sleep(min(1.0, remaining))
+            elapsed = time.time() - start_time
+
+        end_time = time.time()
+        actual_duration = end_time - start_time
+        print(f"\rRecording complete!{' ' * 20}")
+
+        print(f"\nUploading to FoodforThought...")
+
+        try:
+            recording_data = {
+                "recording": {
+                    "id": recording_id,
+                    "robotId": robot_id,
+                    "skillId": skill_id,
+                    "source": "hardware",
+                    "startTime": datetime.fromtimestamp(start_time).isoformat(),
+                    "endTime": datetime.fromtimestamp(end_time).isoformat(),
+                    "success": True,
+                    "metadata": {
+                        "duration": actual_duration,
+                        "frameRate": 0,
+                        "totalFrames": 0,
+                        "tags": ["demonstration", "cli"],
+                        "task_description": task_description,
+                    },
+                    "frames": [],
+                    "events": [],
+                },
+            }
+
+            if create_labeling_task:
+                recording_data["createLabelingTask"] = True
+
+            response = self._request("POST", "/telemetry/ingest", json=recording_data)
+
+            artifact_id = response.get("data", {}).get("artifactId", "")
+            print(f"\n✓ Uploaded successfully!")
+            print(f"  Artifact ID: {artifact_id}")
+            print(f"  View at: https://foodforthought.kindly.fyi/artifacts/{artifact_id}")
+
+            if create_labeling_task:
+                task_id = response.get("data", {}).get("taskId", "")
+                if task_id:
+                    print(f"  Labeling Task: https://foodforthought.kindly.fyi/labeling/{task_id}")
+
+        except Exception as e:
+            print(f"\n✗ Upload failed: {e}", file=sys.stderr)
+
+    def record_list(self, robot_id: Optional[str] = None, skill_id: Optional[str] = None,
+                   success_only: bool = False, limit: int = 20) -> None:
+        """List telemetry recordings from FoodforThought"""
+        print("Fetching recordings...")
+
+        params = {
+            "type": "trajectory",
+            "limit": limit,
+        }
+
+        if robot_id:
+            params["robotModel"] = robot_id
+        if skill_id:
+            params["task"] = skill_id
+
+        try:
+            response = self._request("GET", "/artifacts", params=params)
+            artifacts = response.get("artifacts", [])
+
+            if not artifacts:
+                print("No recordings found.")
+                return
+
+            print(f"\nFound {len(artifacts)} recording(s):\n")
+
+            for artifact in artifacts:
+                metadata = artifact.get("metadata", {})
+
+                # Skip failed recordings if success_only
+                if success_only and not metadata.get("success", True):
+                    continue
+
+                success_marker = "✓" if metadata.get("success", True) else "✗"
+                print(f"{success_marker} {artifact.get('name', 'Unnamed')}")
+                print(f"    ID: {artifact.get('id')}")
+                print(f"    Robot: {metadata.get('robotId', 'Unknown')}")
+                print(f"    Skill: {metadata.get('skillId', 'Unknown')}")
+                print(f"    Duration: {metadata.get('duration', 0):.1f}s")
+                print(f"    Frames: {metadata.get('frameCount', 0)}")
+                print(f"    Source: {metadata.get('source', 'Unknown')}")
+                print()
+
+        except Exception as e:
+            print(f"Error fetching recordings: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def check_transfer(self, skill: Optional[str], source: str, target: str,
                        min_score: float) -> None:
         """Check skill transfer compatibility between robots"""
         print(f"Checking skill transfer compatibility...")
@@ -3106,33 +3365,151 @@ setup(
         ATEClient.data_upload(self, path, skill, stage)
 
 
+def _generate_pkce():
+    """Generate PKCE code verifier and challenge."""
+    import hashlib
+    import base64
+    import secrets
+
+    # Generate code verifier (43-128 chars, URL-safe)
+    code_verifier = secrets.token_urlsafe(32)
+
+    # Generate code challenge (SHA256 hash of verifier, base64url encoded)
+    digest = hashlib.sha256(code_verifier.encode()).digest()
+    code_challenge = base64.urlsafe_b64encode(digest).rstrip(b'=').decode()
+
+    return code_verifier, code_challenge
+
+
+def _generate_device_id():
+    """Generate a unique device ID for this CLI installation."""
+    import platform
+    import hashlib
+
+    # Create a stable device ID based on machine info
+    machine_info = f"{platform.node()}-{platform.system()}-{platform.machine()}"
+    return f"cli-{hashlib.sha256(machine_info.encode()).hexdigest()[:16]}"
+
+
 def login_command():
-    """Interactive login to store API key"""
-    print("Authenticate with FoodforThought")
-    print("1. Go to https://kindly.fyi/settings/keys")
-    print("2. Create a new API key")
-    print("3. Paste it here")
-    
+    """Interactive login via browser (GitHub-style device flow)"""
+    import webbrowser
+
+    print("Authenticating with FoodforThought...")
+    print()
+
+    # Generate PKCE
+    code_verifier, code_challenge = _generate_pkce()
+    device_id = _generate_device_id()
+
+    # Step 1: Initiate device auth
     try:
-        api_key = getpass.getpass("API Key: ").strip()
-    except KeyboardInterrupt:
-        print("\nLogin cancelled.")
+        response = requests.post(
+            f"{BASE_URL}/device-auth/initiate",
+            json={
+                "codeChallenge": code_challenge,
+                "deviceId": device_id,
+                "deviceName": "FoodforThought CLI",
+            },
+            timeout=10,
+        )
+        response.raise_for_status()
+        data = response.json()
+    except requests.RequestException as e:
+        print(f"Error: Failed to initiate login: {e}", file=sys.stderr)
         sys.exit(1)
-        
-    if not api_key:
-        print("Error: API key cannot be empty", file=sys.stderr)
+
+    if not data.get("success"):
+        print(f"Error: {data.get('error', 'Unknown error')}", file=sys.stderr)
         sys.exit(1)
-        
-    if not api_key.startswith("ate_"):
-        print("Warning: API key usually starts with 'ate_'. Please check your key.", file=sys.stderr)
-        if input("Continue anyway? (y/N): ").lower() != "y":
+
+    auth_url = data["authUrl"]
+    state = data["state"]
+
+    # Step 2: Open browser
+    print("Opening browser for authentication...")
+    print(f"If browser doesn't open, visit: {auth_url}")
+    print()
+
+    try:
+        webbrowser.open(auth_url)
+    except Exception:
+        pass  # Browser open is best-effort
+
+    # Step 3: Poll for authorization
+    print("Waiting for authorization...", end="", flush=True)
+
+    max_attempts = 120  # 2 minutes with 1s intervals
+    poll_interval = 1.0
+
+    for attempt in range(max_attempts):
+        time.sleep(poll_interval)
+
+        try:
+            poll_response = requests.post(
+                f"{BASE_URL}/device-auth/poll",
+                json={"state": state, "deviceId": device_id},
+                timeout=10,
+            )
+            poll_data = poll_response.json()
+        except requests.RequestException:
+            print(".", end="", flush=True)
+            continue
+
+        status = poll_data.get("status")
+
+        if status == "pending":
+            print(".", end="", flush=True)
+            continue
+        elif status == "authorized":
+            print(" authorized!")
+            callback_token = poll_data.get("token")
+            break
+        elif status == "expired":
+            print("\nError: Authorization request expired. Please try again.", file=sys.stderr)
             sys.exit(1)
-            
-    # Create config directory
+        elif status == "exchanged":
+            print("\nError: This authorization was already used. Please try again.", file=sys.stderr)
+            sys.exit(1)
+        else:
+            print(".", end="", flush=True)
+    else:
+        print("\nError: Timeout waiting for authorization.", file=sys.stderr)
+        sys.exit(1)
+
+    # Step 4: Exchange for access token
+    print("Exchanging for access token...")
+
+    try:
+        exchange_response = requests.post(
+            f"{BASE_URL}/device-auth/exchange",
+            json={
+                "token": callback_token,
+                "state": state,
+                "codeVerifier": code_verifier,
+                "deviceId": device_id,
+            },
+            timeout=10,
+        )
+        exchange_response.raise_for_status()
+        exchange_data = exchange_response.json()
+    except requests.RequestException as e:
+        print(f"Error: Failed to exchange token: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if not exchange_data.get("success"):
+        print(f"Error: {exchange_data.get('error', 'Unknown error')}", file=sys.stderr)
+        sys.exit(1)
+
+    access_token = exchange_data["accessToken"]
+    refresh_token = exchange_data["refreshToken"]
+    user = exchange_data.get("user", {})
+    expires_at = exchange_data.get("expiresAt")
+
+    # Step 5: Save credentials
     try:
         CONFIG_DIR.mkdir(parents=True, exist_ok=True)
-        
-        # Load existing config if present
+
         config = {}
         if CONFIG_FILE.exists():
             try:
@@ -3140,26 +3517,114 @@ def login_command():
                     config = json.load(f)
             except Exception:
                 pass
-                
-        # Update key
-        config["api_key"] = api_key
-        
-        # Write config
+
+        config["access_token"] = access_token
+        config["refresh_token"] = refresh_token
+        config["device_id"] = device_id
+        config["expires_at"] = expires_at
+        config["user"] = {
+            "id": user.get("id"),
+            "email": user.get("email"),
+            "name": user.get("name"),
+        }
+
         with open(CONFIG_FILE, "w") as f:
             json.dump(config, f, indent=2)
-            
-        print(f"✓ Successfully logged in. Credentials saved to {CONFIG_FILE}")
-        
+
+        # Set restrictive permissions
+        CONFIG_FILE.chmod(0o600)
+
     except Exception as e:
         print(f"Error saving credentials: {e}", file=sys.stderr)
         sys.exit(1)
 
+    print()
+    print(f"✓ Logged in as {user.get('name') or user.get('email')}")
+    print(f"  Credentials saved to {CONFIG_FILE}")
+
+
+def logout_command():
+    """Log out and remove stored credentials."""
+    if not CONFIG_FILE.exists():
+        print("Not logged in.")
+        return
+
+    try:
+        # Load config to get device_id for revoking
+        with open(CONFIG_FILE) as f:
+            config = json.load(f)
+
+        access_token = config.get("access_token")
+        device_id = config.get("device_id")
+
+        # Try to revoke the session on the server
+        if access_token and device_id:
+            try:
+                requests.post(
+                    f"{BASE_URL}/device-auth/revoke",
+                    json={"accessToken": access_token, "deviceId": device_id},
+                    timeout=5,
+                )
+            except Exception:
+                pass  # Best effort
+
+        # Remove local credentials
+        CONFIG_FILE.unlink()
+        print("✓ Logged out successfully.")
+
+    except Exception as e:
+        print(f"Error during logout: {e}", file=sys.stderr)
+        # Still try to remove the file
+        try:
+            CONFIG_FILE.unlink()
+        except Exception:
+            pass
+
+
+def whoami_command():
+    """Show current logged-in user."""
+    if not CONFIG_FILE.exists():
+        print("Not logged in. Run 'ate login' to authenticate.")
+        sys.exit(1)
+
+    try:
+        with open(CONFIG_FILE) as f:
+            config = json.load(f)
+
+        user = config.get("user", {})
+        access_token = config.get("access_token")
+        expires_at = config.get("expires_at")
+
+        if not access_token:
+            # Legacy api_key mode
+            if config.get("api_key"):
+                print("Authenticated via API key (legacy mode)")
+                print("Run 'ate login' to upgrade to device authentication.")
+                return
+            else:
+                print("Not logged in. Run 'ate login' to authenticate.")
+                sys.exit(1)
+
+        print(f"Logged in as: {user.get('name') or 'Unknown'}")
+        print(f"Email: {user.get('email') or 'Unknown'}")
+        if expires_at:
+            print(f"Session expires: {expires_at}")
+
+    except Exception as e:
+        print(f"Error reading credentials: {e}", file=sys.stderr)
+        sys.exit(1)
+
 
 def main():
     """Main CLI entry point"""
     parser = argparse.ArgumentParser(description="FoodforThought CLI")
     subparsers = parser.add_subparsers(dest="command", help="Command to run")
 
+    # Auth commands
+    subparsers.add_parser("login", help="Authenticate with FoodforThought via browser")
+    subparsers.add_parser("logout", help="Log out and remove stored credentials")
+    subparsers.add_parser("whoami", help="Show current logged-in user")
+
     # init command
     init_parser = subparsers.add_parser("init", help="Initialize a new repository")
     init_parser.add_argument("name", help="Repository name")
@@ -3741,6 +4206,59 @@ EXAMPLES:
                                                         help="Check deployment status")
     deploy_status_parser.add_argument("target", help="Target fleet or robot")
 
+    # record command - Telemetry recording for Data Flywheel
+    record_parser = subparsers.add_parser("record",
+        help="Record robot telemetry for the Data Flywheel",
+        description="""Record telemetry from robots for training data.
+
+Examples:
+    ate record start --robot my-robot --skill pick_and_place --task "Pick red cube"
+    ate record stop --success
+    ate record status
+    ate record demo --robot my-robot --skill grasp --task "Grasp object" --duration 30
+    ate record list --robot my-robot""")
+    record_subparsers = record_parser.add_subparsers(dest="record_action", help="Record action")
+
+    # record start
+    record_start_parser = record_subparsers.add_parser("start", help="Start recording telemetry")
+    record_start_parser.add_argument("--robot", "-r", required=True, help="Robot ID to record from")
+    record_start_parser.add_argument("--skill", "-s", required=True, help="Skill ID being executed")
+    record_start_parser.add_argument("--task", "-t", help="Task description (optional)")
+
+    # record stop
+    record_stop_parser = record_subparsers.add_parser("stop", help="Stop recording and upload")
+    record_stop_parser.add_argument("--success", action="store_true", default=True,
+                                   help="Mark recording as successful (default)")
+    record_stop_parser.add_argument("--failure", action="store_true",
+                                   help="Mark recording as failed")
+    record_stop_parser.add_argument("--notes", "-n", help="Notes about the recording")
+    record_stop_parser.add_argument("--no-upload", action="store_true",
+                                   help="Don't upload to FoodforThought")
+    record_stop_parser.add_argument("--create-task", action="store_true",
+                                   help="Create a labeling task for community annotation")
+
+    # record status
+    record_subparsers.add_parser("status", help="Get current recording status")
+
+    # record demo (timed demonstration)
+    record_demo_parser = record_subparsers.add_parser("demo", help="Record a timed demonstration")
+    record_demo_parser.add_argument("--robot", "-r", required=True, help="Robot ID")
+    record_demo_parser.add_argument("--skill", "-s", required=True, help="Skill being demonstrated")
+    record_demo_parser.add_argument("--task", "-t", required=True, help="Task description")
+    record_demo_parser.add_argument("--duration", "-d", type=float, default=30.0,
+                                   help="Recording duration in seconds (default: 30)")
+    record_demo_parser.add_argument("--create-task", action="store_true", default=True,
+                                   help="Create labeling task after upload (default)")
+
+    # record list
+    record_list_parser = record_subparsers.add_parser("list", help="List telemetry recordings")
+    record_list_parser.add_argument("--robot", "-r", help="Filter by robot ID")
+    record_list_parser.add_argument("--skill", "-s", help="Filter by skill ID")
+    record_list_parser.add_argument("--success-only", action="store_true",
+                                   help="Only show successful recordings")
+    record_list_parser.add_argument("--limit", "-l", type=int, default=20,
+                                   help="Maximum number of results (default: 20)")
+
     # robot-setup command - Interactive wizard for robot discovery and primitive skill generation
     robot_setup_parser = subparsers.add_parser("robot-setup",
                                                 help="Interactive wizard to discover robot and generate primitive skills")
@@ -3842,15 +4360,21 @@ EXAMPLES:
         parser.print_help()
         sys.exit(1)
 
-    # login command
-    subparsers.add_parser("login", help="Authenticate with FoodforThought")
-
-    client = ATEClient()
-
+    # Handle auth commands first (before creating client)
     if args.command == "login":
         login_command()
         return
 
+    if args.command == "logout":
+        logout_command()
+        return
+
+    if args.command == "whoami":
+        whoami_command()
+        return
+
+    client = ATEClient()
+
     if args.command == "init":
         result = client.init(args.name, args.description, args.visibility)
         print(f"Created repository: {result['repository']['id']}")
@@ -4056,6 +4580,38 @@ EXAMPLES:
         else:
             deploy_parser.print_help()
 
+    elif args.command == "record":
+        if args.record_action == "start":
+            client.record_start(args.robot, args.skill, args.task)
+        elif args.record_action == "stop":
+            success = not args.failure if hasattr(args, 'failure') else args.success
+            upload = not args.no_upload if hasattr(args, 'no_upload') else True
+            client.record_stop(
+                success=success,
+                notes=args.notes if hasattr(args, 'notes') else None,
+                upload=upload,
+                create_labeling_task=args.create_task if hasattr(args, 'create_task') else False
+            )
+        elif args.record_action == "status":
+            client.record_status()
+        elif args.record_action == "demo":
+            client.record_demo(
+                args.robot,
+                args.skill,
+                args.task,
+                args.duration,
+                args.create_task if hasattr(args, 'create_task') else True
+            )
+        elif args.record_action == "list":
+            client.record_list(
+                robot_id=args.robot if hasattr(args, 'robot') else None,
+                skill_id=args.skill if hasattr(args, 'skill') else None,
+                success_only=args.success_only if hasattr(args, 'success_only') else False,
+                limit=args.limit if hasattr(args, 'limit') else 20
+            )
+        else:
+            record_parser.print_help()
+
     elif args.command == "robot-setup":
         from ate.robot_setup import run_wizard, RobotSetupWizard