cyberwave-cli 0.11.0__py3-none-any.whl

cyberwave_cli/__init__.py

@@ -0,0 +1 @@
+# Init for cyberwave_cli package 

cyberwave_cli/core.py

@@ -0,0 +1,42 @@
+import typer
+from rich import print
+from .plugins import loader
+
+app = typer.Typer(rich_markup_mode="markdown")
+
+def main():
+    # Discover and register plugins
+    loader.register_all(app)
+    # Run the app
+    app()
+
+@app.callback()
+def callback():
+    """
+    CyberWave Command-Line Interface
+    """
+    pass
+
+@app.command()
+def version() -> None:
+    """Show the installed CLI version."""
+    import importlib.metadata
+
+    cli_version = importlib.metadata.version("cyberwave-cli")
+    print(f"CyberWave CLI version: [bold green]{cli_version}[/bold green]")
+
+
+@app.command()
+def plugins_cmd() -> None:
+    """List available CLI plugins."""
+    plugin_names = loader.discover_plugins()
+    if not plugin_names:
+        print("No plugins found")
+    else:
+        print("Loaded plugins:")
+        for name in plugin_names:
+            print(f"- {name}")
+
+
+if __name__ == "__main__":
+    main() 

cyberwave_cli/plugins/__init__.py

@@ -0,0 +1 @@
+# Init for cyberwave_cli.plugins package 

cyberwave_cli/plugins/assets/__init__.py

@@ -0,0 +1 @@
+# Init for assets plugin 

cyberwave_cli/plugins/assets/app.py

@@ -0,0 +1,87 @@
+import asyncio
+import re
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich import print
+
+from cyberwave import Client
+
+app = typer.Typer(help="Manage CyberWave assets (upload meshes to the catalog, list).")
+
+
+def _simple_slugify(text: str) -> str:
+    """Very small helper to create URL-friendly slugs."""
+    slug = re.sub(r"[^a-zA-Z0-9-]+", "-", text.lower()).strip("-")
+    return slug
+
+
+async def _upload_asset(
+    mesh_path: Path,
+    name: str,
+    workspace_uuid: str,
+    project_uuid: str,
+    description: Optional[str],
+    registry_id: Optional[str],
+) -> None:
+    client = Client()
+    await client.login()
+    # Create a simple catalog asset and attach a GLB file
+    # Prefer high-level helpers if present (test stub API)
+    if hasattr(client, "create_asset_definition"):
+        created = await client.create_asset_definition(name=name)
+        await client.upload_mesh(created["id"], mesh_path)
+        await client.add_geometry_to_asset_definition(created["id"])
+        print(f":white_check_mark: Created asset '[bold]{name}[/bold]' (ID {created['id']}) and uploaded GLB")
+        return
+    # Fallback to raw request + upload the GLB
+    created = await client._request(
+        "POST",
+        "/assets",
+        json={
+            "name": name,
+            "description": description or "",
+            "public": False,
+            "registry_id": registry_id,
+        },
+    )
+    asset = created.json() if hasattr(created, "json") else created
+    await client.upload_asset_glb(asset.get("uuid") or asset.get("id"), mesh_path)
+    # If no thumbnail, attempt to auto-generate a simple one from the GLB path (placeholder icon)
+    # Backend may also generate thumbnails asynchronously; this is a best-effort client-side fallback.
+    try:
+        # For now, rely on backend pipeline; printing hint for the user.
+        print(":bulb: If the asset lacks a thumbnail, the backend will attempt to generate one.")
+    except Exception:
+        pass
+    print(f":white_check_mark: Created asset '[bold]{name}[/bold]' (UUID {asset['uuid']}) and uploaded GLB")
+
+@app.command()
+def upload(
+    mesh: Path = typer.Argument(..., exists=True, help="Path to a mesh file"),
+    name: str = typer.Option(..., "--name", help="Name for the catalog entry"),
+    workspace: str = typer.Option(..., "--workspace", "-w", help="Workspace UUID"),
+    project: str = typer.Option(..., "--project", "-p", help="Project UUID (for future)"),
+    registry_id: Optional[str] = typer.Option(None, "--registry-id", help="Catalog registry identifier (e.g., so/100)"),
+    description: Optional[str] = typer.Option(None, "--description", help="Description"),
+):
+    """Upload a mesh and create a catalog asset definition."""
+
+    asyncio.run(_upload_asset(mesh, name, workspace, project, description, registry_id))
+
+@app.command("list") # Explicit command name
+def list_assets():
+    """List available assets in CyberWave storage."""
+    async def _run() -> None:
+        client = Client()
+        await client.login()
+        assets = await client.list_assets()
+        for a in assets:
+            rid = a.get("registry_id") or (a.get("metadata", {}) or {}).get("registry_id")
+            print(f"{a.get('uuid')}  {a.get('name')}  registry_id={rid}")
+
+    asyncio.run(_run())
+
+if __name__ == "__main__":
+    app()

cyberwave_cli/plugins/auth/__init__.py

@@ -0,0 +1 @@
+# Auth plugin for web-based authentication 

cyberwave_cli/plugins/auth/app.py

@@ -0,0 +1,340 @@
+import asyncio
+import webbrowser
+import time
+import json
+from pathlib import Path
+from typing import Optional, Dict, Any
+import os
+
+import typer
+from rich import print
+from rich.prompt import Confirm
+from rich.console import Console
+from rich.table import Table
+import httpx
+
+console = Console()
+app = typer.Typer(help="Authentication and configuration management")
+
+# Configuration constants
+CONFIG_DIR = Path.home() / ".cyberwave"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+DEFAULT_FRONTEND_URL = "http://localhost:3000"
+DEFAULT_BACKEND_URL = "http://localhost:8000"
+
+
+class DeviceAuthFlow:
+    """Handles device flow authentication with the CyberWave platform."""
+    
+    def __init__(self, backend_url: str, frontend_url: str):
+        self.backend_url = backend_url.rstrip('/')
+        self.frontend_url = frontend_url.rstrip('/')
+        self.client = httpx.AsyncClient(timeout=30.0)
+    
+    async def initiate_device_flow(self) -> Dict[str, Any]:
+        """
+        Initiate device flow authentication.
+        Returns device code, user code, and verification URLs.
+        """
+        try:
+            response = await self.client.post(
+                f"{self.backend_url}/api/v1/auth/device/initiate",
+                json={"client_type": "cli"}
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as e:
+            raise typer.Exit(f"Failed to initiate device flow: {e}")
+    
+    async def poll_for_token(self, device_code: str, interval: int = 5) -> Optional[Dict[str, Any]]:
+        """
+        Poll the backend for token completion.
+        Returns tokens when user completes authentication, None if still pending.
+        """
+        try:
+            response = await self.client.post(
+                f"{self.backend_url}/api/v1/auth/device/token",
+                json={"device_code": device_code}
+            )
+            
+            if response.status_code == 200:
+                return response.json()
+            elif response.status_code == 202:
+                # Still pending
+                return None
+            else:
+                response.raise_for_status()
+        except httpx.HTTPError:
+            return None
+    
+    async def close(self):
+        """Close the HTTP client."""
+        await self.client.aclose()
+
+
+def load_config() -> Dict[str, Any]:
+    """Load CLI configuration from file."""
+    if not CONFIG_FILE.exists():
+        return {}
+    
+    try:
+        import tomllib
+    except ImportError:
+        try:
+            import tomli as tomllib
+        except ImportError:
+            print("[red]Error: Neither tomllib nor tomli is available. Please install tomli: pip install tomli[/red]")
+            raise typer.Exit(1)
+    
+    try:
+        with open(CONFIG_FILE, 'rb') as f:
+            return tomllib.load(f)
+    except Exception as e:
+        print(f"[red]Error reading config file: {e}[/red]")
+        return {}
+
+
+def save_config(config: Dict[str, Any]) -> None:
+    """Save CLI configuration to file."""
+    CONFIG_DIR.mkdir(exist_ok=True)
+    
+    try:
+        import tomli_w
+    except ImportError:
+        print("[red]Error: tomli_w is not available. Please install tomli-w: pip install tomli-w[/red]")
+        raise typer.Exit(1)
+    
+    try:
+        with open(CONFIG_FILE, 'wb') as f:
+            tomli_w.dump(config, f)
+        print(f"[green]Configuration saved to {CONFIG_FILE}[/green]")
+    except Exception as e:
+        print(f"[red]Error saving config: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def login(
+    backend_url: Optional[str] = typer.Option(None, "--backend-url", help="Backend URL"),
+    frontend_url: Optional[str] = typer.Option(None, "--frontend-url", help="Frontend URL"),
+    no_browser: bool = typer.Option(False, "--no-browser", help="Don't open browser automatically")
+) -> None:
+    """
+    Authenticate with CyberWave using web-based device flow.
+    
+    This will open your web browser to complete authentication on the CyberWave platform.
+    """
+    asyncio.run(_login_flow(backend_url, frontend_url, no_browser))
+
+
+async def _login_flow(backend_url: Optional[str], frontend_url: Optional[str], no_browser: bool) -> None:
+    """Async implementation of login flow."""
+    config = load_config()
+    
+    # Use provided URLs or fall back to config or defaults
+    backend_url = backend_url or config.get("backend_url", DEFAULT_BACKEND_URL)
+    frontend_url = frontend_url or config.get("frontend_url", DEFAULT_FRONTEND_URL)
+    
+    print(f"[cyan]Initiating authentication with CyberWave...[/cyan]")
+    print(f"Backend: {backend_url}")
+    print(f"Frontend: {frontend_url}")
+    
+    auth_flow = DeviceAuthFlow(backend_url, frontend_url)
+    
+    try:
+        # Step 1: Initiate device flow
+        device_data = await auth_flow.initiate_device_flow()
+        
+        device_code = device_data["device_code"]
+        user_code = device_data["user_code"]
+        verification_url = device_data["verification_url"]
+        expires_in = device_data.get("expires_in", 300)  # 5 minutes default
+        interval = device_data.get("interval", 5)  # 5 seconds default
+        
+        # Step 2: Display instructions to user
+        print(f"\n[bold yellow]Authentication Required[/bold yellow]")
+        print(f"Please visit: [bold blue]{verification_url}[/bold blue]")
+        print(f"And enter the code: [bold green]{user_code}[/bold green]")
+        print(f"\nCode expires in {expires_in} seconds")
+        
+        # Step 3: Open browser (unless disabled)
+        if not no_browser:
+            try:
+                # Construct the full URL with the user code
+                full_url = f"{frontend_url}/auth/device?user_code={user_code}"
+                webbrowser.open(full_url)
+                print(f"[dim]Opened browser to: {full_url}[/dim]")
+            except Exception as e:
+                print(f"[yellow]Could not open browser automatically: {e}[/yellow]")
+        
+        # Step 4: Poll for completion
+        print(f"\n[dim]Waiting for authentication completion...[/dim]")
+        start_time = time.time()
+        
+        with console.status("[bold green]Waiting for authentication...") as status:
+            while time.time() - start_time < expires_in:
+                token_data = await auth_flow.poll_for_token(device_code, interval)
+                
+                if token_data:
+                    # Success! Store tokens
+                    print(f"\n[green]✓ Authentication successful![/green]")
+                    
+                    # Save tokens using the SDK's token storage
+                    from cyberwave import Client
+                    client = Client(base_url=backend_url)
+                    client._access_token = token_data["access_token"]
+                    client._refresh_token = token_data.get("refresh_token")
+                    client._session_info = {k: v for k, v in token_data.items() 
+                                          if k not in ["access_token", "refresh_token"]}
+                    
+                    if client._use_token_cache:
+                        client._save_token_to_cache()
+                    
+                    # Update config with URLs
+                    config.update({
+                        "backend_url": backend_url,
+                        "frontend_url": frontend_url,
+                        "default_workspace": token_data.get("default_workspace"),
+                        "default_project": token_data.get("default_project")
+                    })
+                    save_config(config)
+                    
+                    # Display user info
+                    try:
+                        user_info = await client.get_current_user_info()
+                        print(f"Logged in as: [bold]{user_info.get('email', 'Unknown')}[/bold]")
+                    except Exception:
+                        print("Logged in successfully!")
+                    
+                    await client.aclose()
+                    return
+                
+                # Wait before next poll
+                await asyncio.sleep(interval)
+                status.update(f"[bold green]Waiting for authentication... ({int(expires_in - (time.time() - start_time))}s remaining)")
+        
+        print(f"\n[red]✗ Authentication timed out. Please try again.[/red]")
+        
+    except Exception as e:
+        print(f"[red]✗ Authentication failed: {e}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await auth_flow.close()
+
+
+@app.command()
+def logout() -> None:
+    """Log out and clear stored authentication."""
+    try:
+        from cyberwave import Client
+        
+        # Clear tokens from cache
+        client = Client()
+        asyncio.run(client.logout())
+        
+        print("[green]✓ Successfully logged out[/green]")
+    except Exception as e:
+        print(f"[red]Error during logout: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def status() -> None:
+    """Show current authentication and configuration status."""
+    config = load_config()
+    
+    # Check if user is authenticated
+    from cyberwave import Client
+    client = Client()
+    
+    table = Table(title="CyberWave CLI Status", show_header=True, header_style="bold magenta")
+    table.add_column("Setting", style="cyan", width=20)
+    table.add_column("Value", style="white")
+    
+    # Authentication status
+    if client._access_token:
+        table.add_row("Authentication", "[green]✓ Authenticated[/green]")
+        
+        # Try to get user info
+        try:
+            user_info = asyncio.run(client.get_current_user_info())
+            table.add_row("User", user_info.get('email', 'Unknown'))
+        except Exception:
+            table.add_row("User", "[yellow]Token may be expired[/yellow]")
+    else:
+        table.add_row("Authentication", "[red]✗ Not authenticated[/red]")
+    
+    # Configuration
+    table.add_row("Backend URL", config.get("backend_url", DEFAULT_BACKEND_URL))
+    table.add_row("Frontend URL", config.get("frontend_url", DEFAULT_FRONTEND_URL))
+    table.add_row("Default Workspace", str(config.get("default_workspace", "Not set")))
+    table.add_row("Default Project", str(config.get("default_project", "Not set")))
+    table.add_row("Config File", str(CONFIG_FILE))
+    
+    console.print(table)
+
+
+@app.command()
+def config(
+    key: Optional[str] = typer.Argument(None, help="Configuration key to set or get"),
+    value: Optional[str] = typer.Argument(None, help="Value to set (omit to get current value)"),
+    list_all: bool = typer.Option(False, "--list", "-l", help="List all configuration"),
+    unset: bool = typer.Option(False, "--unset", "-u", help="Unset a configuration key")
+) -> None:
+    """
+    Manage CLI configuration.
+    
+    Examples:
+        cyberwave auth config backend_url http://localhost:8000
+        cyberwave auth config backend_url
+        cyberwave auth config --list
+        cyberwave auth config --unset default_workspace
+    """
+    current_config = load_config()
+    
+    if list_all or (key is None and value is None):
+        # List all configuration
+        if not current_config:
+            print("[yellow]No configuration found[/yellow]")
+            return
+        
+        table = Table(title="Configuration", show_header=True, header_style="bold magenta")
+        table.add_column("Key", style="cyan")
+        table.add_column("Value", style="white")
+        
+        for k, v in current_config.items():
+            table.add_row(k, str(v))
+        
+        console.print(table)
+        return
+    
+    if key is None:
+        print("[red]Error: Please specify a configuration key[/red]")
+        raise typer.Exit(1)
+    
+    if unset:
+        # Unset a key
+        if key in current_config:
+            del current_config[key]
+            save_config(current_config)
+            print(f"[green]Unset {key}[/green]")
+        else:
+            print(f"[yellow]Key '{key}' not found[/yellow]")
+        return
+    
+    if value is None:
+        # Get current value
+        if key in current_config:
+            print(f"{key} = {current_config[key]}")
+        else:
+            print(f"[yellow]Key '{key}' not found[/yellow]")
+        return
+    
+    # Set value
+    current_config[key] = value
+    save_config(current_config)
+    print(f"[green]Set {key} = {value}[/green]")
+
+
+if __name__ == "__main__":
+    app() 

cyberwave_cli/plugins/devices/__init__.py

@@ -0,0 +1 @@
+# Device management CLI plugin

cyberwave_cli/plugins/devices/app.py

@@ -0,0 +1,49 @@
+import asyncio
+from typing import Optional
+
+import typer
+from rich import print
+
+from cyberwave import Client
+
+app = typer.Typer(help="Manage devices (registration and tokens)")
+
+
+@app.command("register")
+def register_device(
+    project: int = typer.Option(..., "--project", "-p", help="Project ID"),
+    name: str = typer.Option(..., "--name", "-n", help="Device name"),
+    type: str = typer.Option(..., "--type", "-t", help="Device type"),
+    asset: Optional[str] = typer.Option(None, "--asset", "-a", help="Asset catalog UUID"),
+) -> None:
+    """Register a new device."""
+
+    async def _run() -> None:
+        client = Client()
+        await client.login()
+        device = await client.register_device(
+            project_id=project,
+            name=name,
+            device_type=type,
+            asset_catalog_uuid=asset,
+        )
+        print(f":white_check_mark: Registered device [bold]{name}[/bold] (ID {device['id']})")
+
+    asyncio.run(_run())
+
+
+@app.command("issue-offline-token")
+def issue_offline_token(device: int = typer.Option(..., "--device", "-d", help="Device ID")) -> None:
+    """Issue an offline token for a device."""
+
+    async def _run() -> None:
+        client = Client()
+        await client.login()
+        token = await client.issue_device_token(device_id=device)
+        print(f":key: Offline token for device {device}: [bold]{token}[/bold]")
+
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    app()

cyberwave_cli/plugins/edge/app.py

@@ -0,0 +1,149 @@
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich import print
+
+from cyberwave import Client
+
+app = typer.Typer(help="Configure and run Cyberwave Edge nodes")
+
+DEFAULT_EDGE_CONFIG = Path.home() / ".cyberwave" / "edge.json"
+
+
+def _write_config_file(cfg_path: Path, data: dict) -> None:
+    cfg_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(cfg_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+    os.chmod(cfg_path, 0o600)
+
+
+@app.command("init")
+def init(
+    robot: str = typer.Option(..., "--robot", help="Robot driver type, e.g. so_arm100"),
+    port: Optional[str] = typer.Option(None, "--port", help="Serial/connection port for the robot"),
+    backend: Optional[str] = typer.Option(None, "--backend", help="Backend base URL (e.g. http://localhost:8000/api/v1)"),
+    device_id: Optional[int] = typer.Option(None, "--device-id", help="Existing device ID"),
+    project_id: Optional[int] = typer.Option(None, "--project", help="Project ID for auto-registration"),
+    device_name: Optional[str] = typer.Option(None, "--device-name", help="Device name for auto-registration"),
+    device_type: Optional[str] = typer.Option("robot/so-arm100", "--device-type", help="Device type for auto-registration"),
+    auto_register: bool = typer.Option(False, "--auto-register", help="Register device if device_id not provided"),
+    use_device_token: bool = typer.Option(False, "--use-device-token", help="Issue and use a device token for offline operation"),
+    loop_hz: float = typer.Option(20.0, "--loop-hz", help="Polling frequency (Hz)"),
+    config: Path = typer.Option(DEFAULT_EDGE_CONFIG, "--config", help="Where to write the Edge config JSON"),
+) -> None:
+    """Create or update an Edge node configuration file."""
+
+    data = {
+        "robot_type": robot,
+        "robot_port": port,
+        "backend_url": backend,
+        "device_id": device_id,
+        "project_id": project_id,
+        "device_name": device_name,
+        "device_type": device_type,
+        "auto_register_device": auto_register,
+        "use_device_token": use_device_token,
+        "loop_hz": loop_hz,
+    }
+
+    # Attempt to reuse existing CLI auth to fill backend if not provided
+    if backend is None:
+        from cyberwave_cli.plugins.auth.app import load_config as _load_cli_cfg, DEFAULT_BACKEND_URL
+        cli_cfg = _load_cli_cfg()
+        data["backend_url"] = cli_cfg.get("backend_url", DEFAULT_BACKEND_URL) + "/api/v1"
+
+    # If auto-register requested and no device_id, perform registration and optionally issue a token
+    if auto_register and not device_id:
+        if not project_id or not device_name or not device_type:
+            raise typer.Exit("--project, --device-name, and --device-type are required for --auto-register")
+        async def _run():
+            client = Client(base_url=data["backend_url"])
+            await client.login()
+            dev = await client.register_device(project_id=project_id, name=device_name, device_type=device_type)
+            data["device_id"] = int(dev.get("id"))
+            if use_device_token:
+                token = await client.issue_device_token(device_id=data["device_id"])
+                data["access_token"] = token
+            await client.aclose()
+        import asyncio; asyncio.run(_run())
+
+    _write_config_file(config, data)
+    print(f":white_check_mark: Edge config written to [bold]{config}[/bold]")
+
+
+@app.command("run")
+def run(config: Path = typer.Option(DEFAULT_EDGE_CONFIG, "--config", help="Edge config JSON path")) -> None:
+    """Run the Edge node with the provided configuration file."""
+    if not config.exists():
+        raise typer.Exit(f"Config file not found: {config}")
+    # Prefer running the module directly to use current env
+    cmd = ["python", "-m", "cyberwave_edge.main", "--config", str(config)]
+    print(f"Starting Edge: {' '.join(cmd)}")
+    subprocess.run(cmd, check=False)
+
+
+@app.command("simulate")
+def simulate(
+    sensor: str = typer.Option(..., "--sensor", "-s", help="Sensor UUID"),
+    video: Path = typer.Option(..., "--video", "-v", help="Path to local mp4"),
+    fps: float = typer.Option(2.0, "--fps"),
+) -> None:
+    """Stream a local video file as a virtual camera to a sensor."""
+    cmd = [
+        "python", "-m", "cyberwave_edge.camera_worker",
+        "--sensor", sensor,
+        "--source", str(video),
+        "--fps", str(fps),
+    ]
+    print(f"Simulating edge camera: {' '.join(cmd)}")
+    subprocess.run(cmd, check=False)
+
+@app.command("status")
+def status(config: Path = typer.Option(DEFAULT_EDGE_CONFIG, "--config", help="Edge config JSON path")) -> None:
+    """Quick diagnostics for Edge configuration and cloud connectivity."""
+    if not config.exists():
+        raise typer.Exit(f"Config file not found: {config}")
+    with open(config, "r", encoding="utf-8") as f:
+        cfg = json.load(f)
+
+    missing = [k for k in ("robot_type", "backend_url") if not cfg.get(k)]
+    if missing:
+        print(f"[red]Missing required config keys: {missing}[/red]")
+        raise typer.Exit(1)
+
+    # Try SDK token and device reachability
+    async def _check():
+        client = Client(base_url=cfg["backend_url"])
+        try:
+            await client.login()  # uses cached token via SDK
+        except Exception:
+            if tok := cfg.get("access_token"):
+                client._access_token = tok  # fallback to provided device token
+            else:
+                print("[yellow]No active session; telemetry may fail without token[/yellow]")
+        did = cfg.get("device_id")
+        ok = True
+        if did:
+            try:
+                # simple check: send empty telemetry as dry run
+                await client.send_telemetry(did, {"ping": True})
+                print(f"[green]✓ Cloud reachable. Device {did} accepted telemetry[/green]")
+            except Exception as e:
+                ok = False
+                print(f"[red]✗ Telemetry check failed for device {did}: {e}[/red]")
+        await client.aclose()
+        return ok
+
+    import asyncio; ok = asyncio.run(_check())
+    if not ok:
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()
+
+

cyberwave_cli/plugins/environments/app.py

@@ -0,0 +1,75 @@
+import asyncio
+import typer
+from rich import print
+
+from cyberwave import Client
+
+app = typer.Typer(help="Manage environments")
+
+
+@app.command("create")
+def create(
+    project: str = typer.Option(..., "--project", "-p", help="Project UUID"),
+    name: str = typer.Option(..., "--name", "-n"),
+    description: str = typer.Option("", "--description", "-d"),
+):
+    async def _run():
+        client = Client()
+        await client.login()
+        env = await client.create_environment(project_uuid=project, name=name, description=description)
+        print(f"[green]✓[/green] Created environment [bold]{env.get('name')}[/bold] (UUID {env.get('uuid')})")
+        await client.aclose()
+    asyncio.run(_run())
+
+
+@app.command("list")
+def list_envs(project: str = typer.Option(..., "--project", "-p", help="Project UUID")):
+    async def _run():
+        client = Client()
+        await client.login()
+        envs = await client.get_environments(project_uuid=project)
+        for e in envs:
+            print(f"- {e.get('name')} ({e.get('uuid')})")
+        await client.aclose()
+    asyncio.run(_run())
+
+
+@app.command("events")
+def list_events(
+    environment: str = typer.Option(..., "--environment", "-e", help="Environment UUID"),
+    limit: int = typer.Option(10, "--limit", "-n", help="Max entries to show"),
+    json_out: bool = typer.Option(False, "--json", help="Emit JSON output"),
+):
+    """List recent environment events (latest session per twin), including segment thumbnails when available."""
+    async def _run():
+        client = Client()
+        await client.login()
+        resp = await client._client.get(f"/environments/{environment}/events", headers=client._get_headers())
+        resp.raise_for_status()
+        data = resp.json()
+        from datetime import datetime
+        if json_out:
+            import json as _json
+            print(_json.dumps(data[:limit], indent=2))
+        else:
+            shown = 0
+            for item in data:
+                if shown >= limit:
+                    break
+                twin = item.get("twin_uuid")
+                sess = item.get("session", {})
+                seg = item.get("segment") or {}
+                ts = sess.get("started_at_unix")
+                ts_str = datetime.fromtimestamp(ts).isoformat() if ts else "?"
+                seg_url = seg.get("url")
+                seg_key = seg.get("storage_key")
+                print(f"- twin={twin} started_at={ts_str} segment_key={seg_key} segment_url={seg_url}")
+                shown += 1
+        await client.aclose()
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    app()
+
+

cyberwave_cli/plugins/loader.py

@@ -0,0 +1,43 @@
+import typer
+import importlib.metadata as metadata
+from rich import print
+
+
+from importlib.metadata import EntryPoint
+from typing import Iterable, List
+
+
+def _get_entry_points(group: str) -> Iterable[EntryPoint]:
+    """Return entry points for the given group across Python versions."""
+    try:  # Python >=3.10
+        return metadata.entry_points(group=group)
+    except TypeError:  # Python <3.10
+        return metadata.entry_points().get(group, [])
+
+
+def discover_plugins() -> List[str]:
+    """Return a list of available plugin names."""
+    return [ep.name for ep in _get_entry_points("cyberwave.cli.plugins")]
+
+def register_all(root_app: typer.Typer) -> None:
+    """Discovers and registers all plugins declared via entry points."""
+    print("[dim]Discovering CLI plugins...[/dim]")
+    discovered_plugins = list(_get_entry_points("cyberwave.cli.plugins"))
+
+    if not discovered_plugins:
+        print("[dim]No external plugins found.[/dim]")
+        return
+
+    for ep in discovered_plugins:
+        print(f"  - Loading plugin: [bold cyan]{ep.name}[/bold cyan]")
+        try:
+            sub_app = ep.load()
+            if isinstance(sub_app, typer.Typer):
+                root_app.add_typer(sub_app, name=ep.name)
+                print(f"    [green]✓[/green] Registered typer app for '[bold]{ep.name}[/bold]'")
+            else:
+                # Handle single commands if needed, though spec implies Typer apps
+                 print(f"    [yellow]⚠[/yellow] Plugin '[bold]{ep.name}[/bold]' did not load a Typer app. Skipping.")
+        except Exception as e:
+            print(f"    [red]✗[/red] Failed to load plugin '[bold]{ep.name}[/bold]': {e}") 
+

cyberwave_cli/plugins/projects/__init__.py

@@ -0,0 +1 @@
+# Init for projects plugin

cyberwave_cli/plugins/projects/app.py

@@ -0,0 +1,55 @@
+import asyncio
+from typing import List, Dict
+
+import typer
+from rich import print
+
+from cyberwave import Client
+
+app = typer.Typer(help="Manage projects within a workspace")
+
+
+@app.command()
+def create(
+    name: str = typer.Option(..., "--name", "-n", help="Project name"),
+    workspace: str = typer.Option(..., "--workspace", "-w", help="Workspace UUID"),
+) -> None:
+    """Create a new project."""
+
+    async def _run() -> None:
+        client = Client()
+        await client.login()
+        # Ensure workspace_id is numeric if API expects int
+        try:
+            ws_id = int(workspace)
+        except Exception:
+            ws_id = workspace
+        project = await client.create_project(workspace_id=ws_id, name=name)
+        print(f":white_check_mark: Created project [bold]{name}[/bold] (UUID {project.get('uuid') or project.get('id')})")
+
+    asyncio.run(_run())
+
+
+@app.command("list")
+def list_projects(
+    workspace: str = typer.Option(..., "--workspace", "-w", help="Workspace UUID"),
+) -> None:
+    """List projects within a workspace."""
+
+    async def _run() -> None:
+        client = Client()
+        await client.login()
+        try:
+            ws_id = int(workspace)
+        except Exception:
+            ws_id = workspace
+        projects: List[Dict] = await client.get_projects(workspace_id=ws_id)
+        for proj in projects:
+            print(f"{proj.get('uuid') or proj.get('id')}: {proj.get('name')}")
+
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    app()
+

cyberwave_cli/plugins/sensors/app.py

@@ -0,0 +1,138 @@
+import asyncio
+import typer
+from rich import print
+
+from cyberwave import Client
+import httpx
+import json
+
+app = typer.Typer(help="Manage sensors")
+
+
+@app.command("list")
+def list_sensors(environment: str = typer.Option(..., "--environment", "-e", help="Environment UUID")):
+    async def _run():
+        client = Client()
+        await client.login()
+        sensors = await client._client.get(f"/environments/{environment}/sensors", headers=client._get_headers())
+        sensors.raise_for_status()
+        for s in sensors.json():
+            print(f"- {s.get('name')} ({s.get('uuid')}) type={s.get('sensor_type')} twin={s.get('twin_uuid')}")
+        await client.aclose()
+    asyncio.run(_run())
+
+
+@app.command("events")
+def sensor_events(
+    sensor_uuid: str = typer.Option(..., "--sensor", "-s"),
+    environment: str = typer.Option(None, "--environment", "-e", help="Environment UUID (to locate latest session)"),
+    limit: int = typer.Option(50, "--limit", "-n"),
+):
+    """Tail analyzer events for a sensor.
+
+    - Backend mode (default): polls /api/v1/sensors/{sensor_uuid}/events and prints latest events.
+    - Node+session mode (fallback): if --environment is provided and there is an active teleop session,
+      read session NDJSON and filter events for the sensor.
+    """
+    async def _run():
+        client = Client()
+        await client.login()
+        # Preferred: backend mode
+        try:
+            r = await client._client.get(f"/sensors/{sensor_uuid}/events", headers=client._get_headers())
+            r.raise_for_status()
+            events = r.json()
+            for ev in events[-limit:]:
+                print(ev)
+            await client.aclose(); return
+        except httpx.HTTPStatusError:
+            pass
+
+        # Fallback: node+session mode requires environment to locate latest session
+        if not environment:
+            print("[yellow]Backend events endpoint unavailable. Provide --environment to fallback to session log tailing.[/yellow]")
+            await client.aclose(); return
+        sensors = await client._client.get(f"/environments/{environment}/sensors", headers=client._get_headers())
+        sensors.raise_for_status()
+        twin_uuid = None
+        for s in sensors.json():
+            if s.get("uuid") == sensor_uuid:
+                twin_uuid = s.get("twin_uuid")
+                break
+        if not twin_uuid:
+            print(f"[red]Sensor {sensor_uuid} not found in environment {environment}[/red]")
+            await client.aclose(); return
+        evs = await client._client.get(f"/environments/{environment}/events", headers=client._get_headers())
+        evs.raise_for_status()
+        session_id = None
+        for row in evs.json():
+            if row.get("twin_uuid") == twin_uuid:
+                session_id = row.get("session", {}).get("session_id")
+                break
+        if not session_id:
+            print(f"[yellow]No sessions found for twin {twin_uuid}[/yellow]")
+            await client.aclose(); return
+        r = await client._client.get(f"/twins/{twin_uuid}/teleop/sessions/{session_id}/events", headers=client._get_headers())
+        r.raise_for_status()
+        count = 0
+        for line in r.text.splitlines():
+            try:
+                obj = json.loads(line)
+            except Exception:
+                continue
+            if obj.get("type") == "event" and obj.get("payload", {}).get("sensor_uuid") == sensor_uuid:
+                analyzer = obj.get("payload", {}).get("analyzer")
+                ts = obj.get("ts_unix")
+                print(f"{ts} analyzer={analyzer} event={obj.get('payload')}")
+                count += 1
+                if count >= limit:
+                    break
+        await client.aclose()
+    asyncio.run(_run())
+
+@app.command("create")
+def create_sensor(
+    environment: str = typer.Option(..., "--environment", "-e"),
+    name: str = typer.Option(..., "--name", "-n"),
+    sensor_type: str = typer.Option("camera", "--type", "-t"),
+    twin: str = typer.Option(None, "--twin"),
+):
+    async def _run():
+        client = Client()
+        await client.login()
+        payload = {"name": name, "sensor_type": sensor_type, "twin_uuid": twin}
+        resp = await client._client.post(f"/environments/{environment}/sensors", json=payload, headers=client._get_headers())
+        resp.raise_for_status()
+        s = resp.json()
+        print(f"[green]✓[/green] Created sensor [bold]{s.get('name')}[/bold] (UUID {s.get('uuid')})")
+        await client.aclose()
+    asyncio.run(_run())
+
+
+@app.command("update")
+def update_sensor(
+    environment: str = typer.Option(..., "--environment", "-e"),
+    sensor_uuid: str = typer.Option(..., "--sensor", "-s"),
+    name: str = typer.Option(None, "--name"),
+    sensor_type: str = typer.Option(None, "--type"),
+    twin: str = typer.Option(None, "--twin"),
+):
+    async def _run():
+        client = Client()
+        await client.login()
+        payload = {}
+        if name is not None: payload["name"] = name
+        if sensor_type is not None: payload["sensor_type"] = sensor_type
+        if twin is not None: payload["twin_uuid"] = twin
+        resp = await client._client.put(f"/environments/{environment}/sensors/{sensor_uuid}", json=payload, headers=client._get_headers())
+        resp.raise_for_status()
+        s = resp.json()
+        print(f"[green]✓[/green] Updated sensor [bold]{s.get('name')}[/bold] (UUID {s.get('uuid')})")
+        await client.aclose()
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    app()
+
+

cyberwave_cli/plugins/sim/app.py

@@ -0,0 +1,17 @@
+import typer
+from rich import print
+
+app = typer.Typer(help="Control local simulations (Isaac Sim, Unity).")
+
+@app.command()
+def launch(simulator: str = typer.Option("isaac", help="Simulator type ('isaac' or 'unity')")):
+    """Launch a local simulation environment."""
+    print(f":rocket: Launching local [yellow]{simulator}[/yellow] simulation... (not implemented)")
+
+@app.command()
+def status():
+    """Check the status of running local simulations."""
+    print(":magnifying_glass_right: Checking simulation status... (not implemented)")
+
+if __name__ == "__main__":
+    app() 

cyberwave_cli/plugins/telemetry/__init__.py

@@ -0,0 +1 @@
+# Init for telemetry plugin 

cyberwave_cli/plugins/telemetry/app.py

@@ -0,0 +1,17 @@
+import typer
+from rich import print
+
+app = typer.Typer(help="Access robot telemetry data (logs, live streams).")
+
+@app.command()
+def logs(robot_id: str = typer.Argument(..., help="ID of the robot")):
+    """Fetch logs for a specific robot."""
+    print(f":scroll: Fetching logs for robot [bold blue]{robot_id}[/bold blue]... (not implemented)")
+
+@app.command()
+def stream(robot_id: str = typer.Argument(..., help="ID of the robot")):
+    """Stream live telemetry data for a specific robot."""
+    print(f":satellite_antenna: Streaming live data for robot [bold blue]{robot_id}[/bold blue]... (not implemented)")
+
+if __name__ == "__main__":
+    app() 

cyberwave_cli/plugins/twins/app.py

@@ -0,0 +1,66 @@
+import asyncio
+import json
+from typing import Optional
+
+import typer
+from rich import print
+
+from cyberwave import Client
+
+app = typer.Typer(help="Twin commands and control (teleop)")
+
+
+@app.command("command")
+def send_command(
+    twin: str = typer.Option(..., "--twin", "-t", help="Twin UUID"),
+    name: str = typer.Option(..., "--name", "-n", help="Command name, e.g., arm.move_joints"),
+    joints: Optional[str] = typer.Option(None, "--joints", help="JSON list of joint positions for arm.move_joints"),
+    pose: Optional[str] = typer.Option(None, "--pose", help='JSON dict pose for arm.move_pose/move_to (e.g., {"x":0.1, "y":0.2, "z":0.0})'),
+    mode: str = typer.Option("both", "--mode", help="sim|real|both"),
+    source: Optional[str] = typer.Option("cli", "--source", help="Source tag, e.g., cli/web-ui/edge-leader"),
+) -> None:
+    """Send a unified command to a twin via the backend TeleopControllerService."""
+
+    async def _run():
+        client = Client()
+        await client.login()
+
+        payload: dict = {"name": name, "payload": {}, "mode": mode, "source": source}
+        if name.endswith("move_joints") and joints:
+            payload["payload"] = {"joints": json.loads(joints)}
+        elif name.endswith("move_pose") or name.endswith("move_to") or name.endswith("fly_to"):
+            if pose:
+                payload["payload"] = {"pose": json.loads(pose)}
+        # Fallback: if user gave raw payload via pose or joints json that doesn't match name, just pass through
+
+        # Use SDK internals to POST
+        headers = client._get_headers()  # type: ignore[attr-defined]
+        resp = await client._client.post(f"/twins/{twin}/commands", json=payload, headers=headers)  # type: ignore[attr-defined]
+        if resp.status_code >= 400:
+            print(f"[red]Command failed: {resp.status_code} {resp.text}[/red]")
+        else:
+            print(f"[green]✓ Command sent: {name}[/green]")
+        await client.aclose()
+
+    asyncio.run(_run())
+
+
+@app.command("apply-defaults")
+def apply_defaults(twin: str = typer.Option(..., "--twin", "-t", help="Twin UUID")) -> None:
+    """Apply asset catalog state defaults (pose, joints, logical) to the twin."""
+    async def _run():
+        client = Client()
+        await client.login()
+        headers = client._get_headers()
+        resp = await client._client.post(f"/twins/{twin}/apply-defaults", headers=headers)
+        if resp.status_code >= 400:
+            print(f"[red]Failed to apply defaults: {resp.status_code} {resp.text}[/red]")
+        else:
+            print(f"[green]✓ Defaults applied[/green] {resp.json()}")
+        await client.aclose()
+    asyncio.run(_run())
+
+if __name__ == "__main__":
+    app()
+
+

cyberwave_cli-0.11.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: cyberwave-cli
+Version: 0.11.0
+Summary: Cyberwave command-line interface (plugins, asset pipeline, telemetry)
+Requires-Dist: typer[all]>=0.12
+Requires-Dist: rich>=13
+Requires-Dist: importlib_metadata>=6.0; python_version < "3.10"
+Requires-Dist: setuptools>=61.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: tomli>=2.0.0; python_version < "3.11"
+Requires-Dist: tomli-w>=1.0.0
+Provides-Extra: sdk
+Requires-Dist: cyberwave<0.12,>=0.11; extra == "sdk"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"

cyberwave_cli-0.11.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+cyberwave_cli/__init__.py,sha256=FGDbBQ9Fmw1exvYKdJWlFmWxvAIZAMb-6QxrYiTkMIg,33
+cyberwave_cli/core.py,sha256=aFL63zvGDO7Kd8Z0WwRM2FunKdnznY6542RXueGZcn0,897
+cyberwave_cli/plugins/__init__.py,sha256=Mi4fla-L0jlXM7F62-yEwxJe03ROcv1zuLNDLAyT-g0,41
+cyberwave_cli/plugins/loader.py,sha256=jm_U_-XUHZqmhddJ8vtr6YqLYZH_zsYQMQhgZe2YXvo,1673
+cyberwave_cli/plugins/assets/__init__.py,sha256=T9QRK4DS85JAeu4uq5sK51aWUGqTVyx-AmNwWnJ7E-A,25
+cyberwave_cli/plugins/assets/app.py,sha256=HU3qMJyP2NbRcfYXPIQxYEeKft2DofK-p5ysdptR7Io,3335
+cyberwave_cli/plugins/auth/__init__.py,sha256=_V4d0s0oIMfJJWLxmxiUPdWBYqyLykcaCiAIbknZH7c,43
+cyberwave_cli/plugins/auth/app.py,sha256=8fPp1AvV4TDMW6h6VryqECXy3ljO0BkqlNs98HIgm8k,12370
+cyberwave_cli/plugins/devices/__init__.py,sha256=j_LQ2cQzv34mZoKGT7efEI2TvDiH7F0qMBSuzhhaUmM,31
+cyberwave_cli/plugins/devices/app.py,sha256=NtNCsexEmBoPeVxDNEXUi3gdLcQINdSJF4mCo88ZlVQ,1448
+cyberwave_cli/plugins/edge/app.py,sha256=AIH8nd0XRUd2Gyd3ZRR-bWQJg_qo8IVbaHKzQOhYR2A,6209
+cyberwave_cli/plugins/environments/app.py,sha256=mALlzR2LzjgFy1eF_mQ7J92kce5osK6nvPw2-3D_OZ0,2609
+cyberwave_cli/plugins/projects/__init__.py,sha256=4cVt2vOy-JQ_-gF2CQF__oLZliHUBkPHBihoxt9LezE,27
+cyberwave_cli/plugins/projects/app.py,sha256=zl2Ko9TOFSCIo5EmlXz4Ahj9lTpMk58AMZzN53jVthA,1499
+cyberwave_cli/plugins/sensors/app.py,sha256=_zY_NghwcKfnaUIgdWPOX-fQUYhRZE8FcVSuS8g0MMI,5517
+cyberwave_cli/plugins/sim/app.py,sha256=KNjkR4YU3QkLAtPPDNpIh7mRHNxlVwiFwJG8DuvURiY,581
+cyberwave_cli/plugins/telemetry/__init__.py,sha256=rz87C8_j2gF5JGW8dJjO1WR9PedXYj5yMNDOPQTX6Mc,28
+cyberwave_cli/plugins/telemetry/app.py,sha256=Ae6UAA6JcT9E9wqEYDaTmb1Cme-tdTVmzZUS0o4Ylf4,650
+cyberwave_cli/plugins/twins/app.py,sha256=DG1QUo2mgwTRJ9aG-3oDdo6tDcil4rvIuFYSgMwVKdA,2704
+cyberwave_cli-0.11.0.dist-info/METADATA,sha256=9sdak6CDqkgi92Fb7WmOdQYBMa-KcmE44FIBpqu-aZk,626
+cyberwave_cli-0.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cyberwave_cli-0.11.0.dist-info/entry_points.txt,sha256=KTGLdbgB3E8Dsn1vOkqjgA6GdisabfFhPZ6_VhDcoTo,411
+cyberwave_cli-0.11.0.dist-info/top_level.txt,sha256=2L8SNq9MKHTbggUoUZZ8wqbdr8DuEOzrcecOcBjzaqc,14
+cyberwave_cli-0.11.0.dist-info/RECORD,,

cyberwave_cli-0.11.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cyberwave_cli-0.11.0.dist-info/entry_points.txt

@@ -0,0 +1,11 @@
+[console_scripts]
+cyberwave = cyberwave_cli.core:main
+
+[cyberwave.cli.plugins]
+auth = cyberwave_cli.plugins.auth.app:app
+devices = cyberwave_cli.plugins.devices.app:app
+edge = cyberwave_cli.plugins.edge.app:app
+environments = cyberwave_cli.plugins.environments.app:app
+projects = cyberwave_cli.plugins.projects.app:app
+sensors = cyberwave_cli.plugins.sensors.app:app
+twins = cyberwave_cli.plugins.twins.app:app

cyberwave_cli-0.11.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cyberwave_cli