@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.4 → 0.1.2-dev.6

package/cli/templates/common/README.md

@@ -1,16 +1,261 @@
 # __PLUGIN_NAME__
 
-A Muscat plugin scaffolded with `muscat-pk`.
+A Muscat plugin project. Build, develop, and ship with `muscat-pk` CLI.
+
+## Quick start
+
+```bash
+muscat-pk dev        # UI preview + backend together
+muscat-pk dev:ui     # UI preview only
+muscat-pk dev:back   # backend only (Python watchfiles / ROS2 Docker)
+muscat-pk pack       # build a distributable ZIP
+```
+
+---
+
+## Project structure
+
+```
+__PLUGIN_DIR__/
+├─ src/
+│   └─ content.tsx      # plugin UI entry point
+├─ assets/
+│   └─ icon.svg         # icon referenced from manifest
+├─ manifest.json        # metadata, contribution points, runtime config
+├─ main.py              # backend (Python or ROS2)
+└─ requirements.txt     # Python deps (auto-pinned to latest on pack)
+```
+
+> ROS2 plugins additionally include a `ros2_ws/` directory.
+
+---
+
+## Frontend (`src/content.tsx`)
+
+### useRb() hook
+
+Access the communication API between the plugin module and UI from any plugin component.
+
+```tsx
+import { useRb } from "@rainbow-robotics/plugin-ui/sdk";
+
+function App() {
+  const rb = useRb();
+}
+```
+
+### rb API
+
+| Method | Description |
+|---|---|
+| `rb.pub(topic, payload)` | Publish a message to a topic |
+| `rb.sub(topic, handler)` | Subscribe to a topic — returns `{ undeclare() }` |
+| `rb.action(topic, payload?)` | Send a request and await a reply |
+| `rb.serve(topic, handler)` | Handle incoming requests from the backend |
+| `rb.toast(message, type?)` | Host toast notification (`"info" · "success" · "warning" · "error"`) |
+
+All methods support Generic Types:
+
+```tsx
+const status = await rb.action<{ ok: boolean }, { id: number }>(
+  "get-status",
+  { id: 1 },
+);
+
+const sub = await rb.sub<{ value: number }>("sensor/data", (data) => {
+  console.log(data.value);
+});
+sub.undeclare(); // cleanup
+```
+
+### Topic namespace
+
+Topics are automatically namespaced by plugin ID to prevent collisions across plugins.
+
+```
+"sensor/data"   →  plugin/{pluginId}/sensor/data   (auto-namespaced)
+"/broadcast/x"  →  broadcast/x                    (leading / = absolute)
+```
+
+### UI components
+
+Import Muscat components from `@rainbow-robotics/plugin-ui/react`. The plugin emits
+`rb-*` tags; the host renders the actual components.
+
+```tsx
+import { connect } from "@rainbow-robotics/plugin-ui/connect";
+import { Button, Slider, Text, Switch } from "@rainbow-robotics/plugin-ui/react";
+import { useRb } from "@rainbow-robotics/plugin-ui/sdk";
+
+function App() {
+  const rb = useRb();
+  return <Button label="Run" onPress={() => rb.action("run")} />;
+}
+
+connect(App);
+```
+
+---
+
+## Backend (`main.py`)
+
+The backend communicates with the frontend using `rainbow_rb_zenoh`.
+Set the `prefix` to `plugin/{manifest.id}` to match the frontend's auto-namespace.
+
+### Python plugin
+
+```python
+import asyncio
+from rainbow_rb_zenoh import ZenohRouter, ZenohClient
+
+router = ZenohRouter(prefix="plugin/__PLUGIN_ID__")
+client = ZenohClient()
+
+
+@router.subscribe("sensor/data")
+async def on_sensor(*, dict_payload, **_):
+    print("received:", dict_payload)
+
+
+@router.queryable("get-status")
+async def get_status(req=None, **_):
+    return {"ok": True}
+
+
+async def main():
+    await router.startup()
+    await asyncio.Event().wait()  # keep alive
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### ROS2 plugin
+
+The node is launched with `--ros-args -r __ns:=/{slug}` automatically by `dev:back`.
+ROS2 topics are bridged to the plugin communication layer — no extra code needed.
+
+```python
+# ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/node.py
+import rclpy
+from rclpy.node import Node
+from std_msgs.msg import Float32
+
+class __PLUGIN_CLASS__Node(Node):
+    def __init__(self):
+        super().__init__("__PLUGIN_SLUG___node")
+        # relative topic name — __ns prefix applied automatically
+        self.pub = self.create_publisher(Float32, "sensor_data", 10)
+        self.create_timer(1.0, self.timer_cb)
+
+    def timer_cb(self):
+        self.pub.publish(Float32(data=42.0))
+```
+
+---
+
+## manifest.json
+
+```jsonc
+{
+  "id": "com.example.my-plugin",   // unique plugin ID (reverse-domain recommended)
+  "name": "My Plugin",
+  "version": "1.0.0",
+  "minAppVersion": "2.0.0",
+  "icon": "assets/icon.svg",
+
+  "contributes": [
+    { "point": "program.panel", "label": "My Plugin", "icon": "assets/icon.svg" },
+    { "point": "lnb",           "label": "My Plugin", "icon": "assets/icon.svg" },
+    { "point": "header.toolbar","label": "My Plugin", "icon": "assets/icon.svg", "opens": "popover" }
+  ],
+
+  // "python" | "ros2"
+  "runtime": { "type": "python", "entry": "main.py" }
+}
+```
+
+**Contribution points:**
+
+| point | Where it appears |
+|---|---|
+| `program.panel` | Program panel tab |
+| `lnb` | Left navigation bar |
+| `header.toolbar` | Header toolbar button |
+
+---
+
+## Installing Python dependencies
+
+Add any package with an optional version pin to `requirements.txt`:
+
+```
+rainbow-rb-sdk
+rainbow-rb-flat-buffers
+numpy==1.26.4
+opencv-python
+```
+
+Then just run `muscat-pk dev` or `muscat-pk dev:back` — dependencies are installed automatically on every startup:
+
+- **Python plugin**: installed into `.venv` via `pip install -r requirements.txt`
+- **ROS2 plugin**: installed inside the Docker container via `pip install -r requirements.txt`
+
+No extra steps needed.
+
+> `muscat-pk build` / `muscat-pk pack` only **pins** versions in `requirements.txt` — it does not run `pip install`.
+
+---
+
+## Switching backend type
+
+```bash
+muscat-pk type change             # interactive
+muscat-pk type change --to ros2   # python → ros2
+muscat-pk type change --to python # ros2 → python
+```
+
+> `ros2_ws/` is not deleted when switching back to python. Remove it manually if no longer needed.
+
+---
+
+## Shipping
 
 ```bash
-__PM__ run dev        # preview in a mini-Muscat (preview-host) + back end
-__PM__ run dev:ui     # UI preview only
-__PM__ run pack       # build a distributable ZIP
+muscat-pk pack
 ```
 
-- `src/content.tsx` — your plugin UI. Import components from `@rainbow-robotics/plugin-ui/react`.
-- `manifest.json` — id, contributions, actions, runtime.
-- `assets/` — static assets (icons referenced from the manifest).
-- `main.py` — (sdk runtime) back-end handler using `rainbow-rb-sdk`.
+- Builds `src/content.tsx` → `dist/content.js`
+- Pins `requirements.txt` to latest versions (stable-only on `main` branch)
+- ROS2: runs `colcon build` inside the Jazzy container; includes `ros2_ws/install/`
+- Output: `__PLUGIN_DIR__-{version}.zip`
 
-The plugin only emits `rb-*` name tags; Muscat renders the real components.
+ZIP layout:
+
+```
+__PLUGIN_DIR__-1.0.0.zip
+├─ dist/             # built UI
+├─ main.py
+├─ requirements.txt  # pinned
+└─ ros2_ws/install/  # ROS2 only
+```
+
+---
+
+## All commands
+
+```bash
+muscat-pk dev        # UI + backend
+muscat-pk dev:ui     # UI preview only (preview-host)
+muscat-pk dev:back   # backend only (Python: watchfiles / ROS2: Docker)
+muscat-pk build      # UI build only → dist/
+muscat-pk pack       # build + ZIP
+```
+
+```bash
+muscat-pk type change    # switch backend type
+muscat-pk sdk list       # show current Python SDK version
+muscat-pk sdk update     # update Python SDK to latest
+muscat-pk update         # update muscat-plugin-kit itself
+```

package/cli/templates/common/main.py

@@ -0,0 +1,24 @@
+import asyncio
+
+from rainbow_rb_zenoh import ZenohRouter
+
+router = ZenohRouter(prefix="plugin/__PLUGIN_ID__")
+
+
+@router.subscribe("sensor/data")
+async def on_sensor(*, dict_payload, **_):
+    print(f"[__PLUGIN_NAME__] received: {dict_payload}")
+
+
+@router.queryable("get-status")
+async def get_status(req=None, **_):
+    return {"ok": True}
+
+
+async def main():
+    await router.startup()
+    await asyncio.Event().wait()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/cli/templates/common/package.json

@@ -3,13 +3,6 @@
   "version": "1.0.0",
   "private": true,
   "type": "module",
-  "scripts": {
-    "dev": "muscat-pk dev",
-    "dev:ui": "muscat-pk dev:ui",
-    "dev:back": "muscat-pk dev:back",
-    "build": "muscat-pk build",
-    "pack": "muscat-pk pack"
-  },
   "dependencies": {
     "@rainbow-robotics/plugin-ui": "^0.1.0"
   },

package/cli/templates/common/requirements.txt

@@ -0,0 +1,2 @@
+rainbow-rb-sdk
+rainbow-rb-flat-buffers

package/cli/templates/common/src/content.tsx

@@ -1,6 +1,7 @@
 import { useState } from "react";
 import { connect } from "@rainbow-robotics/plugin-ui/connect";
-import { Slider, Button, Text, Switch, useRb } from "@rainbow-robotics/plugin-ui/react";
+import { Slider, Button, Text, Switch } from "@rainbow-robotics/plugin-ui/react";
+import { useRb } from "@rainbow-robotics/plugin-ui/sdk";
 
 function App() {
   const rb = useRb();
@@ -22,7 +23,7 @@ function App() {
         onChange={(event: { detail?: boolean }) => {
           const next = event.detail ?? false;
           setOpen(next);
-          rb.notify(next ? "opened" : "closed", "info");
+          rb.toast(next ? "opened" : "closed", "info");
         }}
       />
     </>

package/cli/templates/ros2/ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/node.py

@@ -0,0 +1,25 @@
+import rclpy
+from rclpy.node import Node
+from rb_sdk import RBManipulateSDK  # PyPI: rainbow-rb-sdk (installed from requirements.txt)
+
+
+sdk = RBManipulateSDK()
+
+
+class __PLUGIN_CLASS__Node(Node):
+    def __init__(self):
+        super().__init__("__PLUGIN_SLUG___node")
+        self.get_logger().info("__PLUGIN_NAME__ node started")
+        # sdk is available here — use it alongside ROS2 topics as needed
+
+
+def main(args=None):
+    rclpy.init(args=args)
+    node = __PLUGIN_CLASS__Node()
+    rclpy.spin(node)
+    node.destroy_node()
+    rclpy.shutdown()
+
+
+if __name__ == "__main__":
+    main()

package/cli/templates/ros2/ros2_ws/src/__PLUGIN_SLUG__/package.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<package format="3">
+  <name>__PLUGIN_SLUG__</name>
+  <version>0.0.1</version>
+  <description>__PLUGIN_NAME__ ROS2 node</description>
+  <maintainer email="todo@example.com">maintainer</maintainer>
+  <license>Proprietary</license>
+  <depend>rclpy</depend>
+  <export><build_type>ament_python</build_type></export>
+</package>

package/cli/templates/ros2/ros2_ws/src/__PLUGIN_SLUG__/setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup
+
+package_name = "__PLUGIN_SLUG__"
+
+setup(
+    name=package_name,
+    version="0.0.1",
+    packages=[package_name],
+    data_files=[
+        ("share/ament_index/resource_index/packages", ["resource/" + package_name]),
+        ("share/" + package_name, ["package.xml"]),
+    ],
+    install_requires=["setuptools"],
+    zip_safe=True,
+    entry_points={
+        "console_scripts": ["__PLUGIN_SLUG___node = __PLUGIN_SLUG__.node:main"],
+    },
+)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rainbow-robotics/muscat-plugin-kit",
-  "version": "0.1.2-dev.4",
+  "version": "0.1.2-dev.6",
   "type": "module",
   "engines": {
     "node": ">=20"

package/cli/templates/sdk/main.py

@@ -1,21 +0,0 @@
-import asyncio
-
-from rb_sdk import RBManipulateSDK  # PyPI: rainbow-rb-sdk
-
-sdk = RBManipulateSDK()
-
-
-async def on_action(payload: dict):
-    # Matches manifest.actions[].topic — handle the "grip" action here.
-    width = payload.get("width")
-    print(f"[__PLUGIN_NAME__] grip width={width}")
-    # TODO: drive the robot via the SDK.
-
-
-async def main():
-    await sdk.subscribe("rby2/plugin/__PLUGIN_ID__/grip", on_action)
-    await sdk.spin()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

package/cli/templates/sdk/requirements.txt

@@ -1 +0,0 @@
-rainbow-rb-sdk==__SDK_VERSION__