@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.50 → 0.1.2-dev.52

package/cli/src/bridge.mjs

@@ -63,7 +63,7 @@ function ensureImage() {
  * Build the image, preflight the port, and start the bridge container.
  * Returns true if bridge started, false if port was already in use (caller decides).
  */
-export async function startBridge() {
+export async function startBridge({ zenohPort = null } = {}) {
   assertDockerReady();
 
   // remove our own stale container first, then check the host port is free
@@ -73,15 +73,20 @@ export async function startBridge() {
   ensureImage();
 
   log.step("starting Socket.IO bridge container…");
+  const portFlags = [
+    "-p", `127.0.0.1:${BRIDGE_PORT}:${BRIDGE_PORT}`,
+    ...(zenohPort ? ["-p", `${zenohPort}:${zenohPort}`] : []),
+  ];
   const up = spawnSync(
     "docker",
-    ["run", "-d", "--name", BRIDGE_CONTAINER, "-p", `127.0.0.1:${BRIDGE_PORT}:${BRIDGE_PORT}`, BRIDGE_IMAGE],
+    ["run", "-d", "--name", BRIDGE_CONTAINER, ...portFlags, BRIDGE_IMAGE],
     { stdio: "inherit" },
   );
   if (up.status !== 0) throw new Error("failed to start bridge container.");
 
   await waitForPort(BRIDGE_PORT);
   log.step(`Socket.IO bridge listening on ws://127.0.0.1:${BRIDGE_PORT}`);
+  if (zenohPort) log.step(`Zenoh dev peer port published on :${zenohPort}`);
   return true;
 }
 

package/cli/src/dev.mjs

@@ -1,10 +1,105 @@
 // muscat-pk dev — run the Socket.IO bridge (Docker), dev:ui, and dev:back together.
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { release } from "node:os";
+import { resolve } from "node:path";
 import { runDevUi } from "./devUi.mjs";
 import { runDevBack, stopDevBackContainers } from "./devBack.mjs";
 import { startBridge, stopBridge, BRIDGE_CONTAINER, BRIDGE_PORT } from "./bridge.mjs";
 import { assertManifestPorts } from "./manifest.mjs";
 import { formatPortRanges } from "./ports.mjs";
-import { ensureDocker, findPluginRoot, log, prompt, promptRobotConnection } from "./util.mjs";
+import {
+  ensureDocker,
+  ensureIdeVenv,
+  findPluginRoot,
+  log,
+  prompt,
+  promptRobotConnection,
+  venvPython,
+} from "./util.mjs";
+import { detectRouteAddress, ensureRemoteZenohEnv, getFreePort, isRemoteRobot } from "./zenohDev.mjs";
+
+const DEFAULT_HOST_AGENT_PORT = 18080;
+const isWsl = () => process.platform === "linux" && /microsoft|wsl/i.test(release());
+const canAutoStartHostAgent = () => process.platform === "darwin" || isWsl();
+
+function waitForHostAgent(port, { timeoutMs = 30_000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  const url = `http://127.0.0.1:${port}/health`;
+  return new Promise((resolve, reject) => {
+    const probe = async () => {
+      try {
+        const res = await fetch(url);
+        if (res.ok) return resolve(true);
+      } catch {
+        // keep polling
+      }
+      if (Date.now() >= deadline) {
+        reject(new Error(`host SDK agent did not become ready at ${url}`));
+        return;
+      }
+      setTimeout(probe, 300);
+    };
+    probe();
+  });
+}
+
+async function maybeStartHostAgent(root, { robotIp, robotToken }) {
+  if (process.env.MUSCAT_HOST_AGENT_URL) {
+    log.step(`host SDK agent → ${process.env.MUSCAT_HOST_AGENT_URL}`);
+    return null;
+  }
+  if (process.env.MUSCAT_HOST_AGENT_DISABLE === "1") return null;
+  if (!canAutoStartHostAgent() || !isRemoteRobot(robotIp)) return null;
+
+  const agentPath = resolve(root, "py", "host_agent.py");
+  if (!existsSync(agentPath)) return null;
+
+  const wsl = isWsl();
+  if (wsl) await ensureRemoteZenohEnv(robotIp, { log });
+
+  const bindHost = wsl ? "0.0.0.0" : "127.0.0.1";
+  const containerHost = wsl
+    ? process.env.MUSCAT_HOST_AGENT_CONTAINER_HOST || await detectRouteAddress(robotIp)
+    : "host.docker.internal";
+
+  if (!containerHost) {
+    log.warn("host SDK agent skipped: could not determine container-reachable host");
+    return null;
+  }
+
+  log.step("starting host SDK agent (Docker Desktop workaround)...");
+  if (!ensureIdeVenv(root)) {
+    log.warn("host SDK agent skipped: could not prepare .venv");
+    return null;
+  }
+
+  const port = await getFreePort(Number(process.env.MUSCAT_HOST_AGENT_PORT || DEFAULT_HOST_AGENT_PORT));
+  const py = venvPython(resolve(root, ".venv"));
+  const child = spawn(py, [agentPath], {
+    cwd: root,
+    stdio: ["ignore", "inherit", "inherit"],
+    env: {
+      ...process.env,
+      MUSCAT_ROBOT_HOST: robotIp,
+      MUSCAT_ROBOT_TOKEN: robotToken,
+      MUSCAT_HOST_AGENT_BIND: bindHost,
+      MUSCAT_HOST_AGENT_PORT: String(port),
+    },
+  });
+
+  try {
+    await waitForHostAgent(port);
+  } catch (e) {
+    child.kill();
+    throw e;
+  }
+
+  const containerUrl = `http://${containerHost}:${port}`;
+  process.env.MUSCAT_HOST_AGENT_URL = containerUrl;
+  log.step(`host SDK agent → ${containerUrl}`);
+  return child;
+}
 
 export async function runDev(args = []) {
   const root = findPluginRoot();
@@ -17,8 +112,22 @@ export async function runDev(args = []) {
   const { robotIp, robotToken } = await promptRobotConnection(args);
   process.env.MUSCAT_ROBOT_HOST  = robotIp;
   if (robotToken) process.env.MUSCAT_ROBOT_TOKEN = robotToken;
+
+  const remoteRobot = isRemoteRobot(robotIp);
+  const hostAgent = await maybeStartHostAgent(root, { robotIp, robotToken });
+  const hostAgentUrl = process.env.MUSCAT_HOST_AGENT_URL || "";
+  // Compute the Zenoh advertise host/port up front — startBridge() needs the
+  // port to publish it on the bridge container so the robot can reach back.
+  if (hostAgentUrl && !hostAgent) {
+    log.step(`host SDK agent → ${hostAgentUrl}`);
+  } else if (!hostAgentUrl) {
+    await ensureRemoteZenohEnv(robotIp, { log });
+  }
+
   log.step("starting Socket.IO bridge (Docker) + dev:ui + dev:back");
-  const bridgeStarted = await startBridge();
+  const bridgeStarted = await startBridge({
+    zenohPort: remoteRobot && !hostAgentUrl ? Number(process.env.MUSCAT_ZENOH_PORT) : null,
+  });
 
   if (!bridgeStarted) {
     log.warn(`port ${BRIDGE_PORT} is already in use — can't start Socket.IO bridge.`);
@@ -34,6 +143,7 @@ export async function runDev(args = []) {
   process.env.MUSCAT_PK_MANAGED_DEV = "1";
 
   const cleanup = () => {
+    if (hostAgent && hostAgent.exitCode === null) hostAgent.kill();
     stopDevBackContainers();
     if (bridgeStarted) stopBridge();
   };

package/cli/src/devBack.mjs

@@ -11,6 +11,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { existsSync, watch } from "node:fs";
 import { resolve } from "node:path";
 import { ensureDocker, ensureIdeVenv, findPluginRoot, log, promptRobotConnection } from "./util.mjs";
+import { ensureRemoteZenohEnv } from "./zenohDev.mjs";
 import { assertManifestPorts, manifestRuntime, readManifest, validateManifest } from "./manifest.mjs";
 import {
   formatPortRanges,
@@ -84,10 +85,14 @@ async function runPython(root, portRanges) {
   const container = `${PYTHON_DEV_IMAGE}-run`;
   const robotIp    = process.env.MUSCAT_ROBOT_HOST  ?? "";
   const robotToken = process.env.MUSCAT_ROBOT_TOKEN ?? "";
+  const zenohAdvertiseHost = process.env.MUSCAT_ZENOH_ADVERTISE_HOST ?? "";
+  const zenohPort = process.env.MUSCAT_ZENOH_PORT ?? "";
+  const hostAgentUrl = process.env.MUSCAT_HOST_AGENT_URL ?? "";
   // Share the bridge container's network namespace so localhost:10000 is the
   // bridge (set by `muscat-pk dev`). Standalone dev:back has no bridge to join.
   const bridgeContainer = process.env.MUSCAT_PK_BRIDGE_CONTAINER;
   const netFlags = bridgeContainer ? ["--network", `container:${bridgeContainer}`] : [];
+  const standaloneZenohPortFlags = !bridgeContainer && zenohPort ? ["-p", `${zenohPort}:${zenohPort}`] : [];
   const hostGatewayFlags = bridgeContainer
     ? []
     : ["--add-host", "host.docker.internal:host-gateway"];
@@ -108,6 +113,9 @@ async function runPython(root, portRanges) {
     ...(pluginId    ? ["-e", `RB_PLUGIN_ID=${pluginId}`]             : []),
     ...(robotIp     ? ["-e", `MUSCAT_ROBOT_HOST=${robotIp}`]         : []),
     ...(robotToken  ? ["-e", `MUSCAT_ROBOT_TOKEN=${robotToken}`]     : []),
+    ...(!hostAgentUrl && zenohAdvertiseHost ? ["-e", `MUSCAT_ZENOH_ADVERTISE_HOST=${zenohAdvertiseHost}`] : []),
+    ...(!hostAgentUrl && zenohPort ? ["-e", `MUSCAT_ZENOH_PORT=${zenohPort}`] : []),
+    ...(hostAgentUrl ? ["-e", `MUSCAT_HOST_AGENT_URL=${hostAgentUrl}`] : []),
     ...portEnvFlags(portRanges),
   ];
   const docker = (args, opts = {}) =>
@@ -117,7 +125,7 @@ async function runPython(root, portRanges) {
   docker(["rm", "-f", container], { stdio: "ignore" });
   log.step("starting Python dev container…");
   const up = docker(
-    ["run", "-d", "--name", container, ...netFlags,
+    ["run", "-d", "--name", container, ...netFlags, ...standaloneZenohPortFlags,
       // host.docker.internal is automatic on Docker Desktop (macOS/Windows);
       // this makes it resolve on Linux too, for the no-bridge gateway fallback above.
       ...hostGatewayFlags,
@@ -133,12 +141,96 @@ async function runPython(root, portRanges) {
     "pip install --break-system-packages --ignore-installed -q watchfiles" +
     " && { [ -f requirements.txt ] && pip install --break-system-packages --ignore-installed -q -r requirements.txt || true; }"]);
 
+  docker(["exec", container, "bash", "-lc", `cat > /tmp/muscat-pk-python-dev-entry.py <<'PY'
+import json
+import os
+import urllib.request
+
+def install_host_agent_sdk_patch(host_agent_url):
+    from rainbow.rb_sdk.base import RBBaseSDK
+    from rainbow.rb_sdk.manipulate_sdk.manipulate_move import RBManipulateMoveSDK
+
+    base_url = host_agent_url.rstrip("/")
+
+    def post_json(path, payload):
+        req = urllib.request.Request(
+            f"{base_url}{path}",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        if not data.get("ok"):
+            raise RuntimeError(data.get("error") or "host SDK agent request failed")
+        return data.get("result")
+
+    async def connect_via_host_agent(self, *args, **kwargs):
+        print(f"[muscat-pk] SDK connect routed through host agent: {base_url}", flush=True)
+        return "host-agent"
+
+    async def disconnect_via_host_agent(self, *args, **kwargs):
+        return None
+
+    def call_move_j_via_host_agent(
+        self,
+        *,
+        robot_model,
+        target,
+        reference_value=None,
+        speed=None,
+        flow_manager_args=None,
+    ):
+        result = post_json("/move_j", {
+            "robot_model": robot_model,
+            "values": target.get("tar_values") if isinstance(target, dict) else None,
+            "target": target,
+            "reference_value": reference_value,
+            "speed": speed,
+        })
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+        return result
+
+    RBBaseSDK.connect = connect_via_host_agent
+    RBBaseSDK.disconnect = disconnect_via_host_agent
+    RBManipulateMoveSDK.call_move_j = call_move_j_via_host_agent
+
+try:
+    advertise_host = os.getenv("MUSCAT_ZENOH_ADVERTISE_HOST")
+    zenoh_port = os.getenv("MUSCAT_ZENOH_PORT")
+    host_agent_url = os.getenv("MUSCAT_HOST_AGENT_URL")
+
+    if host_agent_url:
+        print(f"[muscat-pk] host SDK agent mode: {host_agent_url}", flush=True)
+        install_host_agent_sdk_patch(host_agent_url)
+    else:
+        from rainbow.rb_sdk.base import RBBaseSDK
+        if advertise_host:
+            RBBaseSDK._detect_local_ip = staticmethod(lambda host: advertise_host)
+        if zenoh_port:
+            _orig_connect = RBBaseSDK.connect
+
+            async def _connect_with_dev_port(self, *args, **kwargs):
+                kwargs.setdefault("zenoh_port", int(zenoh_port))
+                return await _orig_connect(self, *args, **kwargs)
+
+            RBBaseSDK.connect = _connect_with_dev_port
+except Exception as exc:
+    print(f"[muscat-pk] SDK dev network patch skipped: {exc}", flush=True)
+
+import runpy
+runpy.run_path("/plugin/py/main.py", run_name="__main__")
+PY`]);
+
   if (pluginId) log.step(`RB_PLUGIN_ID=${pluginId}`);
+  if (!hostAgentUrl && zenohAdvertiseHost && zenohPort) log.step(`Zenoh advertise → ${zenohAdvertiseHost}:${zenohPort}`);
+  if (hostAgentUrl) log.step(`host SDK agent → ${hostAgentUrl}`);
   log.step("watchfiles → py/main.py (reload on any .py change in py/)");
   const child = spawn(
     "docker",
     ["exec", ...envFlags, container, "bash", "-lc",
-      "python3 -m watchfiles --filter python --target-type command 'python3 py/main.py' py"],
+      "python3 -m watchfiles --filter python --target-type command 'python3 /tmp/muscat-pk-python-dev-entry.py' py"],
     { cwd: root, stdio: ["inherit", "inherit", "pipe"] },
   );
   // watchfiles prints a KeyboardInterrupt traceback on SIGTERM — suppress it
@@ -351,6 +443,11 @@ export async function runDevBack(args = []) {
   const { robotIp, robotToken } = await promptRobotConnection(args);
   if (robotIp)    process.env.MUSCAT_ROBOT_HOST  = robotIp;
   if (robotToken) process.env.MUSCAT_ROBOT_TOKEN = robotToken;
+  // Standalone `dev:back` against a remote robot needs the Zenoh reverse-path
+  // advertise host/port too (idempotent — `muscat-pk dev` already set these).
+  // Host-agent mode routes robot SDK calls through the mac host, so the Docker
+  // backend does not need its own remote Zenoh peer.
+  if (!process.env.MUSCAT_HOST_AGENT_URL) await ensureRemoteZenohEnv(robotIp, { log });
   const type = manifestRuntime(root);
   if (type === "ros2") return await runRos2(root, portRanges);
   if (type === "cpp") return await runCpp(root, portRanges);

package/cli/src/socketBridge.mjs

@@ -53,10 +53,12 @@ export function startSocketBridge({ port = 10000, host = "0.0.0.0" } = {}) {
     socket.on("serve_register", (data = {}) => {
       if (!data.topic) return;
       queryables.set(data.topic, socket.id);
+      log.step(`serve registered: ${data.topic}`);
     });
 
     socket.on("serve_unregister", (data = {}) => {
       if (queryables.get(data.topic) === socket.id) queryables.delete(data.topic);
+      if (data.topic) log.step(`serve unregistered: ${data.topic}`);
     });
 
     socket.on("serve_reply", (data = {}) => {
@@ -72,9 +74,11 @@ export function startSocketBridge({ port = 10000, host = "0.0.0.0" } = {}) {
       const targetSid = queryables.get(topic);
       const target = targetSid && io.sockets.sockets.get(targetSid);
       if (!target) {
-        if (typeof ack === "function") ack(undefined);
+        log.warn(`action has no handler: ${topic}`);
+        if (typeof ack === "function") ack({ error: `No handler registered for ${topic}` });
         return;
       }
+      log.step(`action: ${topic}`);
       const id = randomUUID();
       const timer = setTimeout(() => {
         pending.delete(id);

package/cli/src/templates-embedded.mjs

@@ -1,3 +1,3 @@
 // AUTO-GENERATED by cli/bundle-templates.mjs — do not edit.
 // ponytail: generated at publish time; not tracked in git.
-export const TEMPLATES = {"common/.mcp.json":"ewogICJtY3BTZXJ2ZXJzIjogewogICAgIm11c2NhdCI6IHsKICAgICAgImNvbW1hbmQiOiAibXVzY2F0LXBrIiwKICAgICAgImFyZ3MiOiBbIm1jcCJdCiAgICB9CiAgfQp9Cg==","common/README.md":"# __PLUGIN_NAME__

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 build      # build + distributable ZIP
```

---

## Project structure

```
__PLUGIN_DIR__/
├─ ui/
│   ├─ content.tsx      # plugin UI entry point
│   └─ style.css        # plugin styles auto-loaded by muscat()
├─ py/
│   └─ main.py          # Python backend entry point
├─ assets/
│   └─ icon.svg         # icon referenced from manifest
├─ manifest.json        # metadata, contribution points, runtime config
├─ README.md            # this file (copied to dist/ on build)
└─ requirements.txt     # Python deps (auto-pinned to latest on build)
```

> ROS2 plugins additionally include a `ros2_ws/` directory.

---

## Frontend (`ui/content.tsx`)

### JavaScript dependencies

`muscat-pk build` runs this plugin project's own Vite build. Vite resolves
imports from installed `node_modules`; it does not care whether a package is
listed under `dependencies` or `devDependencies`, but the package must be
installed.

Do not run a production-only install such as `npm install --omit=dev` before
building the plugin UI, because build tools like `vite`, `typescript`,
`tailwindcss`, `@tailwindcss/vite`, `sass`, or `less` are usually
`devDependencies`.

The scaffold keeps this split:

| package kind | examples | why |
|---|---|---|
| `dependencies` | `@rainbow-robotics/plugin-ui`, UI libraries imported by plugin source | Author-facing APIs used by `ui/*.tsx` |
| `devDependencies` | `vite`, `typescript`, `tailwindcss`, `@tailwindcss/vite`, `sass`, `less` | Build/dev tools needed before `dist/*.js` is produced |

The built plugin ZIP does not include `package.json` or `node_modules`. For
production, Muscat provides `@rainbow-robotics/plugin-ui`, React, and ReactDOM
through the host import map; plugin UI build output imports those as host
externals.

### Styles

`muscat()` automatically loads `ui/style.{css,scss,sass,less}` (or
`ui/styles.{css,scss,sass,less}`) for every UI entry, plus
`ui/{entry}.{css,scss,sass,less}` for a matching entry-specific stylesheet. You
do not need to import CSS from every `.tsx` file.

The scaffold uses Tailwind's theme/utilities layers only, so plugin utilities
are generated from files under `ui/` without applying Tailwind preflight resets
to the host page.

Built CSS selectors are scoped under the current plugin id
(`[data-muscat-plugin-id="..."]`). CSS-in-JS libraries such as Emotion work
normally, but global styles should be scoped by the author.

#### Tailwind

This template enables Tailwind in `vite.config.ts`:

```ts
import { defineConfig } from "vite";
import tailwindcss from "@tailwindcss/vite";
import { muscat } from "@rainbow-robotics/muscat-plugin-kit/vite";

export default defineConfig({
  plugins: [tailwindcss(), muscat()],
});
```

The default `ui/style.css` uses Tailwind theme/utilities only, not preflight:

```css
@layer theme, utilities;

@import "tailwindcss/theme.css" layer(theme);
@import "tailwindcss/utilities.css" layer(utilities);

@source "./**/*.{ts,tsx}";
```

#### SCSS, Sass, and Less

Install the preprocessor package, then create one of the auto-loaded style files.

```bash
npm i -D sass
```

```scss
/* ui/style.scss */
$accent: #3b82f6;

.panel {
  border: 1px solid color-mix(in srgb, $accent 40%, transparent);

  &__title {
    color: $accent;
  }
}
```

For Less, install `less` and use `ui/style.less`.

#### Emotion

Emotion dependencies may be in `dependencies` or `devDependencies`; Vite can
bundle them when they are installed and imported by the plugin.

For `styled`, no Vite config change is needed:

```bash
npm i @emotion/react @emotion/styled
```

```tsx
import styled from "@emotion/styled";

const Panel = styled.div({
  display: "grid",
  gap: 12,
});
```

For Emotion's `css` prop, pass React plugin options through `muscat()` and add
`jsxImportSource` to `tsconfig.json`:

```bash
npm i @emotion/react @emotion/styled
npm i -D @emotion/babel-plugin
```

```ts
// vite.config.ts
import { defineConfig } from "vite";
import tailwindcss from "@tailwindcss/vite";
import { muscat } from "@rainbow-robotics/muscat-plugin-kit/vite";

export default defineConfig({
  plugins: [
    tailwindcss(),
    muscat({
      react: {
        jsxImportSource: "@emotion/react",
        babel: {
          plugins: ["@emotion/babel-plugin"],
        },
      },
    }),
  ],
});
```

```json
{
  "compilerOptions": {
    "jsxImportSource": "@emotion/react"
  }
}
```

Emotion `Global` writes global CSS at runtime, so scope it manually or avoid it
inside plugins.

### 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({ title?, message, type?, actionLabel?, handleActionClick?, closeOnActionClick?, duration?, onClose? })` | Show a host toast notification. `message` accepts a string or `ReactElement`. `type` can be `"info"`, `"danger"`, `"warning"`, `"caution"`, or `"success"` |
| `rb.alert({ title?, message, buttonText? })`                                                                       | Show a host alert dialog. Resolves when the dialog is closed                                                                                               |
| `rb.confirm({ title?, message, buttonText? })`                                                                     | Show a host confirmation dialog. `buttonText` accepts `{ yes, no }`. Resolves to `true` or `false`                                                         |
| `rb.prompt({ title?, message, value?, placeholder?, buttonText? })`                                                | Show a host prompt dialog. `buttonText` accepts `{ yes, no }`. Resolves to the entered string or `undefined`                                               |

Topic names passed to `pub`, `sub`, `action`, and `serve` are isolated per plugin.


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

const ok = await rb.confirm({
  title: "Run",
  message: "Start the backend action?",
});
if (ok) {
  await rb.action("run");
}
```

### Saving and restoring form data (`useRbFormData` / `useRbSave`)

If the host embeds your plugin in a form it owns (e.g. a program step editor
with its own Save button), it can hand your plugin previously-saved values and
pull the current values back out when the user saves. The host — not the
plugin — persists the data (IndexedDB, backend, etc.).

```tsx
import { useState } from "react";
import { useRbFormData, useRbSave } from "@rainbow-robotics/plugin-ui/react";

type GripArgs = { targetName: string; width: number };
const DEFAULTS: GripArgs = { targetName: "", width: 20 };

export default function App() {
  // Previously-saved values, or undefined for a brand-new instance.
  const saved = useRbFormData<GripArgs>();
  const [args, setArgs] = useState<GripArgs>({ ...DEFAULTS, ...saved });

  // Registers a getter the host calls when its Save button is clicked.
  // Always returns the CURRENT values — re-registering on every render keeps
  // the closure fresh, which useRbSave already handles for you.
  useRbSave(() => ({
    args,
    summary: `${args.targetName || "target"} · ${args.width}mm`,
  }));

  return (/* ...form UI reading/writing `args`... */);
}
```

The value returned from `useRbSave` must be JSON-serialisable — the host
persists it as-is. Not every host embeds plugins in a save/restore form; if
yours doesn't, you can skip these hooks entirely.

### UI components

Import Muscat components from `@rainbow-robotics/plugin-ui/react` and export a
React component as the default export. The host mounts that component directly
and provides `useRb()` through context.

```tsx
import { useState } from "react";
import { RBLabelButton, RBSlider, RBSwitch } from "@rainbow-robotics/plugin-ui/react";
import { useRb } from "@rainbow-robotics/plugin-ui/sdk";

export default function App() {
  const rb = useRb();
  const [width, setWidth] = useState(20);
  const [enabled, setEnabled] = useState(true);

  return (
    <div className="flex flex-col gap-4">
      <RBSlider
        value={[width]}
        min={0}
        max={100}
        onValueChange={(values: number[]) => setWidth(values[0] ?? 0)}
      />
      <RBSwitch checked={enabled} onCheckedChange={setEnabled} />
      <RBLabelButton
        disabled={!enabled}
        onClick={() => rb.action("grip", { width })}
      >
        Grip
      </RBLabelButton>
    </div>
  );
}
```

---

## Developing directly on the robot PC

If you're running `muscat-pk dev` **on the robot PC itself**, Muscat is likely already
running its own Socket.IO bridge on port 10000. In that case the CLI detects the port
conflict and asks:

```
⚠ port 10000 is already in use — can't start Socket.IO bridge.
  Proceed without Socket.IO bridge? [y/N]:
```

Answer **y**. Your plugin backend will connect to the Muscat bridge that's already
running instead of starting a new one — exactly what you want when developing on the
robot.

> If you answer **n** (or just press Enter), the CLI exits so you can free the port
> manually and retry.

---

## Backend runtimes

`manifest.json` chooses one backend runtime. `muscat-pk dev` runs backend code in
a Docker container matching the robot environment. Backend code should contain
plugin logic only; it should not start the Muscat bridge or its own copy of the
plugin gateway.

### Which backend pattern? (depends on the contribution point)

**How you control the robot depends on what your plugin contributes** (see
`manifest.json` → `contributes[].point`). Don't mix these up:

| Contribution point | What it is | Backend pattern |
| --- | --- | --- |
| `program.panel` (with `commandInfo`) | Defines a **custom command** the plugin adds to the Program page's rule-based sequence builder. The operator places it into the program tree like any built-in command (Move J, Point, Wait, …); it runs when the program reaches that step. | **`PluginProgramContext`** — integrated with the program's stop/pause and variables. See _Program command backend_ below. |
| `toolbar` / `lnb` / `move.panel` | A live UI panel/popover the operator interacts with directly | Call the robot **SDK directly** (`RBManipulateSDK`, `RBAmrSDK`) from `py/main.py`, or `rb.action(...)` → your backend → SDK. **Not** a program step — there is no stop/pause/variable context. |

Rule of thumb: use `PluginProgramContext` **only** for a `program.panel` command
that runs as part of a program. To move the robot live from a toolbar/move panel,
use the SDK — a program-step context does not apply.

### Frontend-only (`none`)

Use this when the plugin only has UI and calls host services:

```json
{ "runtime": { "type": "none" } }
```

### Python

Python plugins use `py/main.py` and can communicate with the UI through
`rainbow.rb_sdk.RBPluginCall`.

```python
import time
from rainbow.rb_sdk import RBAmrSDK, RBManipulateSDK, RBPluginCall

plugin = RBPluginCall()


plugin.publish("state", {"ready": True})


@plugin.subscribe("event")
def on_ui_event(payload=None):
    print(payload)


@plugin.serve("tool/echo")
def echo(payload=None):
    return {"echo": payload}


def call_frontend():
    res = plugin.call("tool/ping", payload={"hello": "plugin"})
    print(res)


def move_j_example():
    amr = RBAmrSDK()
    manipulate = RBManipulateSDK()
    return manipulate.move.call_move_j(
        robot_model="C500920",
        target={"tar_values": [0, 0, 0, 0, 0, 0], "tar_frame": 0, "tar_unit": 0},
    )


if __name__ == "__main__":
    while True:
        time.sleep(1)
```

#### Program command backend (`program.panel`)

A `program.panel` contribution defines a **custom command** your plugin adds to
the Muscat **Program page**, where the operator builds a robot program as a
rule-based sequence (a program tree). Your command appears alongside the
built-ins (Move J, Point, Wait, …); the operator places it into the tree, and
each time the program executes that step the host calls your backend through
`PluginProgramContext` — receiving the step args, checking for stop/pause,
reading/writing program variables, and signalling completion. This pattern is
**only** for `program.panel`; a toolbar/move-panel plugin uses the SDK directly
instead (see the table above).

```python
"""
Plugin backend main.py example (program.panel command).

manifest.json:
  "runtime": {"type": "python", "entry": "main.py"},
  "contributes": [{
    "point": "program.panel",
    "ui": "program",
    "label": {"en": "My Plugin Step"},
    "commandInfo": {
      "name": "My Plugin Step",
      "icon": "assets/icon.svg",
      "funcName": "rb_program_sdk.plugin_execute",
      "args": {"message": "hello"}   # plugin-author-defined args
    }
  }]

The host invokes commandInfo.funcName (rb_program_sdk.plugin_execute) with
args.plugin_id + your args when the program reaches this step.
"""
import asyncio
from rainbow.rb_sdk import PluginProgramContext

ctx = PluginProgramContext(plugin_id="my-plugin")


@ctx.on_execute
async def handle(args: dict) -> None:
    message = args.get("message", "")
    print(f"[my-plugin] execute called: message={message}", flush=True)

    # check stop/pause during long-running work
    for _ in range(10):
        await ctx.check_stop()
        await asyncio.sleep(0.1)

    # read a program variable
    counter = await ctx.get_variable("counter")
    print(f"[my-plugin] counter={counter}", flush=True)

    # update a variable
    await ctx.set_variable("result", f"done: {message}")

    # finish the step
    await ctx.done()


if __name__ == "__main__":
    asyncio.run(ctx.start())
```

### C++

C++ plugins use `cpp/` and are built with CMake inside Docker. The current C++
template is a build/run skeleton; wire it to the plugin gateway when the C++ SDK
is available.

```cpp
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <string>
#include <thread>

int main() {
  const char* plugin_id = std::getenv("RB_PLUGIN_ID");
  std::cout << "[__PLUGIN_NAME__] backend ready"
            << (plugin_id ? std::string(" (id=") + plugin_id + ")" : "")
            << std::endl;

  while (true) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
  return 0;
}
```

### ROS2 (rclpy)

ROS2 Python plugins use `ros2_ws/` with `runtime.rosClient: "rclpy"`. The node
is launched with `--ros-args -r __ns:=/{slug}` automatically by `dev:back`.

```python
# ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/node.py
import rclpy
from rclpy.node import Node
from rainbow.rb_sdk import RBManipulateSDK

sdk = RBManipulateSDK()


class __PLUGIN_CLASS__Node(Node):
    def __init__(self):
        super().__init__("__PLUGIN_SLUG___node")
        self.get_logger().info("__PLUGIN_NAME__ node started")
        # use sdk alongside ROS2 publishers/subscribers/services as needed
```

### ROS2 (rclcpp)

ROS2 C++ plugins use `ros2_ws/` with `runtime.rosClient: "rclcpp"`.

```cpp
#include "rclcpp/rclcpp.hpp"

class __PLUGIN_CLASS__Node : public rclcpp::Node {
public:
  __PLUGIN_CLASS__Node() : Node("__PLUGIN_SLUG___node") {
    RCLCPP_INFO(this->get_logger(), "__PLUGIN_NAME__ node started");
  }
};
```

---

## manifest.json

```jsonc
{
  // unique plugin ID — reverse-domain format recommended
  "id": "com.example.my-plugin",
  "name": "My Plugin",
  "version": "1.0.0",

  // minimum Muscat version required to load this plugin
  "minMuscatVersion": "1.0.0",

  // plugin author (empty string is fine)
  "author": "Your Name",

  // displayed in the Muscat plugin store / info panel
  // string or { en (required), ko, ja, zh, vi, th, es }
  "description": { "en": "Plugin description", "ko": "플러그인 설명" },

  // SVG string (single file) or PNG/JPG size map (all three sizes required)
  "icons": "assets/icon.svg",
  // "icons": { "16": "assets/icon-16.png", "48": "assets/icon-48.png", "128": "assets/icon-128.png" },

  // targetModels and/or targetCategorys — at least one is required
  // "all" = every target, or list specific values
  "targetModels": "all",
  // "targetModels": ["C500920", "C500930"],
  "targetCategorys": "all",
  // "targetCategorys": ["manipulate", "amr", "rby1", "vision"],

  "contributes": [
    // program.panel — defines a custom command for the Program page sequence
    //   builder; runs via PluginProgramContext when the program reaches it
    {
      "point": "program.panel",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "program",           // must be unique across all contributions
      "commandInfo": {
        "name": "My Plugin",
        "icon": "assets/icon.svg",
        "funcName": "rb_program_sdk.plugin_execute",
        "args": {}
      }
    },
    // toolbar — adds a button to the top toolbar (required)
    {
      "point": "toolbar",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "content",           // must be unique across all contributions
      "opens": "popover"         // popover | panel | page
    },
    // move.panel — adds a panel to the Move screen
    {
      "point": "move.panel",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "move"               // must be unique across all contributions
    }
  ],

  // runtime — one of:
  //   { "type": "none" }
  //   { "type": "python", "entry": "main.py" }
  //   { "type": "cpp", "entry": "<executable name>" }
  //   { "type": "ros2", "rosClient": "rclpy" | "rclcpp", "package": "...", "launch": "..._node" }
  "runtime": { "type": "python", "entry": "main.py" },

  // optional: TCP ports opened by this plugin backend
  // only number[] is allowed; ranges/objects are not accepted
  // external plugin ports must be within 28600-28999
  "ports": [28600]
}
```

**Backend types:**

| type | source dir | build / run | entry |
|---|---|---|---|
| `python` | `py/` | pip + run in Docker | `main.py` |
| `cpp` | `cpp/` | CMake in Docker | built executable name |
| `ros2` (rclpy) | `ros2_ws/` | colcon (ament_python) in Docker | — |
| `ros2` (rclcpp) | `ros2_ws/` | colcon (ament_cmake) in Docker | — |

> Every back end runs in a Docker container matching the robot (Ubuntu 24.04 + Python 3.12), so dev behaves like production and compiled binaries are ABI-compatible. **Docker is required** for all backend types (only a frontend-only `none` plugin skips it). No local Python/toolchain setup is needed.

**Contribution points:**

| point | Where it appears | Backend | `commandInfo` |
|---|---|---|:---:|
| `toolbar` | Top toolbar button (must have at least one) | SDK / `rb.action` | — |
| `lnb` | Left navigation entry | SDK / `rb.action` | — |
| `move.panel` | Move screen panel | SDK / `rb.action` | — |
| `program.panel` | Custom command in the Program page sequence builder | `PluginProgramContext` | ✓ |

**`commandInfo` fields** (for `program.panel`):

| field | type | description |
|---|---|---|
| `name` | `string` | Display name of the command in the program tree |
| `icon` | `string` | Icon path |
| `iconClassName` | `string?` | Optional CSS class for the icon |
| `funcName` | `string?` | Backend function name to call |
| `args` | `Record<string, any>?` | Default arguments |
| `disabled` | `boolean?` | Whether the node is disabled |
| `allowChildren` | `string[]?` | Allowed child commands |
| `allowParents` | `string[]?` | Allowed parent commands |
| `notAllowChildren` | `string[]?` | Disallowed child commands |
| `syncGroupId` | `boolean?` | Sync group ID across children |
| `disableCopy` | `boolean?` | Prevent copy |
| `disableDelete` | `boolean?` | Prevent delete |
| `requireChildren` | `boolean?` | Whether a child command is required |
| `requireParent` | `boolean?` | Whether a parent command is required |
| `childrenCommand` | `string?` | Default command type for children |

**Validation rules:**
- `id`, `name`, `version`, `minMuscatVersion` — required non-empty strings
- `author` — required non-empty string
- `description` — required (`string` or `{ en (required), ko?, ja?, zh?, vi?, th?, es? }`)
- `icons` — SVG: single string path ending in `.svg`; PNG/JPG: object with `"16"`, `"48"`, `"128"` all present
- `targetModels` — `"all"` or a non-empty array of robot model ID strings (at least one of `targetModels` / `targetCategorys` required)
- `targetCategorys` — `"all"` or a non-empty array of `"manipulate" | "amr" | "rby1" | "vision"` (at least one of `targetModels` / `targetCategorys` required)
- `contributes` — required array; must contain at least one `toolbar` entry
- `ui` — each contribution must have a unique value
- `commandInfo` — required when `point` is `"program.panel"`
- `ports` — optional `number[]`; every port must be within `28600-28999`
  and must not be a reserved robot/industrial/internal port

`muscat-pk build` throws on any validation error. `muscat-pk dev` prints warnings.

**Backend port rules:**
- Declare a port only if your backend opens a TCP server/listener.
- `muscat-pk dev` and `muscat-pk dev:back` stop the backend if it opens an
  undeclared managed port.
- Reserved ports include `502`, `2222`, `4840`, `5170-5179`, `8000-8999`,
  `10000`, `30004`, `34964`, `44818`, `50000-50005`, and `50051`.

---

## Localized documentation

You can ship per-language README files alongside the main `README.md`. Place them in the project root:

```
README.md        # default / English fallback
README.ko.md     # Korean
README.en.md     # explicit English (optional)
README.ja.md     # Japanese
```

All `README*.md` files found at the project root are automatically copied to `dist/` on
`muscat-pk build`. Muscat displays the file matching the user's locale,
falling back to `README.md` if none matches.

---

## 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
```

Run `muscat-pk dev` or `muscat-pk dev:back` — dependencies are installed automatically
inside the dev container (`pip install -r requirements.txt`) on every startup. No
local Python is required for this.

`muscat-pk dev:back` also best-effort creates/refreshes a local `.venv` in the
background (via `uv` if available, else your system Python) with the same deps —
purely so your editor (pylint, pyright, mypy, ...) can resolve imports and lint
correctly. It's not used to run the backend; Docker is the actual execution
environment, so this step is silently skipped if no local Python toolchain is
available. Point your editor's Python interpreter at `.venv`.

`muscat-pk sdk update` also refreshes `.venv` in place if one already exists, so
your editor picks up the new `rainbow-rb-sdk` version immediately.

> `muscat-pk build` only **pins** versions in `requirements.txt` — it does not run `pip install` (the robot installs them at load time).

---

## Switching backend type

```bash
muscat-pk type change                 # interactive
muscat-pk type change --to cpp        # → C++
muscat-pk type change --to ros2       # → ROS2 (rclpy / Python)
muscat-pk type change --to ros2-cpp   # → ROS2 (rclcpp / C++)
muscat-pk type change --to python     # → Python
```

> Existing backend dirs (`ros2_ws/`, `cpp/`) are not deleted when switching away. Remove them manually if no longer needed.

---

## AI coding assistants (MCP)

If you build your plugin with an AI assistant (Claude Code, Codex, …), give it
grounded knowledge of the Muscat UI components, design tokens, and SDK instead of
letting it guess. `muscat-pk mcp` is an MCP server exposing:

- `list_components` / `get_component_props` / `get_component_example` — every
  `@rainbow-robotics/plugin-ui/react` component with its real props and a working
  Storybook example.
- `list_design_tokens` / `search_design_tokens` — the Tailwind classes to use
  (`bg-bg-*`, `text-fg-*`, `typo-*`, …) so your UI matches the host theme.
- `search_rb_sdk` — how to use `useRb()`, `rb.*`, `useRbFormData`/`useRbSave`, and
  the backend runtimes.
- `list_rb_sdk` / `get_rb_sdk_api` — the installed `rainbow-rb-sdk` (Python
  backend) classes and signatures.

**Browse the components live** with `muscat-pk storybook`.

### Register the server

**Claude Code** — a `.mcp.json` is already scaffolded at your plugin root, so
it works out of the box:

```json
{
  "mcpServers": {
    "muscat": {
      "command": "muscat-pk",
      "args": ["mcp"]
    }
  }
}
```

**Codex** — add to `~/.codex/config.toml`:

```toml
[mcp_servers.muscat]
command = "muscat-pk"
args = ["mcp"]
```

Any other MCP client works too — it's a standard stdio MCP server started with
`muscat-pk mcp`. If `muscat-pk` isn't on the client's PATH, use its absolute path
(`which muscat-pk`) as `command`.

---

## Shipping

```bash
muscat-pk build            # build + ZIP
muscat-pk build --no-zip   # build only, no ZIP
```

- Builds `ui/content.tsx` → `dist/content.js` (minified)
- Pins `requirements.txt` to latest versions (stable-only on `main` branch)
- Copies `assets/`, `manifest.json`, `README*.md`, `py/`, and `requirements.txt` into `dist/`
- ROS2: runs `colcon build` inside the Jazzy container; includes `ros2_ws/install/`
- Output: `__PLUGIN_DIR__-{version}.zip`

ZIP layout:

```
__PLUGIN_DIR__-1.0.0.zip
├─ dist/
│   ├─ content.js        # built UI
│   ├─ manifest.json
│   ├─ assets/
│   ├─ README.md
│   ├─ README.ko.md      # if present
│   ├─ main.py           # from 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      # build → dist/ + distributable ZIP (--no-zip to skip)
muscat-pk storybook  # browse the rb-components UI library in a browser
muscat-pk mcp        # MCP server for AI assistants (components/tokens/SDK docs)
```

```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
muscat-pk uninstall      # remove muscat-pk itself
```
","common/assets/icon.svg":"PHN2ZyB3aWR0aD0iMjU2IiBoZWlnaHQ9IjI1NiIgdmlld0JveD0iMCAwIDI1NiAyNTYiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CiAgPGRlZnM+CiAgICA8bGluZWFyR3JhZGllbnQgaWQ9ImJnIiB4MT0iMzYiIHkxPSIyOCIgeDI9IjIyMCIgeTI9IjIyOCIgZ3JhZGllbnRVbml0cz0idXNlclNwYWNlT25Vc2UiPgogICAgICA8c3RvcCBzdG9wLWNvbG9yPSIjOEI1Q0Y2Ii8+CiAgICAgIDxzdG9wIG9mZnNldD0iMSIgc3RvcC1jb2xvcj0iIzVCMjFCNiIvPgogICAgPC9saW5lYXJHcmFkaWVudD4KICAgIDxsaW5lYXJHcmFkaWVudCBpZD0iZ3JhcGUiIHgxPSI5MiIgeTE9Ijc0IiB4Mj0iMTY4IiB5Mj0iMTc4IiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSI+CiAgICAgIDxzdG9wIHN0b3AtY29sb3I9IiNEOEI0RkUiLz4KICAgICAgPHN0b3Agb2Zmc2V0PSIxIiBzdG9wLWNvbG9yPSIjQTg1NUY3Ii8+CiAgICA8L2xpbmVhckdyYWRpZW50PgogIDwvZGVmcz4KCiAgPHJlY3QgeD0iMTYiIHk9IjE2IiB3aWR0aD0iMjI0IiBoZWlnaHQ9IjIyNCIgcng9IjUyIiBmaWxsPSJ1cmwoI2JnKSIvPgoKICA8IS0tIHBsdWdpbiBicmFja2V0cyAtLT4KICA8cGF0aCBkPSJNNzIgODRINTZDNDcuMTYzNCA4NCA0MCA5MS4xNjM0IDQwIDEwMFYxMTYiIHN0cm9rZT0id2hpdGUiIHN0cm9rZS13aWR0aD0iMTIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgogIDxwYXRoIGQ9Ik0xODQgODRIMjAwQzIwOC44MzcgODQgMjE2IDkxLjE2MzQgMjE2IDEwMFYxMTYiIHN0cm9rZT0id2hpdGUiIHN0cm9rZS13aWR0aD0iMTIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgogIDxwYXRoIGQ9Ik03MiAxNzJINTZDNDcuMTYzNCAxNzIgNDAgMTY0LjgzNyA0MCAxNTZWMTQwIiBzdHJva2U9IndoaXRlIiBzdHJva2Utd2lkdGg9IjEyIiBzdHJva2UtbGluZWNhcD0icm91bmQiLz4KICA8cGF0aCBkPSJNMTg0IDE3MkgyMDBDMjA4LjgzNyAxNzIgMjE2IDE2NC44MzcgMjE2IDE1NlYxNDAiIHN0cm9rZT0id2hpdGUiIHN0cm9rZS13aWR0aD0iMTIiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgoKICA8IS0tIGdyYXBlIHN0ZW0gKyBsZWFmIC0tPgogIDxwYXRoIGQ9Ik0xMjggNzNDMTI4IDU5IDEzNyA0OCAxNTEgNDQiIHN0cm9rZT0iI0YzRThGRiIgc3Ryb2tlLXdpZHRoPSIxMCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIi8+CiAgPHBhdGggZD0iTTE0MiA1MUMxNTEgMzkgMTY5IDM5IDE3OSA1MEMxNjUgNjAgMTUxIDYyIDE0MiA1MVoiIGZpbGw9IiNDNEI1RkQiLz4KCiAgPCEtLSBtdXNjYXQgZ3JhcGUgY2x1c3RlciAtLT4KICA8Y2lyY2xlIGN4PSIxMDYiIGN5PSI5MSIgcj0iMTgiIGZpbGw9InVybCgjZ3JhcGUpIi8+CiAgPGNpcmNsZSBjeD0iMTMyIiBjeT0iODgiIHI9IjE4IiBmaWxsPSJ1cmwoI2dyYXBlKSIvPgogIDxjaXJjbGUgY3g9IjE1OCIgY3k9IjkxIiByPSIxOCIgZmlsbD0idXJsKCNncmFwZSkiLz4KICA8Y2lyY2xlIGN4PSI5NCIgY3k9IjExOSIgcj0iMTgiIGZpbGw9InVybCgjZ3JhcGUpIi8+CiAgPGNpcmNsZSBjeD0iMTIwIiBjeT0iMTE2IiByPSIxOCIgZmlsbD0idXJsKCNncmFwZSkiLz4KICA8Y2lyY2xlIGN4PSIxNDYiIGN5PSIxMTYiIHI9IjE4IiBmaWxsPSJ1cmwoI2dyYXBlKSIvPgogIDxjaXJjbGUgY3g9IjE3MiIgY3k9IjExOSIgcj0iMTgiIGZpbGw9InVybCgjZ3JhcGUpIi8+CiAgPGNpcmNsZSBjeD0iMTA3IiBjeT0iMTQ1IiByPSIxOCIgZmlsbD0idXJsKCNncmFwZSkiLz4KICA8Y2lyY2xlIGN4PSIxMzMiIGN5PSIxNDQiIHI9IjE4IiBmaWxsPSJ1cmwoI2dyYXBlKSIvPgogIDxjaXJjbGUgY3g9IjE1OSIgY3k9IjE0NSIgcj0iMTgiIGZpbGw9InVybCgjZ3JhcGUpIi8+CiAgPGNpcmNsZSBjeD0iMTIwIiBjeT0iMTcwIiByPSIxOCIgZmlsbD0idXJsKCNncmFwZSkiLz4KICA8Y2lyY2xlIGN4PSIxNDYiIGN5PSIxNzAiIHI9IjE4IiBmaWxsPSJ1cmwoI2dyYXBlKSIvPgogIDxjaXJjbGUgY3g9IjEzMyIgY3k9IjE5MyIgcj0iMTgiIGZpbGw9InVybCgjZ3JhcGUpIi8+CgogIDwhLS0gY2VudGVyIHBsdWdpbiBnbHlwaCAtLT4KICA8cGF0aCBkPSJNMTIyIDExOVYxMDlDMTIyIDEwMy40NzcgMTI2LjQ3NyA5OSAxMzIgOTlIMTM2QzE0MS41MjMgOTkgMTQ2IDEwMy40NzcgMTQ2IDEwOVYxMTkiIHN0cm9rZT0id2hpdGUiIHN0cm9rZS13aWR0aD0iOCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIi8+CiAgPHJlY3QgeD0iMTE2IiB5PSIxMTgiIHdpZHRoPSIzNiIgaGVpZ2h0PSIzNCIgcng9IjEwIiBmaWxsPSJ3aGl0ZSIvPgogIDxwYXRoIGQ9Ik0xMjcgMTUyVjE2MyIgc3Ryb2tlPSJ3aGl0ZSIgc3Ryb2tlLXdpZHRoPSI4IiBzdHJva2UtbGluZWNhcD0icm91bmQiLz4KICA8cGF0aCBkPSJNMTQxIDE1MlYxNjMiIHN0cm9rZT0id2hpdGUiIHN0cm9rZS13aWR0aD0iOCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIi8+Cjwvc3ZnPgo=","common/manifest.json":"ewogICJpZCI6ICJfX1BMVUdJTl9JRF9fIiwKICAibmFtZSI6ICJfX1BMVUdJTl9OQU1FX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAibWluTXVzY2F0VmVyc2lvbiI6ICIxLjAuMCIsCiAgImF1dGhvciI6ICJfX1BMVUdJTl9BVVRIT1JfXyIsCiAgImVtYWlsIjogIl9fUExVR0lOX0VNQUlMX18iLAogICJkZXNjcmlwdGlvbiI6IHsKICAgICJrbyI6ICIiLAogICAgImVuIjogIiIKICB9LAogICJpY29ucyI6ICJhc3NldHMvaWNvbi5zdmciLAogICJ0YXJnZXRNb2RlbHMiOiAiYWxsIiwKICAidGFyZ2V0Q2F0ZWdvcnlzIjogImFsbCIsCiAgImNvbnRyaWJ1dGVzIjogWwogICAgewogICAgICAicG9pbnQiOiAidG9vbGJhciIsCiAgICAgICJpY29uIjogImFzc2V0cy9pY29uLnN2ZyIsCiAgICAgICJsYWJlbCI6IHsgImtvIjogIl9fUExVR0lOX05BTUVfXyIsICJlbiI6ICJfX1BMVUdJTl9OQU1FX18iIH0sCiAgICAgICJ1aSI6ICJjb250ZW50IiwKICAgICAgIm9wZW5zIjogInBvcG92ZXIiCiAgICB9CiAgXSwKICAicnVudGltZSI6IHsgInR5cGUiOiAiX19SVU5USU1FX1RZUEVfXyIsICJlbnRyeSI6ICJtYWluLnB5IiB9Cn0K","common/package.json":"ewogICJuYW1lIjogIl9fUExVR0lOX0lEX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAicHJpdmF0ZSI6IHRydWUsCiAgInR5cGUiOiAibW9kdWxlIiwKICAiZGVwZW5kZW5jaWVzIjogewogICAgIkByYWluYm93LXJvYm90aWNzL3BsdWdpbi11aSI6ICJfX1JCX1ZFUlNJT05fXyIKICB9LAogICJkZXZEZXBlbmRlbmNpZXMiOiB7CiAgICAiQHRhaWx3aW5kY3NzL3ZpdGUiOiAiXjQuMS4wIiwKICAgICJAcmFpbmJvdy1yb2JvdGljcy9tdXNjYXQtcGx1Z2luLWtpdCI6ICJfX1JCX1ZFUlNJT05fXyIsCiAgICAiQHJhaW5ib3ctcm9ib3RpY3MvcHJldmlldy1ob3N0IjogIl9fUkJfVkVSU0lPTl9fIiwKICAgICJAdHlwZXMvcmVhY3QiOiAiXjE5LjAuMTAiLAogICAgIkB0eXBlcy9yZWFjdC1kb20iOiAiXjE5LjAuNCIsCiAgICAiQHZpdGVqcy9wbHVnaW4tcmVhY3QiOiAiXjQuMC4wIiwKICAgICJ0YWlsd2luZGNzcyI6ICJeNC4xLjAiLAogICAgInR5cGVzY3JpcHQiOiAiXjUuOC4wIiwKICAgICJ2aXRlIjogIl42LjAuMCIKICB9Cn0K","common/py/main.py":"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","common/requirements.txt":"cmFpbmJvdy1yYi1zZGs9PTAuMC45LmRldjQzCnJhaW5ib3ctcmItZmxhdC1idWZmZXJzPT0wLjAuOS5kZXY0MwpyYWluYm93LXJiLXplbm9oPT0wLjAuOS5kZXY0MwpyZXF1ZXN0cz09Mi4zNC4yCg==","common/tsconfig.json":"ewogICJjb21waWxlck9wdGlvbnMiOiB7CiAgICAidGFyZ2V0IjogIkVTTmV4dCIsCiAgICAibW9kdWxlIjogIkVTTmV4dCIsCiAgICAibW9kdWxlUmVzb2x1dGlvbiI6ICJidW5kbGVyIiwKICAgICJqc3giOiAicmVhY3QtanN4IiwKICAgICJzdHJpY3QiOiB0cnVlLAogICAgInNraXBMaWJDaGVjayI6IHRydWUsCiAgICAibm9FbWl0IjogdHJ1ZSwKICAgICJsaWIiOiBbIkRPTSIsICJET00uSXRlcmFibGUiLCAiRVNOZXh0Il0KICB9LAogICJpbmNsdWRlIjogWyJ1aSJdCn0K","common/ui/content.tsx":"import { useMemo, useState } from "react";
import {
  RBCheckBox,
  RBLabelButton,
  RBRadioBox,
  RBSelectBox,
  RBSlider,
  RBSwitch,
  RBTextArea,
  RBTextField,
  RBTextInput,
  Option
} from "@rainbow-robotics/plugin-ui/react";
import { useRb } from "@rainbow-robotics/plugin-ui/sdk";

type RunMode = "inspect" | "assist" | "auto";

const MODE_OPTIONS: Array<{ label: string; value: RunMode }> = [
  { label: "Inspect", value: "inspect" },
  { label: "Assist", value: "assist" },
  { label: "Auto", value: "auto" },
];

const TASK_OPTIONS = [
  { label: "Publish status", value: "publish" },
  { label: "Run grip action", value: "grip" },
  { label: "Save snapshot", value: "snapshot" },
];

// Export your UI as the default. The host mounts it (dev: with HMR).
export default function App() {
  const rb = useRb();
  const [targetName, setTargetName] = useState("demo_target");
  const [gripType, setGripType] = useState<string>();
  const [gripWidth, setGripWidth] = useState(24);
  const [speed, setSpeed] = useState(45);
  const [mode, setMode] = useState<RunMode>("assist");
  const [enabled, setEnabled] = useState(true);
  const [tasks, setTasks] = useState<Array<string>>(["publish", "grip"]);
  const [memo, setMemo] = useState("Use this area for operator notes.");

  const payload = useMemo(
    () => ({
      targetName,
      gripWidth,
      speed,
      mode,
      enabled,
      tasks,
      memo,
    }),
    [targetName, gripWidth, speed, mode, enabled, tasks, memo],
  );

  const showRequestError = (error: unknown) => {
    const message = error instanceof Error ? error.message : "Request failed";
    rb.toast({ type: "danger", message });
  };

  const runAction = async () => {
    try {
      await rb.action("grip", payload);
      rb.toast({ type: "success", message: `Sent ${targetName}` });
    } catch (error) {
      showRequestError(error);
    }
  };

  const publishPreview = async () => {
    try {
      const isConfirm = await rb.confirm({
        message: "Are you sure publish?",
        buttonText: { yes: "confirm", no: "cancel" },
      });

      if (isConfirm) {
        await rb.pub("event", payload);
      }
    } catch (error) {
      showRequestError(error);
    }
  };

  return (
    <div className="max-h-[70vh] w-[420px] p-4 max-w-full overflow-y-auto bg-bg-elevated text-fg-default">
      <div className="flex flex-col gap-5">
        <header>
          <div className="flex items-center justify-between gap-12">
            <div>
              <h2 className="typo-heading-xs-semibold">Demo Control</h2>
              <p className="typo-body-xs2-normal text-fg-subtle">
                Input patterns for Muscat plugin UIs
              </p>
            </div>
            <RBSwitch
              checked={enabled}
              onCheckedChange={(next: boolean) => {
                setEnabled(next);
                rb.toast({message: next ? "Plugin enabled" : "Plugin paused"});
              }}
            />
          </div>
        </header>

        <section className="flex flex-col gap-4">
          <RBTextField
            label="Target name"
            required
            helperText="Used as the backend action target."
          >
            <RBTextInput
              name="targetName"
              value={targetName}
              placeholder="target id"
              handleChange={(value) => setTargetName(String(value))}
            />
          </RBTextField>

          <RBTextField label="Select Grip">
            <RBSelectBox  className="w-full" value={gripType} handleChange={setGripType}>
              <Option value="A">A Grip</Option>
              <Option value="B">B Grip</Option>
            </RBSelectBox>
          </RBTextField>

          <div className="flex gap-4">
            <RBTextField className="flex-1" label="Grip width" helperText="0-100 mm">
              <RBTextInput
                className="w-full"
                name="gripWidth"
                type="number"
                value={gripWidth}
                validate={(value: number) =>
                  Math.max(0, Math.min(100, Number(value) || 0))
                }
                handleChange={(value) => setGripWidth(Number(value) || 0)}
              />
            </RBTextField>

            <RBTextField className="flex-1" label="Speed" helperText={`${speed}%`}>
              <div className="flex items-center px-2">
                <RBSlider
                  value={[speed]}
                  min={0}
                  max={100}
                  step={5}
                  onValueChange={(values: number[]) =>
                    setSpeed(values[0] ?? 0)
                  }
                />
              </div>
            </RBTextField>
          </div>
        </section>

        <section className="mb-4">
          <RBTextField label="Run mode">
            <div className="flex justify-between border-1 border-border-subtle rounded-sm p-2">
            {MODE_OPTIONS.map((item) => (
              <RBRadioBox
                key={item.value}
                name="mode"
                checkValue={item.value}
                value={mode}
                handleChange={(value) => setMode(value as RunMode)}
              >
                {item.label}
              </RBRadioBox>
            ))}
          </div>
          </RBTextField>
        </section>

        <section className="mb-4">
          <RBTextField label="Tasks">
            <div className="flex justify-between border-1 border-border-subtle rounded-sm p-2">
              {TASK_OPTIONS.map((item) => (
                <RBCheckBox
                  key={item.value}
                  name="tasks"
                  checkValue={item.value}
                  value={tasks}
                  handleChange={(value) =>
                    setTasks(Array.isArray(value) ? value.map(String) : [])
                  }
                >
                  {item.label}
                </RBCheckBox>
              ))}
            </div>
          </RBTextField>
          
        </section>

        <RBTextField label="Memo">
          <RBTextArea
            name="memo"
            value={memo}
            maxLength={120}
            rows={4}
            handleChange={setMemo}
          />
        </RBTextField>

        <footer className="grid grid-cols-2 gap-8 pt-4">
          <RBLabelButton variant="outlined" onClick={publishPreview}>
            Publish
          </RBLabelButton>
          <RBLabelButton onClick={runAction} disabled={!enabled}>
            Run Action
          </RBLabelButton>
        </footer>
      </div>
    </div>
  );
}
","common/ui/style.css":"QGxheWVyIHRoZW1lLCB1dGlsaXRpZXM7CgpAaW1wb3J0ICJ0YWlsd2luZGNzcy90aGVtZS5jc3MiIGxheWVyKHRoZW1lKTsKQGltcG9ydCAidGFpbHdpbmRjc3MvdXRpbGl0aWVzLmNzcyIgbGF5ZXIodXRpbGl0aWVzKTsKCkBzb3VyY2UgIi4vKiovKi57dHMsdHN4fSI7Cg==","common/vite.config.ts":"aW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSAidml0ZSI7CmltcG9ydCB0YWlsd2luZGNzcyBmcm9tICJAdGFpbHdpbmRjc3Mvdml0ZSI7CmltcG9ydCB7IG11c2NhdCB9IGZyb20gIkByYWluYm93LXJvYm90aWNzL211c2NhdC1wbHVnaW4ta2l0L3ZpdGUiOwoKLy8gVGhlIG11c2NhdCgpIHByZXNldCB3aXJlcyByZWFjdC1yZWZyZXNoLCB1aS8gZW50cnkgZGlzY292ZXJ5LCBhbmQgbWFya3MgdGhlCi8vIGhvc3QtcHJvdmlkZWQgcnVudGltZSAocGx1Z2luLXVpLCByZWFjdCkgYXMgZXh0ZXJuYWwuIEFkZCB5b3VyIG93biBwbHVnaW5zIG9yCi8vIG92ZXJyaWRlcyBoZXJlIGFzIG5lZWRlZC4KZXhwb3J0IGRlZmF1bHQgZGVmaW5lQ29uZmlnKHsKICBwbHVnaW5zOiBbdGFpbHdpbmRjc3MoKSwgbXVzY2F0KCldLAp9KTsK","cpp/cpp/CMakeLists.txt":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fIENYWCkKCnNldChDTUFLRV9DWFhfU1RBTkRBUkQgMTcpCnNldChDTUFLRV9DWFhfU1RBTkRBUkRfUkVRVUlSRUQgT04pCgojIFRoZSBleGVjdXRhYmxlIG5hbWUgbXVzdCBtYXRjaCBydW50aW1lLmVudHJ5IGluIG1hbmlmZXN0Lmpzb24uCmFkZF9leGVjdXRhYmxlKF9fUExVR0lOX1NMVUdfXyBtYWluLmNwcCkKCiMgVE9ETyhjcHAtc2RrKTogbGluayB0aGUgcmFpbmJvdyBjcHAgU0RLIGR5bmFtaWNhbGx5ICh0aGUgcm9ib3QgcHJvdmlkZXMgdGhlCiMgLnNvIGF0IHJ1bnRpbWUg4oCUIGRvIE5PVCBidW5kbGUvc3RhdGljLWxpbmsgaXQpLiBPbmNlIHRoZSBTREsgc2hpcHMgYW4gYXB0CiMgcGFja2FnZSB3aXRoIENNYWtlIGNvbmZpZywgZW5hYmxlOgojICAgZmluZF9wYWNrYWdlKHJhaW5ib3dfY3BwX3NkayBSRVFVSVJFRCkKIyAgIHRhcmdldF9saW5rX2xpYnJhcmllcyhfX1BMVUdJTl9TTFVHX18gUFJJVkFURSByYWluYm93OjpjcHBfc2RrKQo=","cpp/cpp/main.cpp":"Ly8gX19QTFVHSU5fTkFNRV9fIOKAlCBDKysgcGx1Z2luIGJhY2sgZW5kLgovLwovLyBUaGUgQysrIHBsdWdpbiBTREsgaXMgbm90IGF2YWlsYWJsZSB5ZXQsIHNvIHRoaXMgaXMgYSBidWlsZC9ydW4gc2tlbGV0b24uCi8vIE9uY2UgdGhlIFNESyBsYW5kcywgY29ubmVjdCB0byB0aGUgcGx1Z2luIGdhdGV3YXkgaGVyZSAodGhlIGhvc3QgZXhwb3NlcyBpdAovLyBhdCB0aGUgUkJfUExVR0lOX0dBVEVXQVkgLyBSQl9QTFVHSU5fSUQgZW52aXJvbm1lbnQgdmFyaWFibGVzKSBhbmQgd2lyZSB1cAovLyBwdWIgLyBzdWIgLyBzZXJ2ZSwgbWlycm9yaW5nIHRoZSBQeXRob24gcmFpbmJvdy5yYl9zZGsuUkJQbHVnaW5DYWxsIEFQSS4KCiNpbmNsdWRlIDxjaHJvbm8+CiNpbmNsdWRlIDxjc3RkbGliPgojaW5jbHVkZSA8aW9zdHJlYW0+CiNpbmNsdWRlIDxzdHJpbmc+CiNpbmNsdWRlIDx0aHJlYWQ+CgppbnQgbWFpbigpIHsKICBjb25zdCBjaGFyKiBwbHVnaW5faWQgPSBzdGQ6OmdldGVudigiUkJfUExVR0lOX0lEIik7CiAgc3RkOjpjb3V0IDw8ICJbX19QTFVHSU5fTkFNRV9fXSBiYWNrZW5kIHJlYWR5IgogICAgICAgICAgICA8PCAocGx1Z2luX2lkID8gc3RkOjpzdHJpbmcoIiAoaWQ9IikgKyBwbHVnaW5faWQgKyAiKSIgOiAiIikKICAgICAgICAgICAgPDwgc3RkOjplbmRsOwoKICAvLyBUT0RPOiBjb25uZWN0IHRvIHRoZSBwbHVnaW4gZ2F0ZXdheSBhbmQgcmVnaXN0ZXIgaGFuZGxlcnMgb25jZSB0aGUKICAvLyAgICAgICBDKysgU0RLIGlzIGF2YWlsYWJsZS4gRm9yIG5vdywganVzdCBrZWVwIHRoZSBwcm9jZXNzIGFsaXZlLgogIHdoaWxlICh0cnVlKSB7CiAgICBzdGQ6OnRoaXNfdGhyZWFkOjpzbGVlcF9mb3Ioc3RkOjpjaHJvbm86OnNlY29uZHMoMSkpOwogIH0KICByZXR1cm4gMDsKfQo=","ros2/ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/__init__.py":"","ros2/ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/node.py":"aW1wb3J0IHJjbHB5CmZyb20gcmNscHkubm9kZSBpbXBvcnQgTm9kZQpmcm9tIHJhaW5ib3cucmJfc2RrIGltcG9ydCBSQk1hbmlwdWxhdGVTREsgICMgUHlQSTogcmFpbmJvdy1yYi1zZGsKCgpzZGsgPSBSQk1hbmlwdWxhdGVTREsoKQoKCmNsYXNzIF9fUExVR0lOX0NMQVNTX19Ob2RlKE5vZGUpOgogICAgZGVmIF9faW5pdF9fKHNlbGYpOgogICAgICAgIHN1cGVyKCkuX19pbml0X18oIl9fUExVR0lOX1NMVUdfX19ub2RlIikKICAgICAgICBzZWxmLmdldF9sb2dnZXIoKS5pbmZvKCJfX1BMVUdJTl9OQU1FX18gbm9kZSBzdGFydGVkIikKICAgICAgICAjIHNkayBpcyBhdmFpbGFibGUgaGVyZSDigJQgdXNlIGl0IGFsb25nc2lkZSBST1MyIHRvcGljcyBhcyBuZWVkZWQKCgpkZWYgbWFpbihhcmdzPU5vbmUpOgogICAgcmNscHkuaW5pdChhcmdzPWFyZ3MpCiAgICBub2RlID0gX19QTFVHSU5fQ0xBU1NfX05vZGUoKQogICAgcmNscHkuc3Bpbihub2RlKQogICAgbm9kZS5kZXN0cm95X25vZGUoKQogICAgcmNscHkuc2h1dGRvd24oKQoKCmlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiAgICBtYWluKCkK","ros2/ros2_ws/src/__PLUGIN_SLUG__/package.xml":"PD94bWwgdmVyc2lvbj0iMS4wIj8+CjxwYWNrYWdlIGZvcm1hdD0iMyI+CiAgPG5hbWU+X19QTFVHSU5fU0xVR19fPC9uYW1lPgogIDx2ZXJzaW9uPjAuMC4xPC92ZXJzaW9uPgogIDxkZXNjcmlwdGlvbj5fX1BMVUdJTl9OQU1FX18gUk9TMiBub2RlPC9kZXNjcmlwdGlvbj4KICA8bWFpbnRhaW5lciBlbWFpbD0idG9kb0BleGFtcGxlLmNvbSI+bWFpbnRhaW5lcjwvbWFpbnRhaW5lcj4KICA8bGljZW5zZT5Qcm9wcmlldGFyeTwvbGljZW5zZT4KICA8ZGVwZW5kPnJjbHB5PC9kZXBlbmQ+CiAgPGV4cG9ydD48YnVpbGRfdHlwZT5hbWVudF9weXRob248L2J1aWxkX3R5cGU+PC9leHBvcnQ+CjwvcGFja2FnZT4K","ros2/ros2_ws/src/__PLUGIN_SLUG__/resource/__PLUGIN_SLUG__":"","ros2/ros2_ws/src/__PLUGIN_SLUG__/setup.py":"ZnJvbSBzZXR1cHRvb2xzIGltcG9ydCBzZXR1cAoKcGFja2FnZV9uYW1lID0gIl9fUExVR0lOX1NMVUdfXyIKCnNldHVwKAogICAgbmFtZT1wYWNrYWdlX25hbWUsCiAgICB2ZXJzaW9uPSIwLjAuMSIsCiAgICBwYWNrYWdlcz1bcGFja2FnZV9uYW1lXSwKICAgIGRhdGFfZmlsZXM9WwogICAgICAgICgic2hhcmUvYW1lbnRfaW5kZXgvcmVzb3VyY2VfaW5kZXgvcGFja2FnZXMiLCBbInJlc291cmNlLyIgKyBwYWNrYWdlX25hbWVdKSwKICAgICAgICAoInNoYXJlLyIgKyBwYWNrYWdlX25hbWUsIFsicGFja2FnZS54bWwiXSksCiAgICBdLAogICAgaW5zdGFsbF9yZXF1aXJlcz1bInNldHVwdG9vbHMiXSwKICAgIHppcF9zYWZlPVRydWUsCiAgICBlbnRyeV9wb2ludHM9ewogICAgICAgICJjb25zb2xlX3NjcmlwdHMiOiBbIl9fUExVR0lOX1NMVUdfX19ub2RlID0gX19QTFVHSU5fU0xVR19fLm5vZGU6bWFpbiJdLAogICAgfSwKKQo=","ros2-cpp/ros2_ws/src/__PLUGIN_SLUG__/CMakeLists.txt":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fKQoKaWYoTk9UIENNQUtFX0NYWF9TVEFOREFSRCkKICBzZXQoQ01BS0VfQ1hYX1NUQU5EQVJEIDE3KQplbmRpZigpCgpmaW5kX3BhY2thZ2UoYW1lbnRfY21ha2UgUkVRVUlSRUQpCmZpbmRfcGFja2FnZShyY2xjcHAgUkVRVUlSRUQpCgphZGRfZXhlY3V0YWJsZShfX1BMVUdJTl9TTFVHX19fbm9kZSBzcmMvbm9kZS5jcHApCmFtZW50X3RhcmdldF9kZXBlbmRlbmNpZXMoX19QTFVHSU5fU0xVR19fX25vZGUgcmNsY3BwKQoKaW5zdGFsbChUQVJHRVRTIF9fUExVR0lOX1NMVUdfX19ub2RlCiAgREVTVElOQVRJT04gbGliLyR7UFJPSkVDVF9OQU1FfSkKCmFtZW50X3BhY2thZ2UoKQo=","ros2-cpp/ros2_ws/src/__PLUGIN_SLUG__/package.xml":"PD94bWwgdmVyc2lvbj0iMS4wIj8+CjxwYWNrYWdlIGZvcm1hdD0iMyI+CiAgPG5hbWU+X19QTFVHSU5fU0xVR19fPC9uYW1lPgogIDx2ZXJzaW9uPjAuMC4xPC92ZXJzaW9uPgogIDxkZXNjcmlwdGlvbj5fX1BMVUdJTl9OQU1FX18gUk9TMiBub2RlIChyY2xjcHApPC9kZXNjcmlwdGlvbj4KICA8bWFpbnRhaW5lciBlbWFpbD0idG9kb0BleGFtcGxlLmNvbSI+bWFpbnRhaW5lcjwvbWFpbnRhaW5lcj4KICA8bGljZW5zZT5Qcm9wcmlldGFyeTwvbGljZW5zZT4KICA8YnVpbGR0b29sX2RlcGVuZD5hbWVudF9jbWFrZTwvYnVpbGR0b29sX2RlcGVuZD4KICA8ZGVwZW5kPnJjbGNwcDwvZGVwZW5kPgogIDxleHBvcnQ+PGJ1aWxkX3R5cGU+YW1lbnRfY21ha2U8L2J1aWxkX3R5cGU+PC9leHBvcnQ+CjwvcGFja2FnZT4K","ros2-cpp/ros2_ws/src/__PLUGIN_SLUG__/src/node.cpp":"Ly8gX19QTFVHSU5fTkFNRV9fIOKAlCBST1MyIG5vZGUgKHJjbGNwcCkuCi8vCi8vIFRoZSBub2RlIGlzIGxhdW5jaGVkIHdpdGggYC0tcm9zLWFyZ3MgLXIgX19uczo9L3tzbHVnfWAgYXV0b21hdGljYWxseSBieQovLyBkZXY6YmFjay4gUk9TMiB0b3BpY3MgYXJlIGJyaWRnZWQgdG8gdGhlIHBsdWdpbiBjb21tdW5pY2F0aW9uIGxheWVyLCBzbyBhCi8vIHBsYWluIHJjbGNwcCBub2RlIGlzIGFsbCB5b3UgbmVlZCDigJQgcmVsYXRpdmUgdG9waWMgbmFtZXMgZ2V0IHRoZSBuYW1lc3BhY2UKLy8gcHJlZml4IGFwcGxpZWQgYXV0b21hdGljYWxseS4KI2luY2x1ZGUgInJjbGNwcC9yY2xjcHAuaHBwIgoKY2xhc3MgX19QTFVHSU5fQ0xBU1NfX05vZGUgOiBwdWJsaWMgcmNsY3BwOjpOb2RlIHsKcHVibGljOgogIF9fUExVR0lOX0NMQVNTX19Ob2RlKCkgOiBOb2RlKCJfX1BMVUdJTl9TTFVHX19fbm9kZSIpIHsKICAgIFJDTENQUF9JTkZPKHRoaXMtPmdldF9sb2dnZXIoKSwgIl9fUExVR0lOX05BTUVfXyBub2RlIHN0YXJ0ZWQiKTsKICAgIC8vIGNyZWF0ZSBwdWJsaXNoZXJzIC8gc3Vic2NyaWJlcnMgLyBzZXJ2aWNlcyBoZXJlCiAgfQp9OwoKaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KSB7CiAgcmNsY3BwOjppbml0KGFyZ2MsIGFyZ3YpOwogIHJjbGNwcDo6c3BpbihzdGQ6Om1ha2Vfc2hhcmVkPF9fUExVR0lOX0NMQVNTX19Ob2RlPigpKTsKICByY2xjcHA6OnNodXRkb3duKCk7CiAgcmV0dXJuIDA7Cn0K","docker/Dockerfile.bridge":"IyBTb2NrZXQuSU8gYnJpZGdlIGNvbnRhaW5lciDigJQgdGhlIGZyb250ZW5kIChwcmV2aWV3LWhvc3QpIGFuZCB0aGUgYmFja2VuZAojIGNvbnRhaW5lciByZW5kZXp2b3VzIGhlcmUgZHVyaW5nIGBtdXNjYXQtcGsgZGV2YC4KIyAgIC0gZnJvbnRlbmQgKGhvc3QpICDihpIgcHVibGlzaGVkIHBvcnQgbG9jYWxob3N0OjEwMDAwCiMgICAtIGJhY2tlbmQgY29udGFpbmVyIOKGkiBzaGFyZXMgdGhpcyBjb250YWluZXIncyBuZXRucyAoLS1uZXR3b3JrIGNvbnRhaW5lcjopLAojICAgICAgICAgICAgICAgICAgICAgICAgIHNvIGl0IHJlYWNoZXMgdGhlIGJyaWRnZSBhdCBsb2NhbGhvc3Q6MTAwMDAgdG9vCiMgQnVpbGQgY29udGV4dCBpcyB0aGUgYGNsaS9gIGRpciBzbyBpdCBjYW4gY29weSBzcmMvc29ja2V0QnJpZGdlLm1qcy4KRlJPTSBub2RlOjIwLXNsaW0KTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKV09SS0RJUiAvYnJpZGdlCkNPUFkgZG9ja2VyL2JyaWRnZS1wYWNrYWdlLmpzb24gcGFja2FnZS5qc29uClJVTiBucG0gaW5zdGFsbCAtLW9taXQ9ZGV2IC0tbm8tYXVkaXQgLS1uby1mdW5kCgpDT1BZIHNyYy9zb2NrZXRCcmlkZ2UubWpzIC4vc29ja2V0QnJpZGdlLm1qcwoKRVhQT1NFIDEwMDAwCkNNRCBbIm5vZGUiLCAic29ja2V0QnJpZGdlLm1qcyJdCg==","docker/Dockerfile.cpp":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgcHVyZSBDKysgcGx1Z2luIGJhY2sgZW5kLgojIE1hdGNoZXMgdGhlIE11c2NhdCByb2JvdCBiYWNrZW5kIE9TIChVYnVudHUgMjQuMDQpIHNvIHRoZSBjb21waWxlZCBiaW5hcnkKIyBpcyBBQkktY29tcGF0aWJsZSB3aXRoIHRoZSByb2JvdC4gVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCBhbmQgYGJ1aWxkYAojIOKAlCBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUC4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIGJ1aWxkLWVzc2VudGlhbCBcCiAgICAgIGNtYWtlIFwKICAgICYmIHJtIC1yZiAvdmFyL2xpYi9hcHQvbGlzdHMvKgoKIyBUT0RPKGNwcC1zZGspOiBpbnN0YWxsIHRoZSByYWluYm93IGNwcCBTREsgKGRldiBwYWNrYWdlKSBoZXJlLCBwaW5uZWQgdG8gdGhlCiMgcm9ib3QncyB2ZXJzaW9uLCBzbyBwbHVnaW5zIGJ1aWxkL2xpbmsgYWdhaW5zdCB0aGUgc2FtZSBTREsgYXMgcHJvZHVjdGlvbi4KIyBQbGFuOiBhcHQgcGFja2FnZSArIGR5bmFtaWMgbGluayAodGhlIHJvYm90IHByb3ZpZGVzIHRoZSAuc28gYXQgcnVudGltZTsKIyB3ZSBkbyBOT1QgYnVuZGxlIGl0IGludG8gdGhlIHBsdWdpbiBiaW5hcnkpLiBlLmcuOgojICAgUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSByYWluYm93LWNwcC1zZGstZGV2PTxyb2JvdC12ZXJzaW9uPiBcCiMgICAgICAgJiYgcm0gLXJmIC92YXIvbGliL2FwdC9saXN0cy8qCgpXT1JLRElSIC9wbHVnaW4KCkNNRCBbImJhc2giXQo=","docker/Dockerfile.dev":"IyBEZXYtb25seSBjb250YWluZXIgZm9yIHRoZSBST1MyIHBsdWdpbiBiYWNrIGVuZC4KIyBNYXRjaGVzIHRoZSBNdXNjYXQgcm9ib3QgYmFja2VuZDogUk9TMiBKYXp6eSArIFB5dGhvbiAzLjEyIChVYnVudHUgMjQuMDQpLgojIFVzZWQgYnkgYG11c2NhdC1wayBkZXY6YmFja2Ag4oCUIE5PVCBzaGlwcGVkIGluIHRoZSBwbHVnaW4gWklQLgpGUk9NIHJvczpqYXp6eS1yb3MtYmFzZQpMQUJFTCBjb20ucmFpbmJvdy1yb2JvdGljcy5tdXNjYXQtcGs9InRydWUiCgpSVU4gYXB0LWdldCB1cGRhdGUgJiYgYXB0LWdldCBpbnN0YWxsIC15IC0tbm8taW5zdGFsbC1yZWNvbW1lbmRzIFwKICAgICAgcHl0aG9uMy1waXAgXAogICAgICBweXRob24zLWNvbGNvbi1jb21tb24tZXh0ZW5zaW9ucyBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyoKCldPUktESVIgL3BsdWdpbgoKQ01EIFsiYmFzaCJdCg==","docker/Dockerfile.python":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgUHl0aG9uIHBsdWdpbiBiYWNrIGVuZC4KIyBNYXRjaGVzIHRoZSBNdXNjYXQgcm9ib3QgYmFja2VuZDogVWJ1bnR1IDI0LjA0ICsgUHl0aG9uIDMuMTIuCiMgVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCAoaG90LXJlbG9hZCkgYW5kIGBtdXNjYXQtcGsgYnVpbGRgIChsb2NrICsgd2hlZWwgdmVuZG9yKS4KIyBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUCDigJQgdGhlIHJvYm90IGluc3RhbGxzIGRlcHMgZnJvbSBkaXN0L3doZWVscy8gb2ZmbGluZS4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIHB5dGhvbjMgXAogICAgICBweXRob24zLXBpcCBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyogXAogICAgJiYgcGlwMyBpbnN0YWxsIHV2PT0wLjguMTggLS1icmVhay1zeXN0ZW0tcGFja2FnZXMKCiMgVE9ETyhjcHAtc2RrKTogdGhlIFB5dGhvbiBTREsgaXMgYSBweWJpbmQgd3JhcHBlciBvdmVyIHRoZSBjcHAgU0RLLCBzbyB0aGUKIyBjcHAgU0RLIHNoYXJlZCBsaWIgbXVzdCBiZSBwcmVzZW50IGZvciB0aGUgcHl0aG9uIG1vZHVsZSB0byBsb2FkLiBJbnN0YWxsIHRoZQojIHJhaW5ib3cgY3BwIFNESyAoYXB0LCBwaW5uZWQgdG8gdGhlIHJvYm90J3MgdmVyc2lvbikgaGVyZSBvbmNlIGl0IGV4aXN0cy4KCldPUktESVIgL3BsdWdpbgoKQ01EIFsiYmFzaCJdCg==","docker/bridge-package.json":"ewogICJuYW1lIjogIm11c2NhdC1way1icmlkZ2UiLAogICJwcml2YXRlIjogdHJ1ZSwKICAidHlwZSI6ICJtb2R1bGUiLAogICJkZXBlbmRlbmNpZXMiOiB7CiAgICAic29ja2V0LmlvIjogIl40LjguMSIKICB9Cn0K"};
+export const TEMPLATES = {"common/.mcp.json":"ewogICJtY3BTZXJ2ZXJzIjogewogICAgIm11c2NhdCI6IHsKICAgICAgImNvbW1hbmQiOiAibXVzY2F0LXBrIiwKICAgICAgImFyZ3MiOiBbIm1jcCJdCiAgICB9CiAgfQp9Cg==","common/README.md":"# __PLUGIN_NAME__

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 build      # build + distributable ZIP
```

---

## Project structure

```
__PLUGIN_DIR__/
├─ ui/
│   ├─ content.tsx      # plugin UI entry point
│   └─ style.css        # plugin styles auto-loaded by muscat()
├─ py/
│   └─ main.py          # Python backend entry point
├─ assets/
│   └─ icon.svg         # icon referenced from manifest
├─ manifest.json        # metadata, contribution points, runtime config
├─ README.md            # this file (copied to dist/ on build)
└─ requirements.txt     # Python deps (auto-pinned to latest on build)
```

> ROS2 plugins additionally include a `ros2_ws/` directory.

---

## Frontend (`ui/content.tsx`)

### JavaScript dependencies

`muscat-pk build` runs this plugin project's own Vite build. Vite resolves
imports from installed `node_modules`; it does not care whether a package is
listed under `dependencies` or `devDependencies`, but the package must be
installed.

Do not run a production-only install such as `npm install --omit=dev` before
building the plugin UI, because build tools like `vite`, `typescript`,
`tailwindcss`, `@tailwindcss/vite`, `sass`, or `less` are usually
`devDependencies`.

The scaffold keeps this split:

| package kind | examples | why |
|---|---|---|
| `dependencies` | `@rainbow-robotics/plugin-ui`, UI libraries imported by plugin source | Author-facing APIs used by `ui/*.tsx` |
| `devDependencies` | `vite`, `typescript`, `tailwindcss`, `@tailwindcss/vite`, `sass`, `less` | Build/dev tools needed before `dist/*.js` is produced |

The built plugin ZIP does not include `package.json` or `node_modules`. For
production, Muscat provides `@rainbow-robotics/plugin-ui`, React, and ReactDOM
through the host import map; plugin UI build output imports those as host
externals.

### Styles

`muscat()` automatically loads `ui/style.{css,scss,sass,less}` (or
`ui/styles.{css,scss,sass,less}`) for every UI entry, plus
`ui/{entry}.{css,scss,sass,less}` for a matching entry-specific stylesheet. You
do not need to import CSS from every `.tsx` file.

The scaffold uses Tailwind's theme/utilities layers only, so plugin utilities
are generated from files under `ui/` without applying Tailwind preflight resets
to the host page.

Built CSS selectors are scoped under the current plugin id
(`[data-muscat-plugin-id="..."]`). CSS-in-JS libraries such as Emotion work
normally, but global styles should be scoped by the author.

#### Tailwind

This template enables Tailwind in `vite.config.ts`:

```ts
import { defineConfig } from "vite";
import tailwindcss from "@tailwindcss/vite";
import { muscat } from "@rainbow-robotics/muscat-plugin-kit/vite";

export default defineConfig({
  plugins: [tailwindcss(), muscat()],
});
```

The default `ui/style.css` uses Tailwind theme/utilities only, not preflight:

```css
@layer theme, utilities;

@import "tailwindcss/theme.css" layer(theme);
@import "tailwindcss/utilities.css" layer(utilities);

@source "./**/*.{ts,tsx}";
```

#### SCSS, Sass, and Less

Install the preprocessor package, then create one of the auto-loaded style files.

```bash
npm i -D sass
```

```scss
/* ui/style.scss */
$accent: #3b82f6;

.panel {
  border: 1px solid color-mix(in srgb, $accent 40%, transparent);

  &__title {
    color: $accent;
  }
}
```

For Less, install `less` and use `ui/style.less`.

#### Emotion

Emotion dependencies may be in `dependencies` or `devDependencies`; Vite can
bundle them when they are installed and imported by the plugin.

For `styled`, no Vite config change is needed:

```bash
npm i @emotion/react @emotion/styled
```

```tsx
import styled from "@emotion/styled";

const Panel = styled.div({
  display: "grid",
  gap: 12,
});
```

For Emotion's `css` prop, pass React plugin options through `muscat()` and add
`jsxImportSource` to `tsconfig.json`:

```bash
npm i @emotion/react @emotion/styled
npm i -D @emotion/babel-plugin
```

```ts
// vite.config.ts
import { defineConfig } from "vite";
import tailwindcss from "@tailwindcss/vite";
import { muscat } from "@rainbow-robotics/muscat-plugin-kit/vite";

export default defineConfig({
  plugins: [
    tailwindcss(),
    muscat({
      react: {
        jsxImportSource: "@emotion/react",
        babel: {
          plugins: ["@emotion/babel-plugin"],
        },
      },
    }),
  ],
});
```

```json
{
  "compilerOptions": {
    "jsxImportSource": "@emotion/react"
  }
}
```

Emotion `Global` writes global CSS at runtime, so scope it manually or avoid it
inside plugins.

### 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({ title?, message, type?, actionLabel?, handleActionClick?, closeOnActionClick?, duration?, onClose? })` | Show a host toast notification. `message` accepts a string or `ReactElement`. `type` can be `"info"`, `"danger"`, `"warning"`, `"caution"`, or `"success"` |
| `rb.alert({ title?, message, buttonText? })`                                                                       | Show a host alert dialog. Resolves when the dialog is closed                                                                                               |
| `rb.confirm({ title?, message, buttonText? })`                                                                     | Show a host confirmation dialog. `buttonText` accepts `{ yes, no }`. Resolves to `true` or `false`                                                         |
| `rb.prompt({ title?, message, value?, placeholder?, buttonText? })`                                                | Show a host prompt dialog. `buttonText` accepts `{ yes, no }`. Resolves to the entered string or `undefined`                                               |

Topic names passed to `pub`, `sub`, `action`, and `serve` are isolated per plugin.


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

const ok = await rb.confirm({
  title: "Run",
  message: "Start the backend action?",
});
if (ok) {
  await rb.action("run");
}
```

### Saving and restoring form data (`useRbFormData` / `useRbSave`)

If the host embeds your plugin in a form it owns (e.g. a program step editor
with its own Save button), it can hand your plugin previously-saved values and
pull the current values back out when the user saves. The host — not the
plugin — persists the data (IndexedDB, backend, etc.).

```tsx
import { useState } from "react";
import { useRbFormData, useRbSave } from "@rainbow-robotics/plugin-ui/react";

type GripArgs = { targetName: string; width: number };
const DEFAULTS: GripArgs = { targetName: "", width: 20 };

export default function App() {
  // Previously-saved values, or undefined for a brand-new instance.
  const saved = useRbFormData<GripArgs>();
  const [args, setArgs] = useState<GripArgs>({ ...DEFAULTS, ...saved });

  // Registers a getter the host calls when its Save button is clicked.
  // Always returns the CURRENT values — re-registering on every render keeps
  // the closure fresh, which useRbSave already handles for you.
  useRbSave(() => ({
    args,
    summary: `${args.targetName || "target"} · ${args.width}mm`,
  }));

  return (/* ...form UI reading/writing `args`... */);
}
```

The value returned from `useRbSave` must be JSON-serialisable — the host
persists it as-is. Not every host embeds plugins in a save/restore form; if
yours doesn't, you can skip these hooks entirely.

### UI components

Import Muscat components from `@rainbow-robotics/plugin-ui/react` and export a
React component as the default export. The host mounts that component directly
and provides `useRb()` through context.

```tsx
import { useState } from "react";
import { RBLabelButton, RBSlider, RBSwitch } from "@rainbow-robotics/plugin-ui/react";
import { useRb } from "@rainbow-robotics/plugin-ui/sdk";

export default function App() {
  const rb = useRb();
  const [width, setWidth] = useState(20);
  const [enabled, setEnabled] = useState(true);

  return (
    <div className="flex flex-col gap-4">
      <RBSlider
        value={[width]}
        min={0}
        max={100}
        onValueChange={(values: number[]) => setWidth(values[0] ?? 0)}
      />
      <RBSwitch checked={enabled} onCheckedChange={setEnabled} />
      <RBLabelButton
        disabled={!enabled}
        onClick={() => rb.action("grip", { width })}
      >
        Grip
      </RBLabelButton>
    </div>
  );
}
```

---

## Developing directly on the robot PC

If you're running `muscat-pk dev` **on the robot PC itself**, Muscat is likely already
running its own Socket.IO bridge on port 10000. In that case the CLI detects the port
conflict and asks:

```
⚠ port 10000 is already in use — can't start Socket.IO bridge.
  Proceed without Socket.IO bridge? [y/N]:
```

Answer **y**. Your plugin backend will connect to the Muscat bridge that's already
running instead of starting a new one — exactly what you want when developing on the
robot.

> If you answer **n** (or just press Enter), the CLI exits so you can free the port
> manually and retry.

---

## Backend runtimes

`manifest.json` chooses one backend runtime. `muscat-pk dev` runs backend code in
a Docker container matching the robot environment. Backend code should contain
plugin logic only; it should not start the Muscat bridge or its own copy of the
plugin gateway.

### Which backend pattern? (depends on the contribution point)

**How you control the robot depends on what your plugin contributes** (see
`manifest.json` → `contributes[].point`). Don't mix these up:

| Contribution point | What it is | Backend pattern |
| --- | --- | --- |
| `program.panel` (with `commandInfo`) | Defines a **custom command** the plugin adds to the Program page's rule-based sequence builder. The operator places it into the program tree like any built-in command (Move J, Point, Wait, …); it runs when the program reaches that step. | **`PluginProgramContext`** — integrated with the program's stop/pause and variables. See _Program command backend_ below. |
| `toolbar` / `lnb` / `move.panel` | A live UI panel/popover the operator interacts with directly | Call the robot **SDK directly** (`RBManipulateSDK`, `RBAmrSDK`) from `py/main.py`, or `rb.action(...)` → your backend → SDK. **Not** a program step — there is no stop/pause/variable context. |

Rule of thumb: use `PluginProgramContext` **only** for a `program.panel` command
that runs as part of a program. To move the robot live from a toolbar/move panel,
use the SDK — a program-step context does not apply.

### Frontend-only (`none`)

Use this when the plugin only has UI and calls host services:

```json
{ "runtime": { "type": "none" } }
```

### Python

Python plugins use `py/main.py` and can communicate with the UI through
`rainbow.rb_sdk.RBPluginCall`.

```python
import time
from rainbow.rb_sdk import RBAmrSDK, RBManipulateSDK, RBPluginCall

plugin = RBPluginCall()


plugin.publish("state", {"ready": True})


@plugin.subscribe("event")
def on_ui_event(payload=None):
    print(payload)


@plugin.serve("tool/echo")
def echo(payload=None):
    return {"echo": payload}


def call_frontend():
    res = plugin.call("tool/ping", payload={"hello": "plugin"})
    print(res)


def move_j_example():
    amr = RBAmrSDK()
    manipulate = RBManipulateSDK()
    return manipulate.move.call_move_j(
        robot_model="C500920",
        target={"tar_values": [0, 0, 0, 0, 0, 0], "tar_frame": 0, "tar_unit": 0},
    )


if __name__ == "__main__":
    while True:
        time.sleep(1)
```

#### Program command backend (`program.panel`)

A `program.panel` contribution defines a **custom command** your plugin adds to
the Muscat **Program page**, where the operator builds a robot program as a
rule-based sequence (a program tree). Your command appears alongside the
built-ins (Move J, Point, Wait, …); the operator places it into the tree, and
each time the program executes that step the host calls your backend through
`PluginProgramContext` — receiving the step args, checking for stop/pause,
reading/writing program variables, and signalling completion. This pattern is
**only** for `program.panel`; a toolbar/move-panel plugin uses the SDK directly
instead (see the table above).

```python
"""
Plugin backend main.py example (program.panel command).

manifest.json:
  "runtime": {"type": "python", "entry": "main.py"},
  "contributes": [{
    "point": "program.panel",
    "ui": "program",
    "label": {"en": "My Plugin Step"},
    "commandInfo": {
      "name": "My Plugin Step",
      "icon": "assets/icon.svg",
      "funcName": "rb_program_sdk.plugin_execute",
      "args": {"message": "hello"}   # plugin-author-defined args
    }
  }]

The host invokes commandInfo.funcName (rb_program_sdk.plugin_execute) with
args.plugin_id + your args when the program reaches this step.
"""
import asyncio
from rainbow.rb_sdk import PluginProgramContext

ctx = PluginProgramContext(plugin_id="my-plugin")


@ctx.on_execute
async def handle(args: dict) -> None:
    message = args.get("message", "")
    print(f"[my-plugin] execute called: message={message}", flush=True)

    # check stop/pause during long-running work
    for _ in range(10):
        await ctx.check_stop()
        await asyncio.sleep(0.1)

    # read a program variable
    counter = await ctx.get_variable("counter")
    print(f"[my-plugin] counter={counter}", flush=True)

    # update a variable
    await ctx.set_variable("result", f"done: {message}")

    # finish the step
    await ctx.done()


if __name__ == "__main__":
    asyncio.run(ctx.start())
```

### C++

C++ plugins use `cpp/` and are built with CMake inside Docker. The current C++
template is a build/run skeleton; wire it to the plugin gateway when the C++ SDK
is available.

```cpp
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <string>
#include <thread>

int main() {
  const char* plugin_id = std::getenv("RB_PLUGIN_ID");
  std::cout << "[__PLUGIN_NAME__] backend ready"
            << (plugin_id ? std::string(" (id=") + plugin_id + ")" : "")
            << std::endl;

  while (true) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
  return 0;
}
```

### ROS2 (rclpy)

ROS2 Python plugins use `ros2_ws/` with `runtime.rosClient: "rclpy"`. The node
is launched with `--ros-args -r __ns:=/{slug}` automatically by `dev:back`.

```python
# ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/node.py
import rclpy
from rclpy.node import Node
from rainbow.rb_sdk import RBManipulateSDK

sdk = RBManipulateSDK()


class __PLUGIN_CLASS__Node(Node):
    def __init__(self):
        super().__init__("__PLUGIN_SLUG___node")
        self.get_logger().info("__PLUGIN_NAME__ node started")
        # use sdk alongside ROS2 publishers/subscribers/services as needed
```

### ROS2 (rclcpp)

ROS2 C++ plugins use `ros2_ws/` with `runtime.rosClient: "rclcpp"`.

```cpp
#include "rclcpp/rclcpp.hpp"

class __PLUGIN_CLASS__Node : public rclcpp::Node {
public:
  __PLUGIN_CLASS__Node() : Node("__PLUGIN_SLUG___node") {
    RCLCPP_INFO(this->get_logger(), "__PLUGIN_NAME__ node started");
  }
};
```

---

## manifest.json

```jsonc
{
  // unique plugin ID — reverse-domain format recommended
  "id": "com.example.my-plugin",
  "name": "My Plugin",
  "version": "1.0.0",

  // minimum Muscat version required to load this plugin
  "minMuscatVersion": "1.0.0",

  // plugin author (empty string is fine)
  "author": "Your Name",

  // displayed in the Muscat plugin store / info panel
  // string or { en (required), ko, ja, zh, vi, th, es }
  "description": { "en": "Plugin description", "ko": "플러그인 설명" },

  // SVG string (single file) or PNG/JPG size map (all three sizes required)
  "icons": "assets/icon.svg",
  // "icons": { "16": "assets/icon-16.png", "48": "assets/icon-48.png", "128": "assets/icon-128.png" },

  // targetModels and/or targetCategorys — at least one is required
  // "all" = every target, or list specific values
  "targetModels": "all",
  // "targetModels": ["C500920", "C500930"],
  "targetCategorys": "all",
  // "targetCategorys": ["manipulate", "amr", "rby1", "vision"],

  "contributes": [
    // program.panel — defines a custom command for the Program page sequence
    //   builder; runs via PluginProgramContext when the program reaches it
    {
      "point": "program.panel",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "program",           // must be unique across all contributions
      "commandInfo": {
        "name": "My Plugin",
        "icon": "assets/icon.svg",
        "funcName": "rb_program_sdk.plugin_execute",
        "args": {}
      }
    },
    // toolbar — adds a button to the top toolbar (required)
    {
      "point": "toolbar",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "content",           // must be unique across all contributions
      "opens": "popover"         // popover | panel | page
    },
    // move.panel — adds a panel to the Move screen
    {
      "point": "move.panel",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "move"               // must be unique across all contributions
    }
  ],

  // runtime — one of:
  //   { "type": "none" }
  //   { "type": "python", "entry": "main.py" }
  //   { "type": "cpp", "entry": "<executable name>" }
  //   { "type": "ros2", "rosClient": "rclpy" | "rclcpp", "package": "...", "launch": "..._node" }
  "runtime": { "type": "python", "entry": "main.py" },

  // optional: TCP ports opened by this plugin backend
  // only number[] is allowed; ranges/objects are not accepted
  // external plugin ports must be within 28600-28999
  "ports": [28600]
}
```

**Backend types:**

| type | source dir | build / run | entry |
|---|---|---|---|
| `python` | `py/` | pip + run in Docker | `main.py` |
| `cpp` | `cpp/` | CMake in Docker | built executable name |
| `ros2` (rclpy) | `ros2_ws/` | colcon (ament_python) in Docker | — |
| `ros2` (rclcpp) | `ros2_ws/` | colcon (ament_cmake) in Docker | — |

> Every back end runs in a Docker container matching the robot (Ubuntu 24.04 + Python 3.12), so dev behaves like production and compiled binaries are ABI-compatible. **Docker is required** for all backend types (only a frontend-only `none` plugin skips it). No local Python/toolchain setup is needed.

**Contribution points:**

| point | Where it appears | Backend | `commandInfo` |
|---|---|---|:---:|
| `toolbar` | Top toolbar button (must have at least one) | SDK / `rb.action` | — |
| `lnb` | Left navigation entry | SDK / `rb.action` | — |
| `move.panel` | Move screen panel | SDK / `rb.action` | — |
| `program.panel` | Custom command in the Program page sequence builder | `PluginProgramContext` | ✓ |

**`commandInfo` fields** (for `program.panel`):

| field | type | description |
|---|---|---|
| `name` | `string` | Display name of the command in the program tree |
| `icon` | `string` | Icon path |
| `iconClassName` | `string?` | Optional CSS class for the icon |
| `funcName` | `string?` | Backend function name to call |
| `args` | `Record<string, any>?` | Default arguments |
| `disabled` | `boolean?` | Whether the node is disabled |
| `allowChildren` | `string[]?` | Allowed child commands |
| `allowParents` | `string[]?` | Allowed parent commands |
| `notAllowChildren` | `string[]?` | Disallowed child commands |
| `syncGroupId` | `boolean?` | Sync group ID across children |
| `disableCopy` | `boolean?` | Prevent copy |
| `disableDelete` | `boolean?` | Prevent delete |
| `requireChildren` | `boolean?` | Whether a child command is required |
| `requireParent` | `boolean?` | Whether a parent command is required |
| `childrenCommand` | `string?` | Default command type for children |

**Validation rules:**
- `id`, `name`, `version`, `minMuscatVersion` — required non-empty strings
- `author` — required non-empty string
- `description` — required (`string` or `{ en (required), ko?, ja?, zh?, vi?, th?, es? }`)
- `icons` — SVG: single string path ending in `.svg`; PNG/JPG: object with `"16"`, `"48"`, `"128"` all present
- `targetModels` — `"all"` or a non-empty array of robot model ID strings (at least one of `targetModels` / `targetCategorys` required)
- `targetCategorys` — `"all"` or a non-empty array of `"manipulate" | "amr" | "rby1" | "vision"` (at least one of `targetModels` / `targetCategorys` required)
- `contributes` — required array; must contain at least one `toolbar` entry
- `ui` — each contribution must have a unique value
- `commandInfo` — required when `point` is `"program.panel"`
- `ports` — optional `number[]`; every port must be within `28600-28999`
  and must not be a reserved robot/industrial/internal port

`muscat-pk build` throws on any validation error. `muscat-pk dev` prints warnings.

**Backend port rules:**
- Declare a port only if your backend opens a TCP server/listener.
- `muscat-pk dev` and `muscat-pk dev:back` stop the backend if it opens an
  undeclared managed port.
- Reserved ports include `502`, `2222`, `4840`, `5170-5179`, `8000-8999`,
  `10000`, `30004`, `34964`, `44818`, `50000-50005`, and `50051`.

---

## Localized documentation

You can ship per-language README files alongside the main `README.md`. Place them in the project root:

```
README.md        # default / English fallback
README.ko.md     # Korean
README.en.md     # explicit English (optional)
README.ja.md     # Japanese
```

All `README*.md` files found at the project root are automatically copied to `dist/` on
`muscat-pk build`. Muscat displays the file matching the user's locale,
falling back to `README.md` if none matches.

---

## 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
```

Run `muscat-pk dev` or `muscat-pk dev:back` — dependencies are installed automatically
inside the dev container (`pip install -r requirements.txt`) on every startup. No
local Python is required for this.

`muscat-pk dev:back` also best-effort creates/refreshes a local `.venv` in the
background (via `uv` if available, else your system Python) with the same deps —
purely so your editor (pylint, pyright, mypy, ...) can resolve imports and lint
correctly. It's not used to run the backend; Docker is the actual execution
environment, so this step is silently skipped if no local Python toolchain is
available. Point your editor's Python interpreter at `.venv`.

`muscat-pk sdk update` also refreshes `.venv` in place if one already exists, so
your editor picks up the new `rainbow-rb-sdk` version immediately.

> `muscat-pk build` only **pins** versions in `requirements.txt` — it does not run `pip install` (the robot installs them at load time).

---

## Switching backend type

```bash
muscat-pk type change                 # interactive
muscat-pk type change --to cpp        # → C++
muscat-pk type change --to ros2       # → ROS2 (rclpy / Python)
muscat-pk type change --to ros2-cpp   # → ROS2 (rclcpp / C++)
muscat-pk type change --to python     # → Python
```

> Existing backend dirs (`ros2_ws/`, `cpp/`) are not deleted when switching away. Remove them manually if no longer needed.

---

## AI coding assistants (MCP)

If you build your plugin with an AI assistant (Claude Code, Codex, …), give it
grounded knowledge of the Muscat UI components, design tokens, and SDK instead of
letting it guess. `muscat-pk mcp` is an MCP server exposing:

- `list_components` / `get_component_props` / `get_component_example` — every
  `@rainbow-robotics/plugin-ui/react` component with its real props and a working
  Storybook example.
- `list_design_tokens` / `search_design_tokens` — the Tailwind classes to use
  (`bg-bg-*`, `text-fg-*`, `typo-*`, …) so your UI matches the host theme.
- `search_rb_sdk` — how to use `useRb()`, `rb.*`, `useRbFormData`/`useRbSave`, and
  the backend runtimes.
- `list_rb_sdk` / `get_rb_sdk_api` — the installed `rainbow-rb-sdk` (Python
  backend) classes and signatures.

**Browse the components live** with `muscat-pk storybook`.

### Register the server

**Claude Code** — a `.mcp.json` is already scaffolded at your plugin root, so
it works out of the box:

```json
{
  "mcpServers": {
    "muscat": {
      "command": "muscat-pk",
      "args": ["mcp"]
    }
  }
}
```

**Codex** — add to `~/.codex/config.toml`:

```toml
[mcp_servers.muscat]
command = "muscat-pk"
args = ["mcp"]
```

Any other MCP client works too — it's a standard stdio MCP server started with
`muscat-pk mcp`. If `muscat-pk` isn't on the client's PATH, use its absolute path
(`which muscat-pk`) as `command`.

---

## Shipping

```bash
muscat-pk build            # build + ZIP
muscat-pk build --no-zip   # build only, no ZIP
```

- Builds `ui/content.tsx` → `dist/content.js` (minified)
- Pins `requirements.txt` to latest versions (stable-only on `main` branch)
- Copies `assets/`, `manifest.json`, `README*.md`, `py/`, and `requirements.txt` into `dist/`
- ROS2: runs `colcon build` inside the Jazzy container; includes `ros2_ws/install/`
- Output: `__PLUGIN_DIR__-{version}.zip`

ZIP layout:

```
__PLUGIN_DIR__-1.0.0.zip
├─ dist/
│   ├─ content.js        # built UI
│   ├─ manifest.json
│   ├─ assets/
│   ├─ README.md
│   ├─ README.ko.md      # if present
│   ├─ main.py           # from 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      # build → dist/ + distributable ZIP (--no-zip to skip)
muscat-pk storybook  # browse the rb-components UI library in a browser
muscat-pk mcp        # MCP server for AI assistants (components/tokens/SDK docs)
```

```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
muscat-pk uninstall      # remove muscat-pk itself
```
","common/assets/icon.svg":"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","common/manifest.json":"ewogICJpZCI6ICJfX1BMVUdJTl9JRF9fIiwKICAibmFtZSI6ICJfX1BMVUdJTl9OQU1FX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAibWluTXVzY2F0VmVyc2lvbiI6ICIxLjAuMCIsCiAgImF1dGhvciI6ICJfX1BMVUdJTl9BVVRIT1JfXyIsCiAgImVtYWlsIjogIl9fUExVR0lOX0VNQUlMX18iLAogICJkZXNjcmlwdGlvbiI6IHsKICAgICJrbyI6ICIiLAogICAgImVuIjogIiIKICB9LAogICJpY29ucyI6ICJhc3NldHMvaWNvbi5zdmciLAogICJ0YXJnZXRNb2RlbHMiOiAiYWxsIiwKICAidGFyZ2V0Q2F0ZWdvcnlzIjogImFsbCIsCiAgImNvbnRyaWJ1dGVzIjogWwogICAgewogICAgICAicG9pbnQiOiAidG9vbGJhciIsCiAgICAgICJpY29uIjogImFzc2V0cy9pY29uLnN2ZyIsCiAgICAgICJsYWJlbCI6IHsgImtvIjogIl9fUExVR0lOX05BTUVfXyIsICJlbiI6ICJfX1BMVUdJTl9OQU1FX18iIH0sCiAgICAgICJ1aSI6ICJjb250ZW50IiwKICAgICAgIm9wZW5zIjogInBvcG92ZXIiCiAgICB9CiAgXSwKICAicnVudGltZSI6IHsgInR5cGUiOiAiX19SVU5USU1FX1RZUEVfXyIsICJlbnRyeSI6ICJtYWluLnB5IiB9Cn0K","common/package.json":"ewogICJuYW1lIjogIl9fUExVR0lOX0lEX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAicHJpdmF0ZSI6IHRydWUsCiAgInR5cGUiOiAibW9kdWxlIiwKICAiZGVwZW5kZW5jaWVzIjogewogICAgIkByYWluYm93LXJvYm90aWNzL3BsdWdpbi11aSI6ICJfX1JCX1ZFUlNJT05fXyIKICB9LAogICJkZXZEZXBlbmRlbmNpZXMiOiB7CiAgICAiQHRhaWx3aW5kY3NzL3ZpdGUiOiAiXjQuMS4wIiwKICAgICJAcmFpbmJvdy1yb2JvdGljcy9tdXNjYXQtcGx1Z2luLWtpdCI6ICJfX1JCX1ZFUlNJT05fXyIsCiAgICAiQHJhaW5ib3ctcm9ib3RpY3MvcHJldmlldy1ob3N0IjogIl9fUkJfVkVSU0lPTl9fIiwKICAgICJAdHlwZXMvcmVhY3QiOiAiXjE5LjAuMTAiLAogICAgIkB0eXBlcy9yZWFjdC1kb20iOiAiXjE5LjAuNCIsCiAgICAiQHZpdGVqcy9wbHVnaW4tcmVhY3QiOiAiXjQuMC4wIiwKICAgICJyZWFjdCI6ICJeMTkuMC4wIiwKICAgICJyZWFjdC1kb20iOiAiXjE5LjAuMCIsCiAgICAidGFpbHdpbmRjc3MiOiAiXjQuMS4wIiwKICAgICJ0eXBlc2NyaXB0IjogIl41LjguMCIsCiAgICAidml0ZSI6ICJeNi4wLjAiCiAgfQp9Cg==","common/py/main.py":"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","common/requirements.txt":"cmFpbmJvdy1yYi1zZGs9PTAuMC45LmRldjQzCnJhaW5ib3ctcmItZmxhdC1idWZmZXJzPT0wLjAuOS5kZXY0MwpyYWluYm93LXJiLXplbm9oPT0wLjAuOS5kZXY0MwpyZXF1ZXN0cz09Mi4zNC4yCg==","common/tsconfig.json":"ewogICJjb21waWxlck9wdGlvbnMiOiB7CiAgICAidGFyZ2V0IjogIkVTTmV4dCIsCiAgICAibW9kdWxlIjogIkVTTmV4dCIsCiAgICAibW9kdWxlUmVzb2x1dGlvbiI6ICJidW5kbGVyIiwKICAgICJqc3giOiAicmVhY3QtanN4IiwKICAgICJzdHJpY3QiOiB0cnVlLAogICAgInNraXBMaWJDaGVjayI6IHRydWUsCiAgICAibm9FbWl0IjogdHJ1ZSwKICAgICJsaWIiOiBbIkRPTSIsICJET00uSXRlcmFibGUiLCAiRVNOZXh0Il0KICB9LAogICJpbmNsdWRlIjogWyJ1aSJdCn0K","common/ui/content.tsx":"import { useMemo, useState } from "react";
import {
  RBCheckBox,
  RBLabelButton,
  RBRadioBox,
  RBSelectBox,
  RBSlider,
  RBSwitch,
  RBTextArea,
  RBTextField,
  RBTextInput,
  Option
} from "@rainbow-robotics/plugin-ui/react";
import { useRb } from "@rainbow-robotics/plugin-ui/sdk";

type RunMode = "inspect" | "assist" | "auto";

const MODE_OPTIONS: Array<{ label: string; value: RunMode }> = [
  { label: "Inspect", value: "inspect" },
  { label: "Assist", value: "assist" },
  { label: "Auto", value: "auto" },
];

const TASK_OPTIONS = [
  { label: "Publish status", value: "publish" },
  { label: "Run grip action", value: "grip" },
  { label: "Save snapshot", value: "snapshot" },
];

// Export your UI as the default. The host mounts it (dev: with HMR).
export default function App() {
  const rb = useRb();
  const [targetName, setTargetName] = useState("demo_target");
  const [gripType, setGripType] = useState<string>();
  const [gripWidth, setGripWidth] = useState(24);
  const [speed, setSpeed] = useState(45);
  const [mode, setMode] = useState<RunMode>("assist");
  const [enabled, setEnabled] = useState(true);
  const [tasks, setTasks] = useState<Array<string>>(["publish", "grip"]);
  const [memo, setMemo] = useState("Use this area for operator notes.");

  const payload = useMemo(
    () => ({
      targetName,
      gripWidth,
      speed,
      mode,
      enabled,
      tasks,
      memo,
    }),
    [targetName, gripWidth, speed, mode, enabled, tasks, memo],
  );

  const showRequestError = (error: unknown) => {
    const message = error instanceof Error ? error.message : "Request failed";
    rb.toast({ type: "danger", message });
  };

  const runAction = async () => {
    try {
      await rb.action("grip", payload);
      rb.toast({ type: "success", message: `Sent ${targetName}` });
    } catch (error) {
      showRequestError(error);
    }
  };

  const publishPreview = async () => {
    try {
      const isConfirm = await rb.confirm({
        message: "Are you sure publish?",
        buttonText: { yes: "confirm", no: "cancel" },
      });

      if (isConfirm) {
        await rb.pub("event", payload);
      }
    } catch (error) {
      showRequestError(error);
    }
  };

  return (
    <div className="max-h-[70vh] w-[420px] p-4 max-w-full overflow-y-auto bg-bg-elevated text-fg-default">
      <div className="flex flex-col gap-5">
        <header>
          <div className="flex items-center justify-between gap-12">
            <div>
              <h2 className="typo-heading-xs-semibold">Demo Control</h2>
              <p className="typo-body-xs2-normal text-fg-subtle">
                Input patterns for Muscat plugin UIs
              </p>
            </div>
            <RBSwitch
              checked={enabled}
              onCheckedChange={(next: boolean) => {
                setEnabled(next);
                rb.toast({message: next ? "Plugin enabled" : "Plugin paused"});
              }}
            />
          </div>
        </header>

        <section className="flex flex-col gap-4">
          <RBTextField
            label="Target name"
            required
            helperText="Used as the backend action target."
          >
            <RBTextInput
              name="targetName"
              value={targetName}
              placeholder="target id"
              handleChange={(value) => setTargetName(String(value))}
            />
          </RBTextField>

          <RBTextField label="Select Grip">
            <RBSelectBox  className="w-full" value={gripType} handleChange={setGripType}>
              <Option value="A">A Grip</Option>
              <Option value="B">B Grip</Option>
            </RBSelectBox>
          </RBTextField>

          <div className="flex gap-4">
            <RBTextField className="flex-1" label="Grip width" helperText="0-100 mm">
              <RBTextInput
                className="w-full"
                name="gripWidth"
                type="number"
                value={gripWidth}
                validate={(value: number) =>
                  Math.max(0, Math.min(100, Number(value) || 0))
                }
                handleChange={(value) => setGripWidth(Number(value) || 0)}
              />
            </RBTextField>

            <RBTextField className="flex-1" label="Speed" helperText={`${speed}%`}>
              <div className="flex items-center px-2">
                <RBSlider
                  value={[speed]}
                  min={0}
                  max={100}
                  step={5}
                  onValueChange={(values: number[]) =>
                    setSpeed(values[0] ?? 0)
                  }
                />
              </div>
            </RBTextField>
          </div>
        </section>

        <section className="mb-4">
          <RBTextField label="Run mode">
            <div className="flex justify-between border-1 border-border-subtle rounded-sm p-2">
            {MODE_OPTIONS.map((item) => (
              <RBRadioBox
                key={item.value}
                name="mode"
                checkValue={item.value}
                value={mode}
                handleChange={(value) => setMode(value as RunMode)}
              >
                {item.label}
              </RBRadioBox>
            ))}
          </div>
          </RBTextField>
        </section>

        <section className="mb-4">
          <RBTextField label="Tasks">
            <div className="flex justify-between border-1 border-border-subtle rounded-sm p-2">
              {TASK_OPTIONS.map((item) => (
                <RBCheckBox
                  key={item.value}
                  name="tasks"
                  checkValue={item.value}
                  value={tasks}
                  handleChange={(value) =>
                    setTasks(Array.isArray(value) ? value.map(String) : [])
                  }
                >
                  {item.label}
                </RBCheckBox>
              ))}
            </div>
          </RBTextField>
          
        </section>

        <RBTextField label="Memo">
          <RBTextArea
            name="memo"
            value={memo}
            maxLength={120}
            rows={4}
            handleChange={setMemo}
          />
        </RBTextField>

        <footer className="grid grid-cols-2 gap-8 pt-4">
          <RBLabelButton variant="outlined" onClick={publishPreview}>
            Publish
          </RBLabelButton>
          <RBLabelButton onClick={runAction} disabled={!enabled}>
            Run Action
          </RBLabelButton>
        </footer>
      </div>
    </div>
  );
}
","common/ui/style.css":"QGxheWVyIHRoZW1lLCB1dGlsaXRpZXM7CgpAaW1wb3J0ICJ0YWlsd2luZGNzcy90aGVtZS5jc3MiIGxheWVyKHRoZW1lKTsKQGltcG9ydCAidGFpbHdpbmRjc3MvdXRpbGl0aWVzLmNzcyIgbGF5ZXIodXRpbGl0aWVzKTsKCkBzb3VyY2UgIi4vKiovKi57dHMsdHN4fSI7Cg==","common/vite.config.ts":"aW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSAidml0ZSI7CmltcG9ydCB0YWlsd2luZGNzcyBmcm9tICJAdGFpbHdpbmRjc3Mvdml0ZSI7CmltcG9ydCB7IG11c2NhdCB9IGZyb20gIkByYWluYm93LXJvYm90aWNzL211c2NhdC1wbHVnaW4ta2l0L3ZpdGUiOwoKLy8gVGhlIG11c2NhdCgpIHByZXNldCB3aXJlcyByZWFjdC1yZWZyZXNoLCB1aS8gZW50cnkgZGlzY292ZXJ5LCBhbmQgbWFya3MgdGhlCi8vIGhvc3QtcHJvdmlkZWQgcnVudGltZSAocGx1Z2luLXVpLCByZWFjdCkgYXMgZXh0ZXJuYWwuIEFkZCB5b3VyIG93biBwbHVnaW5zIG9yCi8vIG92ZXJyaWRlcyBoZXJlIGFzIG5lZWRlZC4KZXhwb3J0IGRlZmF1bHQgZGVmaW5lQ29uZmlnKHsKICBwbHVnaW5zOiBbdGFpbHdpbmRjc3MoKSwgbXVzY2F0KCldLAp9KTsK","cpp/cpp/CMakeLists.txt":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fIENYWCkKCnNldChDTUFLRV9DWFhfU1RBTkRBUkQgMTcpCnNldChDTUFLRV9DWFhfU1RBTkRBUkRfUkVRVUlSRUQgT04pCgojIFRoZSBleGVjdXRhYmxlIG5hbWUgbXVzdCBtYXRjaCBydW50aW1lLmVudHJ5IGluIG1hbmlmZXN0Lmpzb24uCmFkZF9leGVjdXRhYmxlKF9fUExVR0lOX1NMVUdfXyBtYWluLmNwcCkKCiMgVE9ETyhjcHAtc2RrKTogbGluayB0aGUgcmFpbmJvdyBjcHAgU0RLIGR5bmFtaWNhbGx5ICh0aGUgcm9ib3QgcHJvdmlkZXMgdGhlCiMgLnNvIGF0IHJ1bnRpbWUg4oCUIGRvIE5PVCBidW5kbGUvc3RhdGljLWxpbmsgaXQpLiBPbmNlIHRoZSBTREsgc2hpcHMgYW4gYXB0CiMgcGFja2FnZSB3aXRoIENNYWtlIGNvbmZpZywgZW5hYmxlOgojICAgZmluZF9wYWNrYWdlKHJhaW5ib3dfY3BwX3NkayBSRVFVSVJFRCkKIyAgIHRhcmdldF9saW5rX2xpYnJhcmllcyhfX1BMVUdJTl9TTFVHX18gUFJJVkFURSByYWluYm93OjpjcHBfc2RrKQo=","cpp/cpp/main.cpp":"Ly8gX19QTFVHSU5fTkFNRV9fIOKAlCBDKysgcGx1Z2luIGJhY2sgZW5kLgovLwovLyBUaGUgQysrIHBsdWdpbiBTREsgaXMgbm90IGF2YWlsYWJsZSB5ZXQsIHNvIHRoaXMgaXMgYSBidWlsZC9ydW4gc2tlbGV0b24uCi8vIE9uY2UgdGhlIFNESyBsYW5kcywgY29ubmVjdCB0byB0aGUgcGx1Z2luIGdhdGV3YXkgaGVyZSAodGhlIGhvc3QgZXhwb3NlcyBpdAovLyBhdCB0aGUgUkJfUExVR0lOX0dBVEVXQVkgLyBSQl9QTFVHSU5fSUQgZW52aXJvbm1lbnQgdmFyaWFibGVzKSBhbmQgd2lyZSB1cAovLyBwdWIgLyBzdWIgLyBzZXJ2ZSwgbWlycm9yaW5nIHRoZSBQeXRob24gcmFpbmJvdy5yYl9zZGsuUkJQbHVnaW5DYWxsIEFQSS4KCiNpbmNsdWRlIDxjaHJvbm8+CiNpbmNsdWRlIDxjc3RkbGliPgojaW5jbHVkZSA8aW9zdHJlYW0+CiNpbmNsdWRlIDxzdHJpbmc+CiNpbmNsdWRlIDx0aHJlYWQ+CgppbnQgbWFpbigpIHsKICBjb25zdCBjaGFyKiBwbHVnaW5faWQgPSBzdGQ6OmdldGVudigiUkJfUExVR0lOX0lEIik7CiAgc3RkOjpjb3V0IDw8ICJbX19QTFVHSU5fTkFNRV9fXSBiYWNrZW5kIHJlYWR5IgogICAgICAgICAgICA8PCAocGx1Z2luX2lkID8gc3RkOjpzdHJpbmcoIiAoaWQ9IikgKyBwbHVnaW5faWQgKyAiKSIgOiAiIikKICAgICAgICAgICAgPDwgc3RkOjplbmRsOwoKICAvLyBUT0RPOiBjb25uZWN0IHRvIHRoZSBwbHVnaW4gZ2F0ZXdheSBhbmQgcmVnaXN0ZXIgaGFuZGxlcnMgb25jZSB0aGUKICAvLyAgICAgICBDKysgU0RLIGlzIGF2YWlsYWJsZS4gRm9yIG5vdywganVzdCBrZWVwIHRoZSBwcm9jZXNzIGFsaXZlLgogIHdoaWxlICh0cnVlKSB7CiAgICBzdGQ6OnRoaXNfdGhyZWFkOjpzbGVlcF9mb3Ioc3RkOjpjaHJvbm86OnNlY29uZHMoMSkpOwogIH0KICByZXR1cm4gMDsKfQo=","ros2/ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/__init__.py":"","ros2/ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/node.py":"aW1wb3J0IHJjbHB5CmZyb20gcmNscHkubm9kZSBpbXBvcnQgTm9kZQpmcm9tIHJhaW5ib3cucmJfc2RrIGltcG9ydCBSQk1hbmlwdWxhdGVTREsgICMgUHlQSTogcmFpbmJvdy1yYi1zZGsKCgpzZGsgPSBSQk1hbmlwdWxhdGVTREsoKQoKCmNsYXNzIF9fUExVR0lOX0NMQVNTX19Ob2RlKE5vZGUpOgogICAgZGVmIF9faW5pdF9fKHNlbGYpOgogICAgICAgIHN1cGVyKCkuX19pbml0X18oIl9fUExVR0lOX1NMVUdfX19ub2RlIikKICAgICAgICBzZWxmLmdldF9sb2dnZXIoKS5pbmZvKCJfX1BMVUdJTl9OQU1FX18gbm9kZSBzdGFydGVkIikKICAgICAgICAjIHNkayBpcyBhdmFpbGFibGUgaGVyZSDigJQgdXNlIGl0IGFsb25nc2lkZSBST1MyIHRvcGljcyBhcyBuZWVkZWQKCgpkZWYgbWFpbihhcmdzPU5vbmUpOgogICAgcmNscHkuaW5pdChhcmdzPWFyZ3MpCiAgICBub2RlID0gX19QTFVHSU5fQ0xBU1NfX05vZGUoKQogICAgcmNscHkuc3Bpbihub2RlKQogICAgbm9kZS5kZXN0cm95X25vZGUoKQogICAgcmNscHkuc2h1dGRvd24oKQoKCmlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiAgICBtYWluKCkK","ros2/ros2_ws/src/__PLUGIN_SLUG__/package.xml":"PD94bWwgdmVyc2lvbj0iMS4wIj8+CjxwYWNrYWdlIGZvcm1hdD0iMyI+CiAgPG5hbWU+X19QTFVHSU5fU0xVR19fPC9uYW1lPgogIDx2ZXJzaW9uPjAuMC4xPC92ZXJzaW9uPgogIDxkZXNjcmlwdGlvbj5fX1BMVUdJTl9OQU1FX18gUk9TMiBub2RlPC9kZXNjcmlwdGlvbj4KICA8bWFpbnRhaW5lciBlbWFpbD0idG9kb0BleGFtcGxlLmNvbSI+bWFpbnRhaW5lcjwvbWFpbnRhaW5lcj4KICA8bGljZW5zZT5Qcm9wcmlldGFyeTwvbGljZW5zZT4KICA8ZGVwZW5kPnJjbHB5PC9kZXBlbmQ+CiAgPGV4cG9ydD48YnVpbGRfdHlwZT5hbWVudF9weXRob248L2J1aWxkX3R5cGU+PC9leHBvcnQ+CjwvcGFja2FnZT4K","ros2/ros2_ws/src/__PLUGIN_SLUG__/resource/__PLUGIN_SLUG__":"","ros2/ros2_ws/src/__PLUGIN_SLUG__/setup.py":"ZnJvbSBzZXR1cHRvb2xzIGltcG9ydCBzZXR1cAoKcGFja2FnZV9uYW1lID0gIl9fUExVR0lOX1NMVUdfXyIKCnNldHVwKAogICAgbmFtZT1wYWNrYWdlX25hbWUsCiAgICB2ZXJzaW9uPSIwLjAuMSIsCiAgICBwYWNrYWdlcz1bcGFja2FnZV9uYW1lXSwKICAgIGRhdGFfZmlsZXM9WwogICAgICAgICgic2hhcmUvYW1lbnRfaW5kZXgvcmVzb3VyY2VfaW5kZXgvcGFja2FnZXMiLCBbInJlc291cmNlLyIgKyBwYWNrYWdlX25hbWVdKSwKICAgICAgICAoInNoYXJlLyIgKyBwYWNrYWdlX25hbWUsIFsicGFja2FnZS54bWwiXSksCiAgICBdLAogICAgaW5zdGFsbF9yZXF1aXJlcz1bInNldHVwdG9vbHMiXSwKICAgIHppcF9zYWZlPVRydWUsCiAgICBlbnRyeV9wb2ludHM9ewogICAgICAgICJjb25zb2xlX3NjcmlwdHMiOiBbIl9fUExVR0lOX1NMVUdfX19ub2RlID0gX19QTFVHSU5fU0xVR19fLm5vZGU6bWFpbiJdLAogICAgfSwKKQo=","ros2-cpp/ros2_ws/src/__PLUGIN_SLUG__/CMakeLists.txt":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fKQoKaWYoTk9UIENNQUtFX0NYWF9TVEFOREFSRCkKICBzZXQoQ01BS0VfQ1hYX1NUQU5EQVJEIDE3KQplbmRpZigpCgpmaW5kX3BhY2thZ2UoYW1lbnRfY21ha2UgUkVRVUlSRUQpCmZpbmRfcGFja2FnZShyY2xjcHAgUkVRVUlSRUQpCgphZGRfZXhlY3V0YWJsZShfX1BMVUdJTl9TTFVHX19fbm9kZSBzcmMvbm9kZS5jcHApCmFtZW50X3RhcmdldF9kZXBlbmRlbmNpZXMoX19QTFVHSU5fU0xVR19fX25vZGUgcmNsY3BwKQoKaW5zdGFsbChUQVJHRVRTIF9fUExVR0lOX1NMVUdfX19ub2RlCiAgREVTVElOQVRJT04gbGliLyR7UFJPSkVDVF9OQU1FfSkKCmFtZW50X3BhY2thZ2UoKQo=","ros2-cpp/ros2_ws/src/__PLUGIN_SLUG__/package.xml":"PD94bWwgdmVyc2lvbj0iMS4wIj8+CjxwYWNrYWdlIGZvcm1hdD0iMyI+CiAgPG5hbWU+X19QTFVHSU5fU0xVR19fPC9uYW1lPgogIDx2ZXJzaW9uPjAuMC4xPC92ZXJzaW9uPgogIDxkZXNjcmlwdGlvbj5fX1BMVUdJTl9OQU1FX18gUk9TMiBub2RlIChyY2xjcHApPC9kZXNjcmlwdGlvbj4KICA8bWFpbnRhaW5lciBlbWFpbD0idG9kb0BleGFtcGxlLmNvbSI+bWFpbnRhaW5lcjwvbWFpbnRhaW5lcj4KICA8bGljZW5zZT5Qcm9wcmlldGFyeTwvbGljZW5zZT4KICA8YnVpbGR0b29sX2RlcGVuZD5hbWVudF9jbWFrZTwvYnVpbGR0b29sX2RlcGVuZD4KICA8ZGVwZW5kPnJjbGNwcDwvZGVwZW5kPgogIDxleHBvcnQ+PGJ1aWxkX3R5cGU+YW1lbnRfY21ha2U8L2J1aWxkX3R5cGU+PC9leHBvcnQ+CjwvcGFja2FnZT4K","ros2-cpp/ros2_ws/src/__PLUGIN_SLUG__/src/node.cpp":"Ly8gX19QTFVHSU5fTkFNRV9fIOKAlCBST1MyIG5vZGUgKHJjbGNwcCkuCi8vCi8vIFRoZSBub2RlIGlzIGxhdW5jaGVkIHdpdGggYC0tcm9zLWFyZ3MgLXIgX19uczo9L3tzbHVnfWAgYXV0b21hdGljYWxseSBieQovLyBkZXY6YmFjay4gUk9TMiB0b3BpY3MgYXJlIGJyaWRnZWQgdG8gdGhlIHBsdWdpbiBjb21tdW5pY2F0aW9uIGxheWVyLCBzbyBhCi8vIHBsYWluIHJjbGNwcCBub2RlIGlzIGFsbCB5b3UgbmVlZCDigJQgcmVsYXRpdmUgdG9waWMgbmFtZXMgZ2V0IHRoZSBuYW1lc3BhY2UKLy8gcHJlZml4IGFwcGxpZWQgYXV0b21hdGljYWxseS4KI2luY2x1ZGUgInJjbGNwcC9yY2xjcHAuaHBwIgoKY2xhc3MgX19QTFVHSU5fQ0xBU1NfX05vZGUgOiBwdWJsaWMgcmNsY3BwOjpOb2RlIHsKcHVibGljOgogIF9fUExVR0lOX0NMQVNTX19Ob2RlKCkgOiBOb2RlKCJfX1BMVUdJTl9TTFVHX19fbm9kZSIpIHsKICAgIFJDTENQUF9JTkZPKHRoaXMtPmdldF9sb2dnZXIoKSwgIl9fUExVR0lOX05BTUVfXyBub2RlIHN0YXJ0ZWQiKTsKICAgIC8vIGNyZWF0ZSBwdWJsaXNoZXJzIC8gc3Vic2NyaWJlcnMgLyBzZXJ2aWNlcyBoZXJlCiAgfQp9OwoKaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KSB7CiAgcmNsY3BwOjppbml0KGFyZ2MsIGFyZ3YpOwogIHJjbGNwcDo6c3BpbihzdGQ6Om1ha2Vfc2hhcmVkPF9fUExVR0lOX0NMQVNTX19Ob2RlPigpKTsKICByY2xjcHA6OnNodXRkb3duKCk7CiAgcmV0dXJuIDA7Cn0K","docker/Dockerfile.bridge":"IyBTb2NrZXQuSU8gYnJpZGdlIGNvbnRhaW5lciDigJQgdGhlIGZyb250ZW5kIChwcmV2aWV3LWhvc3QpIGFuZCB0aGUgYmFja2VuZAojIGNvbnRhaW5lciByZW5kZXp2b3VzIGhlcmUgZHVyaW5nIGBtdXNjYXQtcGsgZGV2YC4KIyAgIC0gZnJvbnRlbmQgKGhvc3QpICDihpIgcHVibGlzaGVkIHBvcnQgbG9jYWxob3N0OjEwMDAwCiMgICAtIGJhY2tlbmQgY29udGFpbmVyIOKGkiBzaGFyZXMgdGhpcyBjb250YWluZXIncyBuZXRucyAoLS1uZXR3b3JrIGNvbnRhaW5lcjopLAojICAgICAgICAgICAgICAgICAgICAgICAgIHNvIGl0IHJlYWNoZXMgdGhlIGJyaWRnZSBhdCBsb2NhbGhvc3Q6MTAwMDAgdG9vCiMgQnVpbGQgY29udGV4dCBpcyB0aGUgYGNsaS9gIGRpciBzbyBpdCBjYW4gY29weSBzcmMvc29ja2V0QnJpZGdlLm1qcy4KRlJPTSBub2RlOjIwLXNsaW0KTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKV09SS0RJUiAvYnJpZGdlCkNPUFkgZG9ja2VyL2JyaWRnZS1wYWNrYWdlLmpzb24gcGFja2FnZS5qc29uClJVTiBucG0gaW5zdGFsbCAtLW9taXQ9ZGV2IC0tbm8tYXVkaXQgLS1uby1mdW5kCgpDT1BZIHNyYy9zb2NrZXRCcmlkZ2UubWpzIC4vc29ja2V0QnJpZGdlLm1qcwoKRVhQT1NFIDEwMDAwCkNNRCBbIm5vZGUiLCAic29ja2V0QnJpZGdlLm1qcyJdCg==","docker/Dockerfile.cpp":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgcHVyZSBDKysgcGx1Z2luIGJhY2sgZW5kLgojIE1hdGNoZXMgdGhlIE11c2NhdCByb2JvdCBiYWNrZW5kIE9TIChVYnVudHUgMjQuMDQpIHNvIHRoZSBjb21waWxlZCBiaW5hcnkKIyBpcyBBQkktY29tcGF0aWJsZSB3aXRoIHRoZSByb2JvdC4gVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCBhbmQgYGJ1aWxkYAojIOKAlCBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUC4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIGJ1aWxkLWVzc2VudGlhbCBcCiAgICAgIGNtYWtlIFwKICAgICYmIHJtIC1yZiAvdmFyL2xpYi9hcHQvbGlzdHMvKgoKIyBUT0RPKGNwcC1zZGspOiBpbnN0YWxsIHRoZSByYWluYm93IGNwcCBTREsgKGRldiBwYWNrYWdlKSBoZXJlLCBwaW5uZWQgdG8gdGhlCiMgcm9ib3QncyB2ZXJzaW9uLCBzbyBwbHVnaW5zIGJ1aWxkL2xpbmsgYWdhaW5zdCB0aGUgc2FtZSBTREsgYXMgcHJvZHVjdGlvbi4KIyBQbGFuOiBhcHQgcGFja2FnZSArIGR5bmFtaWMgbGluayAodGhlIHJvYm90IHByb3ZpZGVzIHRoZSAuc28gYXQgcnVudGltZTsKIyB3ZSBkbyBOT1QgYnVuZGxlIGl0IGludG8gdGhlIHBsdWdpbiBiaW5hcnkpLiBlLmcuOgojICAgUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSByYWluYm93LWNwcC1zZGstZGV2PTxyb2JvdC12ZXJzaW9uPiBcCiMgICAgICAgJiYgcm0gLXJmIC92YXIvbGliL2FwdC9saXN0cy8qCgpXT1JLRElSIC9wbHVnaW4KCkNNRCBbImJhc2giXQo=","docker/Dockerfile.dev":"IyBEZXYtb25seSBjb250YWluZXIgZm9yIHRoZSBST1MyIHBsdWdpbiBiYWNrIGVuZC4KIyBNYXRjaGVzIHRoZSBNdXNjYXQgcm9ib3QgYmFja2VuZDogUk9TMiBKYXp6eSArIFB5dGhvbiAzLjEyIChVYnVudHUgMjQuMDQpLgojIFVzZWQgYnkgYG11c2NhdC1wayBkZXY6YmFja2Ag4oCUIE5PVCBzaGlwcGVkIGluIHRoZSBwbHVnaW4gWklQLgpGUk9NIHJvczpqYXp6eS1yb3MtYmFzZQpMQUJFTCBjb20ucmFpbmJvdy1yb2JvdGljcy5tdXNjYXQtcGs9InRydWUiCgpSVU4gYXB0LWdldCB1cGRhdGUgJiYgYXB0LWdldCBpbnN0YWxsIC15IC0tbm8taW5zdGFsbC1yZWNvbW1lbmRzIFwKICAgICAgcHl0aG9uMy1waXAgXAogICAgICBweXRob24zLWNvbGNvbi1jb21tb24tZXh0ZW5zaW9ucyBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyoKCldPUktESVIgL3BsdWdpbgoKQ01EIFsiYmFzaCJdCg==","docker/Dockerfile.python":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgUHl0aG9uIHBsdWdpbiBiYWNrIGVuZC4KIyBNYXRjaGVzIHRoZSBNdXNjYXQgcm9ib3QgYmFja2VuZDogVWJ1bnR1IDI0LjA0ICsgUHl0aG9uIDMuMTIuCiMgVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCAoaG90LXJlbG9hZCkgYW5kIGBtdXNjYXQtcGsgYnVpbGRgIChsb2NrICsgd2hlZWwgdmVuZG9yKS4KIyBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUCDigJQgdGhlIHJvYm90IGluc3RhbGxzIGRlcHMgZnJvbSBkaXN0L3doZWVscy8gb2ZmbGluZS4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIHB5dGhvbjMgXAogICAgICBweXRob24zLXBpcCBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyogXAogICAgJiYgcGlwMyBpbnN0YWxsIHV2PT0wLjguMTggLS1icmVhay1zeXN0ZW0tcGFja2FnZXMKCiMgVE9ETyhjcHAtc2RrKTogdGhlIFB5dGhvbiBTREsgaXMgYSBweWJpbmQgd3JhcHBlciBvdmVyIHRoZSBjcHAgU0RLLCBzbyB0aGUKIyBjcHAgU0RLIHNoYXJlZCBsaWIgbXVzdCBiZSBwcmVzZW50IGZvciB0aGUgcHl0aG9uIG1vZHVsZSB0byBsb2FkLiBJbnN0YWxsIHRoZQojIHJhaW5ib3cgY3BwIFNESyAoYXB0LCBwaW5uZWQgdG8gdGhlIHJvYm90J3MgdmVyc2lvbikgaGVyZSBvbmNlIGl0IGV4aXN0cy4KCldPUktESVIgL3BsdWdpbgoKQ01EIFsiYmFzaCJdCg==","docker/bridge-package.json":"ewogICJuYW1lIjogIm11c2NhdC1way1icmlkZ2UiLAogICJwcml2YXRlIjogdHJ1ZSwKICAidHlwZSI6ICJtb2R1bGUiLAogICJkZXBlbmRlbmNpZXMiOiB7CiAgICAic29ja2V0LmlvIjogIl40LjguMSIKICB9Cn0K"};

package/cli/src/zenohDev.mjs

@@ -0,0 +1,75 @@
+// Remote-robot Zenoh dev networking helpers, shared by `muscat-pk dev` and
+// standalone `muscat-pk dev:back`.
+//
+// The plugin backend runs in a Docker container. When it connects to a REMOTE
+// robot, rainbow.rb_sdk registers this machine as a Zenoh peer and the robot's
+// `common` service connects BACK to the advertised ip:port to form the mesh.
+// Inside a container, the SDK's own _detect_local_ip() returns the container's
+// internal IP (unreachable from the robot) and lets the OS pick a random listen
+// port (unpublished) — so the reverse connection never lands and SDK calls like
+// call_move_j get no reply. We fix both ends:
+//   - MUSCAT_ZENOH_ADVERTISE_HOST → the host's LAN IP toward the robot, which
+//     devBack's entry script uses to override _detect_local_ip.
+//   - MUSCAT_ZENOH_PORT → a fixed, host-published listen port the robot can reach.
+import { createSocket } from "node:dgram";
+import { createServer } from "node:net";
+
+export const DEFAULT_ZENOH_DEV_PORT = 53917;
+export const LOCAL_HOSTS = new Set(["", "localhost", "127.0.0.1", "::1"]);
+
+export const isRemoteRobot = (robotIp) => !!robotIp && !LOCAL_HOSTS.has(robotIp);
+
+/** The local interface IP the OS would use to reach `host` (no packet sent). */
+export function detectRouteAddress(host) {
+  return new Promise((resolve) => {
+    const socket = createSocket("udp4");
+    socket.once("error", () => {
+      socket.close();
+      resolve("");
+    });
+    socket.connect(80, host, () => {
+      const address = socket.address();
+      socket.close();
+      resolve(typeof address === "object" ? address.address : "");
+    });
+  });
+}
+
+/** `preferred` if free, otherwise an OS-assigned free port. */
+export function getFreePort(preferred) {
+  return new Promise((resolve) => {
+    const srv = createServer();
+    srv.once("error", () => {
+      const fallback = createServer();
+      fallback.listen(0, "0.0.0.0", () => {
+        const address = fallback.address();
+        const port = typeof address === "object" && address ? address.port : preferred;
+        fallback.close(() => resolve(port));
+      });
+    });
+    srv.listen(preferred, "0.0.0.0", () => srv.close(() => resolve(preferred)));
+  });
+}
+
+/**
+ * Compute and set MUSCAT_ZENOH_ADVERTISE_HOST / MUSCAT_ZENOH_PORT for a remote
+ * robot, unless already set by a parent command (idempotent). No-op for a local
+ * robot. Returns the resolved { advertiseHost, zenohPort } (or null if local).
+ */
+export async function ensureRemoteZenohEnv(robotIp, { log } = {}) {
+  if (!isRemoteRobot(robotIp)) return null;
+  // Already set (e.g. `muscat-pk dev` computed it before starting the bridge).
+  if (process.env.MUSCAT_ZENOH_PORT) {
+    return {
+      advertiseHost: process.env.MUSCAT_ZENOH_ADVERTISE_HOST || "",
+      zenohPort: Number(process.env.MUSCAT_ZENOH_PORT),
+    };
+  }
+  const advertiseHost =
+    process.env.MUSCAT_ZENOH_ADVERTISE_HOST || (await detectRouteAddress(robotIp));
+  const zenohPort = await getFreePort(DEFAULT_ZENOH_DEV_PORT);
+  if (advertiseHost) process.env.MUSCAT_ZENOH_ADVERTISE_HOST = advertiseHost;
+  process.env.MUSCAT_ZENOH_PORT = String(zenohPort);
+  log?.step?.(`remote Zenoh dev peer → ${advertiseHost || "(auto)"}:${zenohPort}`);
+  return { advertiseHost, zenohPort };
+}

package/cli/storybook-dist/project.json

@@ -1 +1 @@
-{"generatedAt":1783639482772,"userSince":1750932757926,"hasCustomBabel":false,"hasCustomWebpack":false,"hasStaticDirs":false,"hasStorybookEslint":true,"refCount":0,"testPackages":{"@vitest/browser":"3.2.4","@vitest/coverage-v8":"3.2.4","playwright":"1.59.1","vitest":"3.2.4"},"hasRouterPackage":false,"monorepo":"Turborepo","packageManager":{"type":"yarn","version":"berry","agent":"yarn@berry"},"preview":{"usesGlobals":false},"framework":{"name":"@storybook/react-vite","options":{}},"builder":"@storybook/builder-vite","renderer":"@storybook/react","portableStoriesFileCount":0,"applicationFileCount":0,"storybookVersion":"8.6.18","storybookVersionSpecifier":"^8.6.4","language":"typescript","storybookPackages":{"@chromatic-com/storybook":{"version":"3.2.7"},"@storybook/addon-essentials":{"version":"8.6.18"},"@storybook/addon-links":{"version":"8.6.18"},"@storybook/addon-onboarding":{"version":"8.6.18"},"@storybook/addon-themes":{"version":"8.6.18"},"@storybook/blocks":{"version":"8.6.18"},"@storybook/experimental-addon-test":{"version":"8.6.18"},"@storybook/react":{"version":"8.6.18"},"@storybook/react-vite":{"version":"8.6.18"},"@storybook/test":{"version":"8.6.18"},"@storybook/theming":{"version":"8.6.18"},"eslint-plugin-storybook":{"version":"0.11.6"},"storybook":{"version":"8.6.18"},"storybook-addon-react-docgen":{"version":"1.2.44"}},"addons":{"$SNIP/node_modules/@storybook/addon-links":{"version":null},"$SNIP/node_modules/@storybook/addon-essentials":{"version":null},"$SNIP/node_modules/@chromatic-com/storybook":{"version":null},"$SNIP/node_modules/@storybook/addon-themes":{"version":null},"$SNIP/node_modules/@storybook/experimental-addon-test":{"version":null}}}
+{"generatedAt":1783659929067,"userSince":1750932757926,"hasCustomBabel":false,"hasCustomWebpack":false,"hasStaticDirs":false,"hasStorybookEslint":true,"refCount":0,"testPackages":{"@vitest/browser":"3.2.4","@vitest/coverage-v8":"3.2.4","playwright":"1.59.1","vitest":"3.2.4"},"hasRouterPackage":false,"monorepo":"Turborepo","packageManager":{"type":"yarn","version":"berry","agent":"yarn@berry"},"preview":{"usesGlobals":false},"framework":{"name":"@storybook/react-vite","options":{}},"builder":"@storybook/builder-vite","renderer":"@storybook/react","portableStoriesFileCount":0,"applicationFileCount":0,"storybookVersion":"8.6.18","storybookVersionSpecifier":"^8.6.4","language":"typescript","storybookPackages":{"@chromatic-com/storybook":{"version":"3.2.7"},"@storybook/addon-essentials":{"version":"8.6.18"},"@storybook/addon-links":{"version":"8.6.18"},"@storybook/addon-onboarding":{"version":"8.6.18"},"@storybook/addon-themes":{"version":"8.6.18"},"@storybook/blocks":{"version":"8.6.18"},"@storybook/experimental-addon-test":{"version":"8.6.18"},"@storybook/react":{"version":"8.6.18"},"@storybook/react-vite":{"version":"8.6.18"},"@storybook/test":{"version":"8.6.18"},"@storybook/theming":{"version":"8.6.18"},"eslint-plugin-storybook":{"version":"0.11.6"},"storybook":{"version":"8.6.18"},"storybook-addon-react-docgen":{"version":"1.2.44"}},"addons":{"$SNIP/node_modules/@storybook/addon-links":{"version":null},"$SNIP/node_modules/@storybook/addon-essentials":{"version":null},"$SNIP/node_modules/@chromatic-com/storybook":{"version":null},"$SNIP/node_modules/@storybook/addon-themes":{"version":null},"$SNIP/node_modules/@storybook/experimental-addon-test":{"version":null}}}

package/cli/templates/common/package.json

@@ -13,6 +13,8 @@
     "@types/react": "^19.0.10",
     "@types/react-dom": "^19.0.4",
     "@vitejs/plugin-react": "^4.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
     "tailwindcss": "^4.1.0",
     "typescript": "^5.8.0",
     "vite": "^6.0.0"

package/cli/vite.mjs

@@ -257,6 +257,17 @@ export function muscat(options = {}) {
       apply: "serve",
       config: () => {
         return {
+          // NOTE: even with sharedRuntimeBase set (so `alias` is empty and our
+          // resolveId below wins for every actual import), @vitejs/plugin-react
+          // still unconditionally adds react/react-dom/jsx-(dev-)runtime to
+          // optimizeDeps.include for Fast Refresh — Vite merges every plugin's
+          // optimizeDeps (arrays are concatenated, not overridden), so esbuild's
+          // pre-bundle scanner still tries to statically resolve those on disk.
+          // That's why the scaffold template keeps react/react-dom as local
+          // devDependencies even in shared-runtime mode: purely so this static
+          // scan has something real to resolve. The actual dev-server imports
+          // never reach that local copy — resolveId (enforce: "pre") below
+          // always wins first and redirects to the host's instance.
           resolve: {
             alias: sharedRuntimeBase ? [] : reactAliases(pluginRoot),
             dedupe: ["react", "react-dom"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rainbow-robotics/muscat-plugin-kit",
-  "version": "0.1.2-dev.50",
+  "version": "0.1.2-dev.52",
   "type": "module",
   "engines": {
     "node": ">=20"
@@ -53,8 +53,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@rainbow-robotics/plugin-ui": "0.1.2-dev.50",
-    "@rainbow-robotics/preview-host": "0.1.2-dev.50",
+    "@rainbow-robotics/plugin-ui": "0.1.2-dev.52",
+    "@rainbow-robotics/preview-host": "0.1.2-dev.52",
     "postcss": "^8.5.8",
     "socket.io": "^4.8.1",
     "typescript": "^5.8.0",