cyberwave-cli 0.11.0__tar.gz

cyberwave_cli-0.11.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,190 @@
+# Cyberwave CLI
+
+Command-line interface for the Cyberwave Digital Twin Platform. Manage projects, environments, digital twins, and robot integrations from the terminal.
+
+## Installation
+
+### Stable Release (Recommended)
+```bash
+pip install cyberwave-cli
+```
+
+### With Full SDK Support
+```bash
+pip install cyberwave-cli cyberwave cyberwave-robotics-integrations
+```
+
+### Development Installation
+```bash
+pipx install cyberwave-cli  # Isolated installation
+```
+
+## Quick Start
+
+### 1. Authentication
+```bash
+# Login to your Cyberwave instance
+cyberwave auth login --backend-url http://localhost:8000 --frontend-url http://localhost:3000
+
+# Check authentication status
+cyberwave auth status
+
+# Logout
+cyberwave auth logout
+```
+
+### 2. Project Management
+```bash
+# List projects
+cyberwave projects list
+
+# Create new project
+cyberwave projects create "My Robot Project" --description "Autonomous robot fleet"
+
+# Get project details
+cyberwave projects show <project-uuid>
+```
+
+### 3. Environment Management
+```bash
+# List environments
+cyberwave environments list
+
+# Create environment
+cyberwave environments create "Test Environment" --project <project-uuid>
+
+# Environment details
+cyberwave environments show <environment-uuid>
+```
+
+### 4. Digital Twin Operations
+```bash
+# List twins in environment
+cyberwave twins list --environment <environment-uuid>
+
+# Add twin from catalog
+cyberwave twins add cyberwave/so101 --environment <environment-uuid>
+
+# Control twin position
+cyberwave twins move <twin-uuid> --x 1.0 --y 0.0 --z 0.5
+
+# Control robot joints
+cyberwave twins joint <twin-uuid> --joint shoulder --angle 45
+```
+
+### 5. Device Management
+```bash
+# Register device
+cyberwave devices register --name "My Robot" --type so100
+
+# List devices
+cyberwave devices list
+
+# Device status
+cyberwave devices status <device-id>
+```
+
+### Plugins
+
+Plugins are discovered via the `cyberwave.cli.plugins` entry point and loaded automatically.
+
+- Built-in: `auth`, `projects`, `devices`, `edge`, `twins`
+- List loaded plugins:
+  ```bash
+  cyberwave plugins-cmd
+  ```
+
+### Devices
+
+```bash
+# Register a device and issue a device token
+cyberwave devices register --project <PROJECT_ID> --name my-edge --type robot/so-arm100
+cyberwave devices issue-offline-token --device <DEVICE_ID>
+```
+
+### Edge Node (SO-ARM100 example and simulation)
+
+Configure and run a CyberWave Edge node that bridges a local driver to the cloud via the SDK.
+
+- Initialize config (auto-register and create a device token):
+  ```bash
+  cyberwave edge init \
+    --robot so_arm100 \
+    --port /dev/ttyUSB0 \
+    --backend http://localhost:8000/api/v1 \
+    --project <PROJECT_ID> \
+    --device-name edge-soarm100 \
+    --device-type robot/so-arm100 \
+    --auto-register \
+    --use-device-token \
+    --config ~/.cyberwave/edge.json
+  ```
+- Run:
+  ```bash
+  cyberwave edge run --config ~/.cyberwave/edge.json
+  ```
+- Status:
+  ```bash
+  cyberwave edge status --config ~/.cyberwave/edge.json
+  ```
+- Simulate a virtual camera from a local mp4 (no hardware needed):
+  ```bash
+  cyberwave edge simulate --sensor <SENSOR_UUID> --video ./sample.mp4 --fps 2
+  ```
+- Command mode (optional): set in `~/.cyberwave/edge.json` to route via backend controller
+  ```json
+  {
+    "control_mode": "command",
+    "twin_uuid": "<TWIN_UUID>"
+  }
+  ```
+
+### Twin Control (Unified Command)
+
+Send a command to a twin through the backend TeleopController.
+
+```bash
+# Move joints (degrees/radians based on driver semantics)
+cyberwave twins command \
+  --twin <TWIN_UUID> \
+  --name arm.move_joints \
+  --joints "[0,10,0,0,0,0]" \
+  --mode both \
+  --source cli
+
+# Move to pose
+cyberwave twins command \
+  --twin <TWIN_UUID> \
+  --name arm.move_pose \
+  --pose '{"x":0.1, "y":0.2, "z":0.0}' \
+  --mode sim
+```
+
+### Configuration
+
+- CLI config: `~/.cyberwave/config.toml` (managed by `cyberwave auth config`)
+- Edge config: `~/.cyberwave/edge.json` (managed by `cyberwave edge init`)
+
+### Security
+
+- Tokens are stored in system keychain when available, with JSON fallback.
+- Device tokens are long-lived; prefer them for headless Edge deployments.
+
+### Environments and Sensors (new)
+
+List environments for a project and show recent events (latest session per twin):
+```bash
+cyberwave environments list --project <PROJECT_UUID>
+cyberwave environments events --environment <ENVIRONMENT_UUID> -n 5
+```
+
+Create/list sensors in an environment:
+```bash
+cyberwave sensors create --environment <ENVIRONMENT_UUID> --name "Living Room Cam" --type camera
+cyberwave sensors list --environment <ENVIRONMENT_UUID>
+```
+
+List analyzer events for a specific sensor from the latest session:
+```bash
+cyberwave sensors events --environment <ENVIRONMENT_UUID> --sensor <SENSOR_UUID> -n 20
+```

cyberwave_cli-0.11.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name        = "cyberwave-cli"
+version     = "0.11.0"
+description = "Cyberwave command-line interface (plugins, asset pipeline, telemetry)"
+dependencies = [
+    "typer[all]>=0.12",
+    "rich>=13",
+    "importlib_metadata>=6.0; python_version < '3.10'",
+    "setuptools>=61.0",
+    "httpx>=0.24.0",
+    "tomli>=2.0.0; python_version < '3.11'",
+    "tomli-w>=1.0.0",
+]
+
+[project.optional-dependencies]
+sdk  = ["cyberwave>=0.11,<0.12"]
+test = ["pytest>=7.0", "pytest-cov", "pytest-mock"]
+
+[project.scripts]
+cyberwave = "cyberwave_cli.core:main"
+
+[project.entry-points]
+[project.entry-points."cyberwave.cli.plugins"]
+auth = "cyberwave_cli.plugins.auth.app:app"
+devices = "cyberwave_cli.plugins.devices.app:app"
+projects = "cyberwave_cli.plugins.projects.app:app"
+edge = "cyberwave_cli.plugins.edge.app:app"
+twins = "cyberwave_cli.plugins.twins.app:app"
+environments = "cyberwave_cli.plugins.environments.app:app"
+sensors = "cyberwave_cli.plugins.sensors.app:app"
+
+[tool.setuptools.packages.find]
+where = ["src"]

cyberwave_cli-0.11.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cyberwave_cli-0.11.0/src/cyberwave_cli/__init__.py

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

cyberwave_cli-0.11.0/src/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-0.11.0/src/cyberwave_cli/plugins/__init__.py

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

cyberwave_cli-0.11.0/src/cyberwave_cli/plugins/assets/__init__.py

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

cyberwave_cli-0.11.0/src/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-0.11.0/src/cyberwave_cli/plugins/auth/__init__.py

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