@rainbow-robotics/muscat-plugin-kit 1.10.2-dev.6 → 1.10.2-dev.7

package/cli/bin/muscat-pk.mjs

@@ -121,6 +121,9 @@ async function main() {
       case "storybook":
         return await runStorybook(args);
       case "mcp": {
+        // Relay by default so `muscat-pk update` reaches a running session; --serve is the server.
+        if (args[0] !== "--serve" && args[0] !== "--install" && args[0] !== "install")
+          return (await import("../src/mcpProxy.mjs")).runMcpProxy();
         const { runMcp, installMcp } = await import("../src/mcp.mjs");
         if (args[0] === "--install" || args[0] === "install")
           return installMcp(args[1]);

package/cli/src/build.mjs

@@ -13,9 +13,10 @@ import { chmodSync, cpSync, copyFileSync, existsSync, mkdirSync, readdirSync, re
 import { createRequire } from "node:module";
 import { basename, dirname, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
-import { execSync, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { ensureDocker, findPluginRoot, hasBin, humanSize, log, parseArgs, prompt } from "./util.mjs";
 import { assertManifest, manifestRuntime } from "./manifest.mjs";
+import { writeZip } from "./zip.mjs";
 
 // Find a usable JS runtime for running vite as a subprocess.
 // In binary (Bun) mode, try `bun` first (it can run vite directly), then node.
@@ -343,14 +344,8 @@ function packZip(pluginRoot) {
   const entries = ["dist"];
 
   log.step(`packing ${entries.join(", ")} → ${zipName}`);
-  try {
-    execSync(`zip -r -q "${zipPath}" ${entries.map((e) => `"${e}"`).join(" ")}`, {
-      cwd: pluginRoot,
-      stdio: "inherit",
-    });
-  } catch {
-    throw new Error("`zip` not found. Install zip or pack manually.");
-  }
+  // In-process, not the `zip` CLI: Windows has none, and it keeps the robot's executable bits (zip.mjs).
+  writeZip(zipPath, entries, pluginRoot);
 
   const zipBytes = statSync(zipPath).size;
   log.ok(`${zipName}   ${humanSize(zipBytes)}`);

package/cli/src/mcpProxy.mjs

@@ -0,0 +1,110 @@
+// `muscat-pk mcp` — AI clients keep one stdio MCP server per session, so a `muscat-pk update`
+// never reached a running one. This relays stdio to the real server (`mcp --serve`) and, when the
+// installed kit changes, swaps that child for the new one: it replays the client's initialize and
+// sends tools/list_changed, so the connection stays up and the next calls use the new tools.
+import { spawn } from "node:child_process";
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { kitRoot, resolveLocalCliBin } from "./util.mjs";
+
+const isBinaryMode = typeof Bun !== "undefined";
+const REINIT_ID = "__muscat_pk_reinit__";
+const POLL_MS = 3000;
+
+// Re-resolved on every (re)start: an update may install, bump or remove the project's local kit.
+function serverCommand() {
+  const local = resolveLocalCliBin(process.cwd());
+  if (local) {
+    return { cmd: isBinaryMode ? "node" : process.execPath, args: [local, "mcp", "--serve"], watch: resolve(local, "../../../package.json") };
+  }
+  if (isBinaryMode) return { cmd: process.execPath, args: ["mcp", "--serve"], watch: process.execPath };
+  return { cmd: process.execPath, args: [process.argv[1], "mcp", "--serve"], watch: resolve(kitRoot, "package.json") };
+}
+
+const stamp = (file) => {
+  try {
+    return `${file}:${statSync(file).mtimeMs}`;
+  } catch {
+    return file;
+  }
+};
+
+export function runMcpProxy() {
+  let child = null;
+  let initRequest = null;
+  const pending = new Set(); // client request ids the current child hasn't answered
+  const toClient = (msg) => process.stdout.write(JSON.stringify(msg) + "\n");
+
+  const failPending = () => {
+    for (const id of pending) {
+      toClient({ jsonrpc: "2.0", id, error: { code: -32603, message: "muscat-pk was updated during this call — retry it." } });
+    }
+    pending.clear();
+  };
+
+  const start = () => {
+    const { cmd, args } = serverCommand();
+    const c = spawn(cmd, args, { stdio: ["pipe", "pipe", "inherit"] });
+    createInterface({ input: c.stdout }).on("line", (line) => {
+      let msg = null;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        /* not JSON — pass through */
+      }
+      if (msg?.id === REINIT_ID) {
+        // Our replayed initialize: the client already has its answer from the first child.
+        c.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+        toClient({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+        return;
+      }
+      if (msg && msg.id !== undefined && !msg.method) pending.delete(msg.id);
+      process.stdout.write(line + "\n");
+    });
+    c.on("exit", () => {
+      if (c !== child) return; // replaced on purpose
+      child = null;
+      failPending();
+    });
+    child = c;
+    if (initRequest) c.stdin.write(JSON.stringify({ ...initRequest, id: REINIT_ID }) + "\n");
+  };
+
+  const restart = () => {
+    const old = child;
+    child = null;
+    old?.kill();
+    failPending();
+    start();
+  };
+
+  start();
+  let last = stamp(serverCommand().watch);
+  setInterval(() => {
+    const now = stamp(serverCommand().watch);
+    if (now !== last) {
+      last = now;
+      process.stderr.write("[muscat-pk] kit updated — restarting the MCP server\n");
+      restart();
+    }
+  }, POLL_MS).unref();
+
+  createInterface({ input: process.stdin })
+    .on("line", (line) => {
+      let msg = null;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        /* forward as-is */
+      }
+      if (msg?.method === "initialize") initRequest = msg;
+      if (!child) start(); // the server crashed — bring it back (it replays initialize)
+      if (msg && msg.id !== undefined && msg.method) pending.add(msg.id);
+      child.stdin.write(line + "\n");
+    })
+    .on("close", () => {
+      child?.kill();
+      process.exit(0);
+    });
+}

package/cli/src/templates-embedded.mjs

@@ -1,4 +1,4 @@
 // AUTO-GENERATED by cli/bundle-templates.mjs — do not edit.
 // ponytail: generated at publish time; not tracked in git.
-export const KIT_VERSION = "1.3.8-dev.3";
-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 already serves the
plugin gateway on port 10000. The CLI sees that, does not start its own local Muscat, and
your plugin backend connects to the robot's gateway — exactly what you want when
developing on the robot.

---

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

#### External endpoints (`plugin.router`)

`plugin.serve` / `plugin.subscribe` / `plugin.publish` are **internal only** (plugin
UI ↔ backend, plugin ↔ plugin). To expose an endpoint to the outside world —
REST, Socket.IO, TCP, MQTT, WebRTC — use `plugin.router`. Declaring one is a
single decorator; the running Muscat (`common`) picks it up without a restart,
and it disappears when the plugin stops or is removed.

> Requires a robot running `rainbow-rb-sdk` **0.0.9.dev5 or newer** (the SDK is
> provided by the plugin container at runtime). On older robots `plugin.router`
> does not exist and raises `AttributeError`.

```python
from rainbow.rb_sdk import RBPluginCall
from rainbow.rb_sdk.plugin import PluginRouteError

plugin = RBPluginCall()  # plugin_id comes from env RB_PLUGIN_ID


@plugin.router.on("/hello")                                  # all 5 transports
def hello(payload: dict, meta: dict):
    return {"msg": f"hi {payload.get('name')}"}              # return value = response body


@plugin.router.on("/admin", explicit_routes=["api"])         # REST only
def admin(payload, meta):
    if not (meta.get("principal") or {}).get("is_admin"):
        raise PluginRouteError(403, "admin only")            # becomes the external status
    ...


@plugin.router.subscribe("/cmd", explicit_events=["tcp"])    # receive external TCP publish
def on_cmd(payload: dict):
    ...


plugin.router.emit("/state", {"busy": True})                 # push to external subscribers
```

| API | Meaning | External address |
| --- | --- | --- |
| `router.on(path, explicit_routes=None)` | request/response handler | `common/plugin/{plugin_id}/{path}` (REST is always `POST`) |
| `router.subscribe(topic, explicit_events=None)` | receive external publishes | external side publishes to `common/plugin/{plugin_id}/{topic}` |
| `router.emit(topic, payload)` | plugin → external push | external side subscribes to `common/plugin/{plugin_id}/{topic}` |

- The `plugin_id` prefix is added by the SDK — write only the path in plugin code.
- Paths may have several segments (`/tool/echo`). Declaring the same path twice raises `ValueError`.
- Transport names: `api | socket | tcp | mqtt | webrtc`. `subscribe` accepts only `tcp | mqtt | webrtc`. Unknown names raise `ValueError`.
- `explicit_routes` / `explicit_events` of `None` means every transport. A request on a transport not listed gets 404.

Handler contract:

- Signature `(payload, meta)`, `(payload)` or `()` — only the arguments you declare are injected. Sync and async both work.
- `payload`: what the caller sent (for REST: JSON body merged with query params). The shape is up to the plugin.
- `meta`: `{"transport": "api"|"socket"|"tcp"|"mqtt"|"webrtc", "principal": dict | None}`. When the robot's login policy is on, `principal` holds the token subject. **Role checks are the plugin's job** — inspect `meta["principal"]` yourself.
- The return value is the response body (must be JSON-serialisable). `None` → empty response.
- Status codes: `raise PluginRouteError(code, message)`. Any other exception → 500 with `str(exc)` as the message.
- `subscribe` handlers take `(payload)` only and return nothing.

#### Calling plugin endpoints from outside

| Transport | How |
| --- | --- |
| REST | `POST /common/plugin/{plugin_id}/{path}` (through the api-gateway), JSON body |
| Socket.IO | emit event `common/plugin/{plugin_id}/{path}`, response arrives in the ack |
| TCP | topic `common/plugin/{plugin_id}/{path}` request / publish |
| MQTT | request: `common/plugin/{plugin_id}/{path}/__req__`, publish: `common/plugin/{plugin_id}/{topic}` |
| WebRTC | data channel topic `common/plugin/{plugin_id}/{path}` |

Auth: when the robot's login policy is on, a token is **required** (any role — GUEST passes). When it is off, calls go straight through. REST uses the same Bearer token as the other Muscat APIs.

```bash
curl -s -X POST http://<robot>/common/plugin/my-plugin/hello \
  -H 'Content-Type: application/json' -d '{"name":"kim"}'
```

| Situation | Status |
| --- | --- |
| No plugin declares that path / plugin is down / transport not allowed | 404 |
| Plugin did not answer within 10 s | 504 |
| `common` ↔ gateway not connected | 503 |
| Handler raised | 500 (`PluginRouteError` → its `code`) |

Known limits:

- A plugin path named `install` cannot be called over REST (`POST /common/plugin/{id}/install` is taken by the registry install route first). Socket/TCP are unaffected.
- Swagger shows one catch-all route, not per-plugin paths.
- The MQTT broker echoes to the sender: a plugin that `emit`s and `subscribe`s the same topic receives its own push over `mqtt`. Drop `mqtt` from `explicit_events` or use separate topics. (TCP is filtered by `sender_id`.)
- `on` and `subscribe` may share a name — they live in separate tables.

During `muscat-pk dev` the local Muscat runtime takes the `router.*` registrations
on its gateway (port `10000`), and its `common` (port `3000`) routes
`common/plugin/...` to them like on the robot — try
`curl http://localhost:3000/common/plugin/<plugin-id>/<path>`. After restarting the plugin process,
external calls may return 504 for up to about a minute (until the gateway notices
the old socket is gone), then 404 — that is expected.

#### 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:
    """Called once when my Step executes. Variable writes apply to the
    running program immediately + broadcast to other robots' main tasks."""
    count = await ctx.get_variable("counter")          # read an existing program variable
    await ctx.set_variable("counter", count + 1)       # update an existing variable — allowed
    await ctx.set_variable("RBP_TEST", 1)              # NEW variables must start with RBP_

    for i in range(100):
        await ctx.check_stop()   # auto-scoped to this Step's robot model
        await asyncio.sleep(0.5)

    await ctx.done()


async def background_monitor() -> None:
    """Resident task outside any Step. If no program is running,
    get returns None and set is silently ignored — always safe to call."""
    while True:
        await asyncio.sleep(1.0)

        # targets every running main task (no robot_model param — always broadcast)
        await ctx.set_variable("RBP_TEST", 3)

        # get options
        v1 = await ctx.get_variable("counter")                           # first value found in the whole tree
        v2 = await ctx.get_variable("counter", robot_model="C500920")    # a specific robot
        v3 = await ctx.get_variable("RBP_TEST", plugin_id="my-plugin")   # the value my-plugin last wrote

        if ctx.executor_state("C500920") == "paused":
            print("C500920 program is paused")


async def main() -> None:
    asyncio.create_task(background_monitor())
    await ctx.start()  # stays resident


asyncio.run(main())
```

#### Program variables & executor state (`PluginProgramContext`)

`rainbow.rb_sdk.PluginProgramContext` lets the plugin process interact with the
running program (PyFM): read/write program variables and observe execution
state — inside a Step handler or from a resident task, at any time.

- The `on_execute` handler is called **only when PyFM executes this plugin's
  Step**. One Step execution = one handler call, and the Step does not finish
  until you call `ctx.done()` — always call it.
- The plugin process itself stays resident after `ctx.start()`; executor state
  queries and variable access below keep working whether or not a Step is
  executing.

#### Variable naming rules (important)

PyFM variables are a **program-wide shared namespace**. One rule:

- **Modifying an existing variable** — the name passes as-is. Exchanging
  variables between the program and the plugin is the intended usage.
- **Creating a variable that doesn't exist** — the `RBP_` prefix is
  **required** (enforced by the SDK/server; a violation raises
  `RuntimeError`). Applies equally inside and outside Step execution.

For new variable names, a convention that includes the plugin id is strongly
recommended:

```
RBP_{plugin_id}_{name}

e.g. RBP_vision_detect_count, RBP_gripper_last_error
```

Why:

- `RBP_` — instantly identifies plugin-created variables in the program
  editor/UI.
- `{plugin_id}` — **prevents name collisions with other plugins.** If two
  plugins use the same name they overwrite the same variable (`RBP_` alone is
  not something the SDK guards against).

#### Reading / writing variables

```python
value = await ctx.get_variable("counter")                 # read (no name restriction)
await ctx.set_variable("counter", value + 1)              # modify existing variable — allowed
await ctx.set_variable("RBP_my-plugin_result", 42)        # create new variable — RBP_ required
```

`set_variable` always applies to **every running main task** (a plugin belongs
to muscat, not to a specific robot — there is no `robot_model` parameter):

| When | Own program | Other robots' main tasks |
|---|---|---|
| During own Step execution | via the control queryable — **immediate** | broadcast — each at its next Step boundary |
| Outside a Step (resident task, …) | resident endpoint — next Step boundary | same |

`get_variable` has options:

```python
await ctx.get_variable("counter")                          # search all main tasks (first value found)
await ctx.get_variable("counter", robot_model="C500920")   # a specific robot's value
await ctx.get_variable("RBP_TEST", plugin_id="A.plugin")   # the value that plugin last wrote
```

Caveats:

- If no program is running, `set_variable` is **silently ignored** and
  `get_variable` returns `None`. (`RuntimeError` is raised only for real
  errors, like the `RBP_` violation on a new variable — the message is tagged
  `[plugin:{id}]` with the offending plugin.)
- Rarely, a write can be lost if it races the worker's variable flush
  (lock-free read-modify-write). For important values, re-check and retry on
  the next cycle.

#### Per-plugin value storage (meta)

Besides the shared value, each variable entry records which plugin last wrote
what:

```python
# state_dict["variables"] — after A wrote 1 and B wrote 2
"RBP_TEST": {
    "value": 2,                                # shared slot = last written value
    "type": "local",
    "meta": {"writers": {"A.plugin": 1, "B.plugin": 2}},   # per-plugin record
}
```

So the exact value is recoverable even when names collide:

- Plugin SDK: `ctx.get_variable("RBP_TEST", plugin_id="A.plugin")` → `1`
- Program step expression: `COUNT = get_var("A.plugin", "RBP_TEST") + 1` → `2`
- A plain name (`RBP_TEST += 1`) uses the shared slot (last written value) → `3`

#### Executor state

Subscribes to the `muscat/executor/state` publish (0.8 s interval) and exposes
per-robot-model state:

```python
ctx.executor_state("C500920")   # "running" | "paused" | "waiting" | ... | None
ctx.executor_state()            # {"C500920": "paused", "amr": "running"}
ctx.is_paused("C500920")        # whether that model is paused
ctx.is_stopped("C500920")       # stop/error transition of a model seen active this run
```

- States: `idle | running | paused | waiting | stopped | post_start | completed | error`
- A model with no running task is `None` / absent from the dict.
- The publish interval is 0.8 s, so expect up to ~1 s of latency.
- With `IS_DEV=true` there is no publish at all — always `None`.

To get a callback at the moment the state changes, without polling:

```python
@ctx.on_executor_state_change
async def on_change(robot_model: str, state: str) -> None:
    if state == "paused":
        print(f"{robot_model} paused")
```

- Not called for repeated publishes of the same state — fires exactly once
  per per-model state change.
- An exception in the handler is only logged; state tracking keeps running.

#### Responding to pause / stop

```python
@ctx.on_execute
async def handle(args: dict) -> None:
    for i in range(100):
        # stop → CancelledError (propagated to the executor as a stop),
        # pause → waits here until resumed.
        # Inside on_execute this automatically watches only the robot model
        # executing this Step.
        await ctx.check_stop()

        ...  # actual work
        await asyncio.sleep(0.5)

    await ctx.done()
```

Scope priority for `check_stop` / `is_paused` / `is_stopped`:

1. `robot_model` given — that model only
2. Omitted inside `on_execute` — **only the model executing this Step**
   (passed in by the executor)
3. Omitted elsewhere (resident task, …) — all models

A handler doing long-running work must call `check_stop()` every loop
iteration so it reacts to pause/stop immediately. Without it, the plugin keeps
running even after the operator presses Stop.

Variables your plugin wants the Program page variable picker to offer must be
pre-declared in `manifest.json` under `"variables"` (see the manifest section
below).

### C++

C++ plugins use `cpp/` and are built with CMake inside Docker against the
Rainbow Robotics C++ SDK (see _C++ SDK_ below).

```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;
}
```

#### C++ SDK (`rainbow-rb-sdk-dev`)

Both C++ runtimes (`cpp`, `ros2` + `rclcpp`) link the Rainbow Robotics C++ SDK
from the apt package `rainbow-rb-sdk-dev`. The `muscat-pk` dev containers already
have it, so `muscat-pk dev` / `build` need nothing extra. To build outside the
container (your own Ubuntu 24.04 machine, or the robot PC):

```bash
curl -fsSL https://rainbowrobotics.github.io/rb-sdk/rb-sdk-apt-repo.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/rb-sdk-apt.gpg
echo 'deb [signed-by=/usr/share/keyrings/rb-sdk-apt.gpg] https://rainbowrobotics.github.io/rb-sdk stable main' | sudo tee /etc/apt/sources.list.d/rb-sdk.list
sudo apt update && sudo apt install rainbow-rb-sdk-dev
```

- CMake: `find_package(rb_sdk REQUIRED)` + `target_link_libraries(<target> rb_sdk::rb_sdk)` (C++20). pkg-config: `rb_sdk`.
- Headers: `<rainbow/rb_sdk/manipulate/rb_manipulate_sdk.hpp>` (`RBManipulateSDK`),
  `<rainbow/rb_sdk/program/plugin_program_context.hpp>` (`rb_plugin::PluginProgramContext`, for `program.panel` commands — the header's top comment has a full `main()` example).
- The binary is linked **dynamically**; `muscat-pk build` copies the matching `librb_sdk.so` into `dist/<arch>/lib/` (the robot has no SDK installed), so each plugin keeps the SDK version it was built with. The version is the one pinned in `CMakeLists.txt` (`find_package(rb_sdk <version> EXACT REQUIRED)`); change it with `muscat-pk sdk update <version>`.
- UI ↔ backend messaging works from C++ too: `rb_plugin::RBPluginCall` in `<rainbow/rb_sdk/plugin/rb_plugin.hpp>` (see the scaffolded `cpp/main.cpp`).

### ROS2 (rclpy)

ROS2 Python plugins use `ros2_ws/` with `runtime.rosClient: "rclpy"`. relative topic names are placed under the plugin's ROS namespace — the plugin id
with "." → "/" and "-" → "_" (`com.example.my-plugin` → `/com/example/my_plugin`), in dev
and on the robot. Use an absolute name (`/cmd_vel`) for topics shared with other nodes.
`RBPluginCall` works in the node module too (UI messaging and `plugin.router`).

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


#### Talking to an external PC over ROS 2

ROS 2 discovery stays on the robot (`ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST`; `muscat-pk dev`
runs the same), so robots on one LAN don't mix topics. Allow specific PCs from the plugin UI —
Muscat keeps the list per plugin, starts your backend with `ROS_STATIC_PEERS` set to it, and
restarts the plugin when it changes. Your ROS code needs no changes; the PC needs no extra settings.

```tsx
const rb = useRb();
const peers = await rb.rosPeers.get();               // ["192.168.0.50"]
await rb.rosPeers.set(["192.168.0.50", "192.168.0.51"]); // saves + restarts the plugin; rejects on a bad IP
```

- Per plugin: plugin B keeps its allowed PCs when plugin A (allowing the same PC) is stopped or removed.
- It opens communication; it is not access control — a PC that knows the robot's IP can still
  add the robot to its own `ROS_STATIC_PEERS`.
- In `muscat-pk dev` the list is kept in `.muscat-dev/ros-peers.json` (ROS 2 backends).

### ROS2 (rclcpp)

ROS2 C++ plugins use `ros2_ws/` with `runtime.rosClient: "rclcpp"`. The node links
the Rainbow C++ SDK the same way as the `cpp` runtime (see _C++ SDK_ above).

```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");
  }
};
```

---

## Video streaming (MediaMTX)

Muscat runs a MediaMTX media server. The backend publishes a stream over RTSP and
the UI plays it over WebRTC. `muscat-pk dev` runs the same server (or uses a local
Muscat's), so the addresses are identical in dev and on the robot.

| | Address |
| --- | --- |
| Publish (backend) | `rtsp://127.0.0.1:8554/<plugin_id>/<name>` |
| Play (UI) | `http://<host>:8889/<plugin_id>/<name>/` |

- Prefix the path with your plugin id — paths are shared with robot cameras and other plugins.
- The robot runtime has no ffmpeg, GStreamer or OpenCV; bring your own encoder (below).

**Backend (Python)** — use PyAV: add `av` and `numpy` to `requirements.txt`. Its wheels
include FFmpeg, so they ship in the ZIP like any other dependency.

```python
import fractions, time
import av, numpy as np

out = av.open("rtsp://127.0.0.1:8554/__PLUGIN_ID__/cam", mode="w", format="rtsp",
              options={"rtsp_transport": "tcp"})
stream = out.add_stream("libx264", rate=25, options={"preset": "ultrafast", "tune": "zerolatency"})
stream.width, stream.height, stream.pix_fmt = 640, 360, "yuv420p"

i = 0
while True:
    img = np.zeros((360, 640, 3), dtype=np.uint8)          # your RGB frame here
    frame = av.VideoFrame.from_ndarray(img, format="rgb24")
    frame.pts, frame.time_base = i, fractions.Fraction(1, 25)
    for packet in stream.encode(frame):
        out.mux(packet)
    i += 1
    time.sleep(1 / 25)
```

Run the encoder loop in a thread (or `asyncio.to_thread`) so it doesn't block the
`RBPluginCall` handlers.

**UI** — embed MediaMTX's WebRTC player. `location.hostname` is `localhost` in the
preview and the robot's address on the robot:

```tsx
const STREAM = "__PLUGIN_ID__/cam"; // the path the backend publishes

export default function Camera() {
  return (
    <iframe
      src={`${location.protocol}//${location.hostname}:8889/${STREAM}/`}
      allow="autoplay"
      className="aspect-video w-full border-0"
    />
  );
}
```

---

## 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
    }
  ],

  // optional: variables this plugin exposes to pyfm programs — the Program
  // page variable picker lists ONLY declared variables. name must start with
  // RBP_; description is optional but without it the UI can't explain the
  // variable, so write one.
  "variables": [
    { "name": "RBP_grip_force", "type": "number", "init": 0.5, "description": { "ko": "그리퍼 힘", "en": "Gripper force" } },
    { "name": "RBP_target_pose", "type": "array", "init": [0, 0, 0] }
  ],

  // 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` — the plugin's screens; when present it must contain at least one `toolbar` entry. Leave it out (or `[]`) for a backend-only plugin: no UI is built, and Node.js is not needed to build it
- `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
- `variables` — optional array of `{ name, type, init, description? }`:
  - `name` — must start with `RBP_`, then letters/digits/underscore; unique per plugin
  - `type` — `"number" | "string" | "array"`
  - `init` — required initial value, must match `type`
  - `description` — optional `string` or i18n object (`en` required in object form)

`muscat-pk build` throws on any validation error. `muscat-pk dev` prints
warnings — except `variables` errors (e.g. a name without the `RBP_` prefix),
which are hard errors in `dev` / `dev:back` too.

**Backend port rules:**
- Declare a port only if your backend opens a TCP server/listener.
- **Every listening TCP port must be declared.** `muscat-pk dev` and
  `muscat-pk dev:back` watch the backend and stop it the moment it opens a port
  that is not in `ports`. A port outside `28600-28999` can't be declared, so it
  must not be opened either — picking e.g. `5500` is not a way around the rule.
  It would escape this check *and* the robot's install-time conflict check, and
  only collide once it's running on a robot.
- Reserved ports include `502`, `2222`, `4840`, `5170-5179`, `8000-8999`,
  `10000`, `30004`, `34964`, `44818`, `50000-50005`, and `50051`.
- The robot rejects installation (HTTP 409) if a declared port is reserved,
  out of range, or already claimed by another enabled plugin.

**Reaching your backend's ports during development:**
- Declared ports are published to `127.0.0.1` on your machine, so
  `curl http://127.0.0.1:28600` works from the host on macOS, Windows, and Linux.
- On native Linux the dev container uses host networking, so the ports are on
  the host already.
- If a declared port is already taken on your machine, `muscat-pk dev` warns and
  skips publishing that one — the backend still listens inside the container.

---

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

> Switching between a Python and a C++ backend asks whether to replace this README with the matching one (the old file is kept as `README.md.bak`). Add `--readme` to answer yes without the prompt.

---

## 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; with `lang: "cpp"`, the C++ SDK headers
  (`rainbow-rb-sdk-dev`, read out of the `muscat-pk` cpp dev image — build it
  once with `muscat-pk dev:back`).

**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** — register once with:

```bash
muscat-pk mcp --install codex
```

This appends the server to `~/.codex/config.toml` (idempotent — safe to run
again). Equivalent manual config:

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

> Building the other arch (e.g. arm64 on an amd64 PC) runs in an emulated container for
> C++ backends. Docker Desktop has it built in; on Linux enable it once with
> `docker run --privileged --rm tonistiigi/binfmt --install all`, or pass `--arch` for one arch.

- 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":"ewogICJpZCI6ICJfX1BMVUdJTl9JRF9fIiwKICAibmFtZSI6ICJfX1BMVUdJTl9OQU1FX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAibWluTXVzY2F0VmVyc2lvbiI6ICIxLjAuMCIsCiAgImF1dGhvciI6ICJfX1BMVUdJTl9BVVRIT1JfXyIsCiAgImVtYWlsIjogIl9fUExVR0lOX0VNQUlMX18iLAogICJkZXNjcmlwdGlvbiI6IHsKICAgICJrbyI6ICIiLAogICAgImVuIjogIiIKICB9LAogICJpY29ucyI6ICJhc3NldHMvaWNvbi5zdmciLAogICJ0YXJnZXRNb2RlbHMiOiAiYWxsIiwKICAidGFyZ2V0Q2F0ZWdvcnlzIjogImFsbCIsCiAgImNvbnRyaWJ1dGVzIjogWwogICAgewogICAgICAicG9pbnQiOiAidG9vbGJhciIsCiAgICAgICJpY29uIjogImFzc2V0cy9pY29uLnN2ZyIsCiAgICAgICJsYWJlbCI6IHsgImtvIjogIl9fUExVR0lOX05BTUVfXyIsICJlbiI6ICJfX1BMVUdJTl9OQU1FX18iIH0sCiAgICAgICJ1aSI6ICJjb250ZW50IiwKICAgICAgIm9wZW5zIjogInBvcG92ZXIiCiAgICB9CiAgXSwKICAidmFyaWFibGVzIjogW10sCiAgInJ1bnRpbWUiOiB7ICJ0eXBlIjogIl9fUlVOVElNRV9UWVBFX18iLCAiZW50cnkiOiAibWFpbi5weSIgfQp9Cg==","common/package.json":"ewogICJuYW1lIjogIl9fUExVR0lOX0lEX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAicHJpdmF0ZSI6IHRydWUsCiAgInR5cGUiOiAibW9kdWxlIiwKICAiZGVwZW5kZW5jaWVzIjogewogICAgIkByYWluYm93LXJvYm90aWNzL3BsdWdpbi11aSI6ICJfX1JCX1ZFUlNJT05fXyIKICB9LAogICJkZXZEZXBlbmRlbmNpZXMiOiB7CiAgICAiQHRhaWx3aW5kY3NzL3ZpdGUiOiAiXjQuMS4wIiwKICAgICJAcmFpbmJvdy1yb2JvdGljcy9tdXNjYXQtcGx1Z2luLWtpdCI6ICJfX1JCX1ZFUlNJT05fXyIsCiAgICAiQHJhaW5ib3ctcm9ib3RpY3MvcHJldmlldy1ob3N0IjogIl9fUkJfVkVSU0lPTl9fIiwKICAgICJAdHlwZXMvcmVhY3QiOiAiXjE5LjAuMTAiLAogICAgIkB0eXBlcy9yZWFjdC1kb20iOiAiXjE5LjAuNCIsCiAgICAiQHZpdGVqcy9wbHVnaW4tcmVhY3QiOiAiXjQuMC4wIiwKICAgICJyZWFjdCI6ICJeMTkuMC4wIiwKICAgICJyZWFjdC1kb20iOiAiXjE5LjAuMCIsCiAgICAidGFpbHdpbmRjc3MiOiAiXjQuMS4wIiwKICAgICJ0eXBlc2NyaXB0IjogIl41LjguMCIsCiAgICAidml0ZSI6ICJeNi4wLjAiCiAgfQp9Cg==","common/py/main.py":"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","common/requirements.txt":"cmFpbmJvdy1yYi1zZGs9PTAuMTAuMgpyYWluYm93LXJiLWZsYXQtYnVmZmVycz09MC4xMC4yCnJhaW5ib3ctcmItemVub2g9PTAuMTAuMgpyZXF1ZXN0cz09Mi4zNC4yCg==","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":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fIENYWCkKCnNldChDTUFLRV9DWFhfU1RBTkRBUkQgMjApCnNldChDTUFLRV9DWFhfU1RBTkRBUkRfUkVRVUlSRUQgT04pCgojIFJhaW5ib3cgUm9ib3RpY3MgQysrIFNESyDigJQgcHJvdmlkZWQgYnkgdGhlIGFwdCBwYWNrYWdlIHJhaW5ib3ctcmItc2RrLWRldgojIChwcmUtaW5zdGFsbGVkIGluIHRoZSBtdXNjYXQtcGsgZGV2IGNvbnRhaW5lcikuIFRoZSB2ZXJzaW9uIGhlcmUgaXMgdGhlIG9uZSB0aGUKIyBkZXYgY29udGFpbmVyIGluc3RhbGxzOyBjaGFuZ2UgaXQgd2l0aCBgbXVzY2F0LXBrIHNkayB1cGRhdGUgPHZlcnNpb24+YC4KZmluZF9wYWNrYWdlKHJiX3NkayAwLjEwLjIgRVhBQ1QgUkVRVUlSRUQpCgojIFRoZSBleGVjdXRhYmxlIG5hbWUgbXVzdCBtYXRjaCBydW50aW1lLmVudHJ5IGluIG1hbmlmZXN0Lmpzb24uCmFkZF9leGVjdXRhYmxlKF9fUExVR0lOX1NMVUdfXyBtYWluLmNwcCkKdGFyZ2V0X2xpbmtfbGlicmFyaWVzKF9fUExVR0lOX1NMVUdfXyBQUklWQVRFIHJiX3Nkazo6cmJfc2RrKQo=","cpp/cpp/main.cpp":"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","readme-cpp/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 (C++ rebuild + restart in 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()
├─ cpp/
│   ├─ CMakeLists.txt   # links rb_sdk::rb_sdk (C++ SDK)
│   └─ main.cpp         # C++ 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)
```

> ROS2 (rclcpp) plugins have `ros2_ws/` instead of `cpp/`.

---

## 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 already serves the
plugin gateway on port 10000. The CLI sees that, does not start its own local Muscat, and
your plugin backend connects to the robot's gateway — exactly what you want when
developing on the robot.

---

## 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 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`) from `cpp/main.cpp`, 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" } }
```

### C++ (`cpp`)

C++ plugins build `cpp/` with CMake and run the executable named by
`manifest.json` → `runtime.entry`. The Rainbow Robotics C++ SDK
(`rainbow-rb-sdk-dev`) is pre-installed in the `muscat-pk` dev container — you
don't install anything locally.

```json
{ "runtime": { "type": "cpp", "entry": "__PLUGIN_SLUG__" } }
```

```cmake
# cpp/CMakeLists.txt — the version is the SDK the dev container installs (muscat-pk sdk update <version>)
find_package(rb_sdk 0.10.2 EXACT REQUIRED)
add_executable(__PLUGIN_SLUG__ main.cpp)           # name must equal runtime.entry
target_link_libraries(__PLUGIN_SLUG__ PRIVATE rb_sdk::rb_sdk)
```

Editor support: the SDK is installed only inside the dev container, so `muscat-pk new` (and later
`dev` / `build` / `type change`) copies its headers to `.muscat-dev/sysroot` and writes a `Muscat`
configuration to `.vscode/c_cpp_properties.json`. VS Code's C/C++ extension then resolves `rb_sdk`
names. The copies follow the SDK version above; the build itself never uses them. ROS 2 headers
(`rclcpp`) are not copied.

Headers live under `<rainbow/rb_sdk/...>`:

| Header | Class | Use |
| --- | --- | --- |
| `plugin/rb_plugin.hpp` | `rb_plugin::RBPluginCall` | plugin UI ↔ backend, external endpoints (`router()`) |
| `manipulate/rb_manipulate_sdk.hpp` | `RBManipulateSDK` | control a manipulator |
| `program/rb_program_sdk.hpp` | `RBProgramSDK` | program-side helpers |
| `program/plugin_program_context.hpp` | `rb_plugin::PluginProgramContext` | `program.panel` commands |
| `zenoh_client.hpp` | `ZenohClient` | low-level pub/sub/query |

Payloads are `nlohmann::json` (`#include <nlohmann/json.hpp>`, installed with the SDK).

#### Talking to the plugin UI (`RBPluginCall`)

```cpp
#include <rainbow/rb_sdk/plugin/rb_plugin.hpp>
#include <nlohmann/json.hpp>

using nlohmann::json;
using rb_plugin::RBPluginCall;

int main() {
  // plugin id comes from env RB_PLUGIN_ID (set by muscat-pk dev and by the robot)
  auto plugin = RBPluginCall::get_instance(RBPluginCall::resolve_plugin_id(std::nullopt));

  plugin->publish("state", {{"ready", true}});                 // UI: rb.sub("state", ...)

  auto sub = plugin->subscribe("event",                        // UI: rb.pub("event", ...)
      [](const std::string& topic, const json& payload) { /* ... */ });

  plugin->serve("tool/echo", [](const json& payload) {         // UI: await rb.action("tool/echo", ...)
    return json{{"echo", payload}};
  });

  json res = plugin->call("tool/ping", {{"hello", "plugin"}}, 5.0);  // UI answers with rb.serve("tool/ping", ...)

  for (;;) std::this_thread::sleep_for(std::chrono::seconds(1));    // stay resident
}
```

| C++ | UI (`useRb()`) |
| --- | --- |
| `plugin->serve(topic, fn)` | `await rb.action(topic, payload)` |
| `plugin->subscribe(topic, fn)` | `rb.pub(topic, payload)` |
| `plugin->publish(topic, payload)` | `rb.sub(topic, handler)` |
| `plugin->call(topic, payload, timeout_sec)` | `rb.serve(topic, handler)` |

- Keep the `Subscription` returned by `subscribe`; pass it to `plugin->unsubscribe(std::nullopt, sub)` to remove just that one.
- `call` throws `rb_plugin::RBPluginGatewayError` when the gateway is down or the UI doesn't answer in time.

#### External endpoints (`router()`)

`serve` / `subscribe` / `publish` are **internal only** (plugin UI ↔ backend).
To expose an endpoint to the outside world — REST, Socket.IO, TCP, MQTT,
WebRTC — use `plugin->router()`. The running Muscat (`common`) picks it up
without a restart, and it disappears when the plugin stops.

```cpp
auto& router = plugin->router();

router.on("/hello", [](const json& payload, const json& meta) {       // all 5 transports
  return json{{"msg", "hi " + payload.value("name", std::string("there"))}};
});

router.on("/admin", [](const json& payload, const json& meta) {
  if (!meta.value("principal", json::object()).value("is_admin", false))
    throw rb_plugin::PluginRouteError(403, "admin only");              // becomes the external status
  return json::object();
}, std::vector<std::string>{"api"});                                  // REST only

router.subscribe("/cmd", [](const json& payload) { /* ... */ },
                 std::vector<std::string>{"tcp"});                    // receive external TCP publish

router.emit("/state", {{"busy", true}});                               // push to external subscribers
```

```bash
curl -s -X POST http://<robot>/common/plugin/<plugin_id>/hello \
  -H 'Content-Type: application/json' -d '{"name":"kim"}'
# → {"msg":"hi kim"}
```

| API | Meaning | External address |
| --- | --- | --- |
| `router.on(path, handler, explicit_routes)` | request/response handler | `common/plugin/{plugin_id}/{path}` (REST is always `POST`) |
| `router.subscribe(topic, handler, explicit_events)` | receive external publishes | external side publishes to `common/plugin/{plugin_id}/{topic}` |
| `router.emit(topic, payload)` | plugin → external push | external side subscribes to `common/plugin/{plugin_id}/{topic}` |

- `meta` = `{"transport": "api"|"socket"|"tcp"|"mqtt"|"webrtc", "principal": object | null}`. **Role checks are the plugin's job.**
- Transport names: `api | socket | tcp | mqtt | webrtc`; `subscribe` accepts only `tcp | mqtt | webrtc`. Unknown names or duplicate paths throw `std::invalid_argument`.
- Throw `rb_plugin::PluginRouteError(code, message)` to set the status; any other exception → 500.

| Situation | Status |
| --- | --- |
| No plugin declares that path / plugin is down / transport not allowed | 404 |
| Plugin did not answer within 10 s | 504 |
| `common` ↔ gateway not connected | 503 |

During `muscat-pk dev` the local Muscat runtime takes `router()` registrations on its
gateway and its `common` routes external calls to them like on the robot
(`curl http://localhost:3000/common/plugin/<plugin-id>/<path>`). After
restarting the plugin, external calls may return 504 for about a minute, then 404.

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

A `program.panel` contribution adds a **custom command** to the Program page.
Each time the program reaches that step, the host calls your backend through
`PluginProgramContext` with the step args (what the UI saved with `useRbSave`).

```cpp
#include <rainbow/rb_sdk/program/plugin_program_context.hpp>

using rb_plugin::PluginProgramContext;

int main() {
  PluginProgramContext ctx("__PLUGIN_ID__");

  ctx.set_execute_handler([&](const nlohmann::json& args) {
    auto count = ctx.get_variable("counter");                  // json; null if no program runs
    ctx.set_variable("counter", count.is_number() ? count.get<int>() + 1 : 1);
    ctx.set_variable("RBP___PLUGIN_SLUG___result", 42);        // NEW variables must start with RBP_

    try {
      for (int i = 0; i < 100; ++i) {
        ctx.check_stop();                                      // pause → blocks, stop → throws PluginStopped
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
      }
    } catch (const rb_plugin::PluginStopped&) {
      return;                                                  // program was stopped
    }
    ctx.done();                                                // always call — the step ends here
  });

  ctx.start();                                                 // does not block
  for (;;) std::this_thread::sleep_for(std::chrono::seconds(1));
}
```

- The step does not finish until you call `ctx.done()`.
- `set_execute_handler` must be called before `start()`.
- **New** variables need the `RBP_` prefix (`RBP_{plugin_id}_{name}` recommended); existing ones pass as-is.
- `get_variable(name, robot_model, plugin_id)` — optional filters: a specific robot, or the value a given plugin last wrote.
- Executor state: `ctx.executor_state_for("C500920")`, `ctx.executor_states()`, `ctx.is_paused()`, `ctx.is_stopped()`,
  or `ctx.set_state_change_handler([](const std::string& model, const std::string& state) { ... })`.
- A long-running handler must call `check_stop()` every iteration, or it keeps running after the operator presses Stop.

Variables the Program page variable picker should offer must be declared in
`manifest.json` under `"variables"`.

#### Controlling the robot

```cpp
#include <rainbow/rb_sdk/manipulate/rb_manipulate_sdk.hpp>

RBManipulateSDK manipulate;                       // on the robot: connects to the local Zenoh
manipulate.state.call_servocontrol("C500920", 1);

IPC::MoveInput_TargetT t;
t.tar_values = {0, 0, 90, 0, 90, 0};
t.tar_frame = 0;
t.tar_unit = 1;
manipulate.move.call_move_j("C500920", t, std::nullopt, MoveSpeedArg{1, 60.f, 120.f});
manipulate.move.call_move_wait("C500920", -1);
```

Remote dev (`muscat-pk dev --robot-ip <ip> --robot-token <token>`) sets
`MUSCAT_ROBOT_HOST` / `MUSCAT_ROBOT_TOKEN`; connect **before** registering
subscriptions, because `connect()` reopens the Zenoh session:

```cpp
if (const char* host = std::getenv("MUSCAT_ROBOT_HOST"))
  if (const char* token = std::getenv("MUSCAT_ROBOT_TOKEN"))
    manipulate.connect({.token = token, .host = host});
```

AMR and RB-Y1 SDKs are Python-only for now.

### ROS2 (rclcpp)

ROS2 C++ plugins use `ros2_ws/` with `runtime.rosClient: "rclcpp"`. The node
links the C++ SDK the same way (`find_package(rb_sdk)` + `rb_sdk::rb_sdk`); relative topic names are placed under the plugin's ROS namespace — the plugin id
with "." → "/" and "-" → "_" (`com.example.my-plugin` → `/com/example/my_plugin`), in dev
and on the robot. Use an absolute name (`/cmd_vel`) for topics shared with other nodes.

```cpp
#include "rclcpp/rclcpp.hpp"
#include <rainbow/rb_sdk/manipulate/rb_manipulate_sdk.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");
  }
};

int main(int argc, char** argv) {
  rclcpp::init(argc, argv);
  rclcpp::spin(std::make_shared<__PLUGIN_CLASS__Node>());
  rclcpp::shutdown();
  return 0;
}
```

`RBPluginCall` and `PluginProgramContext` work in an rclcpp node too — create
them in `main()` before `rclcpp::spin`.


#### Talking to an external PC over ROS 2

ROS 2 discovery stays on the robot (`ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST`; `muscat-pk dev`
runs the same), so robots on one LAN don't mix topics. Allow specific PCs from the plugin UI —
Muscat keeps the list per plugin, starts your backend with `ROS_STATIC_PEERS` set to it, and
restarts the plugin when it changes. Your ROS code needs no changes; the PC needs no extra settings.

```tsx
const rb = useRb();
const peers = await rb.rosPeers.get();               // ["192.168.0.50"]
await rb.rosPeers.set(["192.168.0.50", "192.168.0.51"]); // saves + restarts the plugin; rejects on a bad IP
```

- Per plugin: plugin B keeps its allowed PCs when plugin A (allowing the same PC) is stopped or removed.
- It opens communication; it is not access control — a PC that knows the robot's IP can still
  add the robot to its own `ROS_STATIC_PEERS`.
- In `muscat-pk dev` the list is kept in `.muscat-dev/ros-peers.json` (ROS 2 backends).

---

## Video streaming (MediaMTX)

Muscat runs a MediaMTX media server. The backend publishes a stream over RTSP and
the UI plays it over WebRTC. `muscat-pk dev` runs the same server (or uses a local
Muscat's), so the addresses are identical in dev and on the robot.

| | Address |
| --- | --- |
| Publish (backend) | `rtsp://127.0.0.1:8554/<plugin_id>/<name>` |
| Play (UI) | `http://<host>:8889/<plugin_id>/<name>/` |

- Prefix the path with your plugin id — paths are shared with robot cameras and other plugins.
- The robot runtime has no ffmpeg, GStreamer or OpenCV; bring your own encoder (below).

**Backend (C++)** — publish RTSP with an encoder library you bring (e.g. FFmpeg's
libavformat / libx264); the robot has none installed. Ship it with the plugin — see
_Bundling extra shared libraries_.

**UI** — embed MediaMTX's WebRTC player. `location.hostname` is `localhost` in the
preview and the robot's address on the robot:

```tsx
const STREAM = "__PLUGIN_ID__/cam"; // the path the backend publishes

export default function Camera() {
  return (
    <iframe
      src={`${location.protocol}//${location.hostname}:8889/${STREAM}/`}
      allow="autoplay"
      className="aspect-video w-full border-0"
    />
  );
}
```

---

## 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
    }
  ],

  // optional: variables this plugin exposes to pyfm programs — the Program
  // page variable picker lists ONLY declared variables. name must start with
  // RBP_; description is optional but without it the UI can't explain the
  // variable, so write one.
  "variables": [
    { "name": "RBP_grip_force", "type": "number", "init": 0.5, "description": { "ko": "그리퍼 힘", "en": "Gripper force" } },
    { "name": "RBP_target_pose", "type": "array", "init": [0, 0, 0] }
  ],

  // 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": "cpp", "entry": "__PLUGIN_SLUG__" },

  // 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` — the plugin's screens; when present it must contain at least one `toolbar` entry. Leave it out (or `[]`) for a backend-only plugin: no UI is built, and Node.js is not needed to build it
- `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
- `variables` — optional array of `{ name, type, init, description? }`:
  - `name` — must start with `RBP_`, then letters/digits/underscore; unique per plugin
  - `type` — `"number" | "string" | "array"`
  - `init` — required initial value, must match `type`
  - `description` — optional `string` or i18n object (`en` required in object form)

`muscat-pk build` throws on any validation error. `muscat-pk dev` prints
warnings — except `variables` errors (e.g. a name without the `RBP_` prefix),
which are hard errors in `dev` / `dev:back` too.

**Backend port rules:**
- Declare a port only if your backend opens a TCP server/listener.
- **Every listening TCP port must be declared.** `muscat-pk dev` and
  `muscat-pk dev:back` watch the backend and stop it the moment it opens a port
  that is not in `ports`. A port outside `28600-28999` can't be declared, so it
  must not be opened either — picking e.g. `5500` is not a way around the rule.
  It would escape this check *and* the robot's install-time conflict check, and
  only collide once it's running on a robot.
- Reserved ports include `502`, `2222`, `4840`, `5170-5179`, `8000-8999`,
  `10000`, `30004`, `34964`, `44818`, `50000-50005`, and `50051`.
- The robot rejects installation (HTTP 409) if a declared port is reserved,
  out of range, or already claimed by another enabled plugin.

**Reaching your backend's ports during development:**
- Declared ports are published to `127.0.0.1` on your machine, so
  `curl http://127.0.0.1:28600` works from the host on macOS, Windows, and Linux.
- On native Linux the dev container uses host networking, so the ports are on
  the host already.
- If a declared port is already taken on your machine, `muscat-pk dev` warns and
  skips publishing that one — the backend still listens inside the container.

---

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

---

## C++ SDK & dependencies

The dev container has the C++ SDK (`rainbow-rb-sdk-dev`) pre-installed — no local
install needed. The SDK version is the one pinned in `CMakeLists.txt` (`find_package(rb_sdk <version> EXACT REQUIRED)`). Pick a different one with:

```bash
muscat-pk sdk update <version>
```

`muscat-pk build` copies the matching `librb_sdk.so` next to your binary
(`dist/<arch>/lib/`, or `install-<arch>/<pkg>/lib/` for rclcpp), so the robot needs no SDK
install and each plugin keeps the SDK version it was built with.

Other libraries: install them in the build (e.g. vendor them under `cpp/` and
`add_subdirectory`, or link statically) — the robot only has Ubuntu 24.04 base
libraries.

To use the SDK outside a plugin (your own Ubuntu 24.04 machine):

```bash
curl -fsSL https://rainbowrobotics.github.io/rb-sdk/rb-sdk-apt-repo.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/rb-sdk-apt.gpg
echo 'deb [signed-by=/usr/share/keyrings/rb-sdk-apt.gpg] https://rainbowrobotics.github.io/rb-sdk stable main' | sudo tee /etc/apt/sources.list.d/rb-sdk.list
sudo apt update && sudo apt install rainbow-rb-sdk-dev
```


### Bundling extra shared libraries

The robot only has Ubuntu 24.04 base libraries. Copy any other `.so` your executable
needs into `${CMAKE_BINARY_DIR}/lib` — `muscat-pk build` ships that folder as
`dist/<arch>/lib/` and the executable finds it via its RPATH (`$ORIGIN/lib`):

```cmake
# cpp/CMakeLists.txt — third_party/ holds prebuilt libs for amd64 / arm64
set(ARCH_DIR ${CMAKE_SOURCE_DIR}/third_party/${CMAKE_SYSTEM_PROCESSOR})
target_link_libraries(__PLUGIN_SLUG__ PRIVATE ${ARCH_DIR}/libfoo.so)
add_custom_command(TARGET __PLUGIN_SLUG__ POST_BUILD
  COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/lib
  COMMAND ${CMAKE_COMMAND} -E copy ${ARCH_DIR}/libfoo.so ${CMAKE_BINARY_DIR}/lib/)
```

Build them for both arches (`x86_64`, `aarch64`) on Ubuntu 24.04 so they match the robot.
Static linking works too and needs no bundling. For an rclcpp node, `install(FILES ... DESTINATION lib)`
instead — the node finds `install-<arch>/<pkg>/lib/` the same way.
---

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

> Switching between a Python and a C++ backend asks whether to replace this README with the matching one (the old file is kept as `README.md.bak`). Add `--readme` to answer yes without the prompt.

---

## 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; with `lang: "cpp"`, the C++ SDK headers
  (`rainbow-rb-sdk-dev`, read out of the `muscat-pk` cpp dev image — build it
  once with `muscat-pk dev:back`).

**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** — register once with:

```bash
muscat-pk mcp --install codex
```

This appends the server to `~/.codex/config.toml` (idempotent — safe to run
again). Equivalent manual config:

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

> Building the other arch (e.g. arm64 on an amd64 PC) runs in an emulated container for
> C++ backends. Docker Desktop has it built in; on Linux enable it once with
> `docker run --privileged --rm tonistiigi/binfmt --install all`, or pass `--arch` for one arch.

- Builds `ui/content.tsx` → `dist/content.js` (minified)
- Compiles `cpp/` (Release) in the Ubuntu 24.04 container per arch → `dist/<arch>/<entry>` + `dist/<arch>/lib/librb_sdk.so.*`
- ROS2 (rclcpp): runs `colcon build` per arch → `dist/ros2_ws/install-<arch>/`
- Copies `assets/`, `manifest.json`, and `README*.md` into `dist/`
- 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
│   ├─ amd64/            # cpp: <entry> + lib/librb_sdk.so.*
│   ├─ arm64/
│   └─ ros2_ws/          # rclcpp: install-amd64/, install-arm64/
```

---

## All commands

```bash
muscat-pk dev        # UI + backend
muscat-pk dev:ui     # UI preview only (preview-host)
muscat-pk dev:back   # backend only (C++ rebuild + restart in 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 update         # update muscat-plugin-kit itself
muscat-pk uninstall      # remove muscat-pk itself
```
","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":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fKQoKaWYoTk9UIENNQUtFX0NYWF9TVEFOREFSRCkKICBzZXQoQ01BS0VfQ1hYX1NUQU5EQVJEIDE3KQplbmRpZigpCgpmaW5kX3BhY2thZ2UoYW1lbnRfY21ha2UgUkVRVUlSRUQpCmZpbmRfcGFja2FnZShyY2xjcHAgUkVRVUlSRUQpCiMgUmFpbmJvdyBSb2JvdGljcyBDKysgU0RLIChhcHQ6IHJhaW5ib3ctcmItc2RrLWRldiwgcHJlLWluc3RhbGxlZCBpbiB0aGUgZGV2CiMgY29udGFpbmVyKS4gVGhlIHZlcnNpb24gaGVyZSBpcyB0aGUgb25lIHRoZSBkZXYgY29udGFpbmVyIGluc3RhbGxzOyBjaGFuZ2UgaXQKIyB3aXRoIGBtdXNjYXQtcGsgc2RrIHVwZGF0ZSA8dmVyc2lvbj5gLgpmaW5kX3BhY2thZ2UocmJfc2RrIDAuMTAuMiBFWEFDVCBSRVFVSVJFRCkKCmFkZF9leGVjdXRhYmxlKF9fUExVR0lOX1NMVUdfX19ub2RlIHNyYy9ub2RlLmNwcCkKYW1lbnRfdGFyZ2V0X2RlcGVuZGVuY2llcyhfX1BMVUdJTl9TTFVHX19fbm9kZSByY2xjcHApCnRhcmdldF9saW5rX2xpYnJhcmllcyhfX1BMVUdJTl9TTFVHX19fbm9kZSByYl9zZGs6OnJiX3NkaykKCmluc3RhbGwoVEFSR0VUUyBfX1BMVUdJTl9TTFVHX19fbm9kZQogIERFU1RJTkFUSU9OIGxpYi8ke1BST0pFQ1RfTkFNRX0pCgphbWVudF9wYWNrYWdlKCkK","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":"Ly8gX19QTFVHSU5fTkFNRV9fIOKAlCBST1MyIG5vZGUgKHJjbGNwcCkuCi8vCi8vIFJlbGF0aXZlIHRvcGljIG5hbWVzIGxhbmQgdW5kZXIgdGhlIHBsdWdpbidzIFJPUyBuYW1lc3BhY2UgKHBsdWdpbiBpZCB3aXRoCi8vICIuIiDihpIgIi8iLCAiLSIg4oaSICJfIik7IHVzZSBhbiBhYnNvbHV0ZSBuYW1lICgiL2NtZF92ZWwiKSBmb3Igc2hhcmVkIHRvcGljcy4KLy8gVUkgbWVzc2FnaW5nIC8gZXh0ZXJuYWwgZW5kcG9pbnRzOiByYl9wbHVnaW46OlJCUGx1Z2luQ2FsbCAocGx1Z2luL3JiX3BsdWdpbi5ocHApLgojaW5jbHVkZSAicmNsY3BwL3JjbGNwcC5ocHAiCi8vIFJhaW5ib3cgUm9ib3RpY3MgQysrIFNESyAobGlua2VkIGFzIHJiX3Nkazo6cmJfc2RrKTogUkJNYW5pcHVsYXRlU0RLIGV0Yy4KI2luY2x1ZGUgPHJhaW5ib3cvcmJfc2RrL21hbmlwdWxhdGUvcmJfbWFuaXB1bGF0ZV9zZGsuaHBwPgoKY2xhc3MgX19QTFVHSU5fQ0xBU1NfX05vZGUgOiBwdWJsaWMgcmNsY3BwOjpOb2RlIHsKcHVibGljOgogIF9fUExVR0lOX0NMQVNTX19Ob2RlKCkgOiBOb2RlKCJfX1BMVUdJTl9TTFVHX19fbm9kZSIpIHsKICAgIFJDTENQUF9JTkZPKHRoaXMtPmdldF9sb2dnZXIoKSwgIl9fUExVR0lOX05BTUVfXyBub2RlIHN0YXJ0ZWQiKTsKICAgIC8vIGNyZWF0ZSBwdWJsaXNoZXJzIC8gc3Vic2NyaWJlcnMgLyBzZXJ2aWNlcyBoZXJlCiAgfQp9OwoKaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KSB7CiAgcmNsY3BwOjppbml0KGFyZ2MsIGFyZ3YpOwogIHJjbGNwcDo6c3BpbihzdGQ6Om1ha2Vfc2hhcmVkPF9fUExVR0lOX0NMQVNTX19Ob2RlPigpKTsKICByY2xjcHA6OnNodXRkb3duKCk7CiAgcmV0dXJuIDA7Cn0K","docker/Dockerfile.cpp":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgcHVyZSBDKysgcGx1Z2luIGJhY2sgZW5kLgojIE1hdGNoZXMgdGhlIE11c2NhdCByb2JvdCBiYWNrZW5kIE9TIChVYnVudHUgMjQuMDQpIHNvIHRoZSBjb21waWxlZCBiaW5hcnkKIyBpcyBBQkktY29tcGF0aWJsZSB3aXRoIHRoZSByb2JvdC4gVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCBhbmQgYGJ1aWxkYAojIOKAlCBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUC4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIGJ1aWxkLWVzc2VudGlhbCBcCiAgICAgIGNtYWtlIFwKICAgICYmIHJtIC1yZiAvdmFyL2xpYi9hcHQvbGlzdHMvKgoKIyBSYWluYm93IFJvYm90aWNzIEMrKyBTREsgZm9yIGZpbmRfcGFja2FnZShyYl9zZGspLiBtdXNjYXQtcGsgcGFzc2VzIHRoZSB2ZXJzaW9uIHBpbm5lZCBpbiB0aGUKIyBwcm9qZWN0J3MgQ01ha2VMaXN0cy50eHQgKGZpbmRfcGFja2FnZShyYl9zZGsgPHZlcj4gRVhBQ1QpKTsgd2l0aG91dCBhIHBpbiAoUk9TIDIgcmNscHksIGBtdXNjYXQtcGsgbWNwYAojIG91dHNpZGUgYSBwcm9qZWN0KSB0aGUgbmV3ZXN0IFNESyBpcyBpbnN0YWxsZWQuIFJ1bnRpbWUgYW5kIC1kZXYgYXJlIGluc3RhbGxlZCB0b2dldGhlciBhdCBvbmUgdmVyc2lvbi4KQVJHIFJCX1NES19WRVJTSU9OPQpSVU4gYXB0LWdldCB1cGRhdGUgJiYgYXB0LWdldCBpbnN0YWxsIC15IC0tbm8taW5zdGFsbC1yZWNvbW1lbmRzIGNhLWNlcnRpZmljYXRlcyBjdXJsIFwKICAgICYmIGluc3RhbGwgLWQgL2V0Yy9hcHQva2V5cmluZ3MgXAogICAgJiYgY3VybCAtZnNTTCBodHRwczovL3JhaW5ib3dyb2JvdGljcy5naXRodWIuaW8vcmItc2RrL3JiLXNkay1hcHQtcmVwby5ncGcua2V5IC1vIC9ldGMvYXB0L2tleXJpbmdzL3JiLXNkay5hc2MgXAogICAgJiYgcHJpbnRmICdkZWIgW3NpZ25lZC1ieT0vZXRjL2FwdC9rZXlyaW5ncy9yYi1zZGsuYXNjXSBodHRwczovL3JhaW5ib3dyb2JvdGljcy5naXRodWIuaW8vcmItc2RrICVzIG1haW5cbicgc3RhYmxlIGRldiA+IC9ldGMvYXB0L3NvdXJjZXMubGlzdC5kL3JiLXNkay5saXN0IFwKICAgICYmIGFwdC1nZXQgdXBkYXRlIFwKICAgICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyAicmFpbmJvdy1yYi1zZGske1JCX1NES19WRVJTSU9OOis9JFJCX1NES19WRVJTSU9OfSIgInJhaW5ib3ctcmItc2RrLWRldiR7UkJfU0RLX1ZFUlNJT046Kz0kUkJfU0RLX1ZFUlNJT059IiBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyoKCgpXT1JLRElSIC9wbHVnaW4KCkNNRCBbImJhc2giXQo=","docker/Dockerfile.dev":"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","docker/Dockerfile.python":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgUHl0aG9uIHBsdWdpbiBiYWNrIGVuZC4KIyBNYXRjaGVzIHRoZSBNdXNjYXQgcm9ib3QgYmFja2VuZDogVWJ1bnR1IDI0LjA0ICsgUHl0aG9uIDMuMTIuCiMgVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCAoaG90LXJlbG9hZCkgYW5kIGBtdXNjYXQtcGsgYnVpbGRgIChsb2NrICsgd2hlZWwgdmVuZG9yKS4KIyBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUCDigJQgdGhlIHJvYm90IGluc3RhbGxzIGRlcHMgZnJvbSBkaXN0L3doZWVscy8gb2ZmbGluZS4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIHB5dGhvbjMgXAogICAgICBweXRob24zLXBpcCBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyogXAogICAgJiYgcGlwMyBpbnN0YWxsIHV2PT0wLjguMTggLS1icmVhay1zeXN0ZW0tcGFja2FnZXMKCiMgVE9ETyhjcHAtc2RrKTogdGhlIFB5dGhvbiBTREsgaXMgYSBweWJpbmQgd3JhcHBlciBvdmVyIHRoZSBjcHAgU0RLLCBzbyB0aGUKIyBjcHAgU0RLIHNoYXJlZCBsaWIgbXVzdCBiZSBwcmVzZW50IGZvciB0aGUgcHl0aG9uIG1vZHVsZSB0byBsb2FkLiBJbnN0YWxsIHRoZQojIHJhaW5ib3cgY3BwIFNESyAoYXB0LCBwaW5uZWQgdG8gdGhlIHJvYm90J3MgdmVyc2lvbikgaGVyZSBvbmNlIGl0IGV4aXN0cy4KCgpXT1JLRElSIC9wbHVnaW4KCkNNRCBbImJhc2giXQo="};
+export const KIT_VERSION = "1.10.2-dev.6";
+export const TEMPLATES = {"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 already serves the
plugin gateway on port 10000. The CLI sees that, does not start its own local Muscat, and
your plugin backend connects to the robot's gateway — exactly what you want when
developing on the robot.

---

## Several developers on one robot

Against a remote robot, `muscat-pk dev` / `dev:back` run your plugin under a dev id of its own,
`<manifest id>.dev-<user>-<random>` (printed at start; the random part is kept in `~/.muscat-pk/dev-id`).
Two machines developing the same plugin on one robot would otherwise register the same topics on its
gateway, and a button in one UI would silently run the other machine's backend. The UI, the backend,
the ROS namespace and external routes (`common/plugin/<dev id>/<path>`) all use the dev id.

Pass `--keep-id` to run under the manifest id instead, e.g. to test program `execute` or an external
client that uses the real id. Then only one machine may be connected to that robot.

---

## 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 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, 0], "tar_frame": -1, "tar_unit": 0},
    )


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

#### External endpoints (`plugin.router`)

`plugin.serve` / `plugin.subscribe` / `plugin.publish` are **internal only** (plugin
UI ↔ backend, plugin ↔ plugin). To expose an endpoint to the outside world —
REST, Socket.IO, TCP, MQTT, WebRTC — use `plugin.router`. Declaring one is a
single decorator; the running Muscat (`common`) picks it up without a restart,
and it disappears when the plugin stops or is removed.

> Requires a robot running `rainbow-rb-sdk` **0.0.9.dev5 or newer** (the SDK is
> provided by the plugin container at runtime). On older robots `plugin.router`
> does not exist and raises `AttributeError`.

```python
from rainbow.rb_sdk import RBPluginCall
from rainbow.rb_sdk.plugin import PluginRouteError

plugin = RBPluginCall()  # plugin_id comes from env RB_PLUGIN_ID


@plugin.router.on("/hello")                                  # all 5 transports
def hello(payload: dict, meta: dict):
    return {"msg": f"hi {payload.get('name')}"}              # return value = response body


@plugin.router.on("/admin", explicit_routes=["api"])         # REST only
def admin(payload, meta):
    if not (meta.get("principal") or {}).get("is_admin"):
        raise PluginRouteError(403, "admin only")            # becomes the external status
    ...


@plugin.router.subscribe("/cmd", explicit_events=["tcp"])    # receive external TCP publish
def on_cmd(payload: dict):
    ...


plugin.router.emit("/state", {"busy": True})                 # push to external subscribers
```

| API | Meaning | External address |
| --- | --- | --- |
| `router.on(path, explicit_routes=None)` | request/response handler | `common/plugin/{plugin_id}/{path}` (REST is always `POST`) |
| `router.subscribe(topic, explicit_events=None)` | receive external publishes | external side publishes to `common/plugin/{plugin_id}/{topic}` |
| `router.emit(topic, payload)` | plugin → external push | external side subscribes to `common/plugin/{plugin_id}/{topic}` |

- The `plugin_id` prefix is added by the SDK — write only the path in plugin code.
- Paths may have several segments (`/tool/echo`). Declaring the same path twice raises `ValueError`.
- Transport names: `api | socket | tcp | mqtt | webrtc`. `subscribe` accepts only `tcp | mqtt | webrtc`. Unknown names raise `ValueError`.
- `explicit_routes` / `explicit_events` of `None` means every transport. A request on a transport not listed gets 404.

Handler contract:

- Signature `(payload, meta)`, `(payload)` or `()` — only the arguments you declare are injected. Sync and async both work.
- `payload`: what the caller sent (for REST: JSON body merged with query params). The shape is up to the plugin.
- `meta`: `{"transport": "api"|"socket"|"tcp"|"mqtt"|"webrtc", "principal": dict | None}`. When the robot's login policy is on, `principal` holds the token subject. **Role checks are the plugin's job** — inspect `meta["principal"]` yourself.
- The return value is the response body (must be JSON-serialisable). `None` → empty response.
- Status codes: `raise PluginRouteError(code, message)`. Any other exception → 500 with `str(exc)` as the message.
- `subscribe` handlers take `(payload)` only and return nothing.

#### Calling plugin endpoints from outside

| Transport | How |
| --- | --- |
| REST | `POST /common/plugin/{plugin_id}/{path}` (through the api-gateway), JSON body |
| Socket.IO | emit event `common/plugin/{plugin_id}/{path}`, response arrives in the ack |
| TCP | topic `common/plugin/{plugin_id}/{path}` request / publish |
| MQTT | request: `common/plugin/{plugin_id}/{path}/__req__`, publish: `common/plugin/{plugin_id}/{topic}` |
| WebRTC | data channel topic `common/plugin/{plugin_id}/{path}` |

Auth: when the robot's login policy is on, a token is **required** (any role — GUEST passes). When it is off, calls go straight through. REST uses the same Bearer token as the other Muscat APIs.

```bash
curl -s -X POST http://<robot>/common/plugin/my-plugin/hello \
  -H 'Content-Type: application/json' -d '{"name":"kim"}'
```

| Situation | Status |
| --- | --- |
| No plugin declares that path / plugin is down / transport not allowed | 404 |
| Plugin did not answer within 10 s | 504 |
| `common` ↔ gateway not connected | 503 |
| Handler raised | 500 (`PluginRouteError` → its `code`) |

Known limits:

- A plugin path named `install` cannot be called over REST (`POST /common/plugin/{id}/install` is taken by the registry install route first). Socket/TCP are unaffected.
- Swagger shows one catch-all route, not per-plugin paths.
- The MQTT broker echoes to the sender: a plugin that `emit`s and `subscribe`s the same topic receives its own push over `mqtt`. Drop `mqtt` from `explicit_events` or use separate topics. (TCP is filtered by `sender_id`.)
- `on` and `subscribe` may share a name — they live in separate tables.

During `muscat-pk dev` the local Muscat runtime takes the `router.*` registrations
on its gateway (port `10000`), and its `common` (port `3000`) routes
`common/plugin/...` to them like on the robot — try
`curl http://localhost:3000/common/plugin/<plugin-id>/<path>`. After restarting the plugin process,
external calls may return 504 for up to about a minute (until the gateway notices
the old socket is gone), then 404 — that is expected.

#### 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:
    """Called once when my Step executes. Variable writes apply to the
    running program immediately + broadcast to other robots' main tasks."""
    count = await ctx.get_variable("counter")          # read an existing program variable
    await ctx.set_variable("counter", count + 1)       # update an existing variable — allowed
    await ctx.set_variable("RBP_TEST", 1)              # NEW variables must start with RBP_

    for i in range(100):
        await ctx.check_stop()   # auto-scoped to this Step's robot model
        await asyncio.sleep(0.5)

    await ctx.done()


async def background_monitor() -> None:
    """Resident task outside any Step. If no program is running,
    get returns None and set is silently ignored — always safe to call."""
    while True:
        await asyncio.sleep(1.0)

        # targets every running main task (no robot_model param — always broadcast)
        await ctx.set_variable("RBP_TEST", 3)

        # get options
        v1 = await ctx.get_variable("counter")                           # first value found in the whole tree
        v2 = await ctx.get_variable("counter", robot_model="C500920")    # a specific robot
        v3 = await ctx.get_variable("RBP_TEST", plugin_id="my-plugin")   # the value my-plugin last wrote

        if ctx.executor_state("C500920") == "paused":
            print("C500920 program is paused")


async def main() -> None:
    asyncio.create_task(background_monitor())
    await ctx.start()  # stays resident


asyncio.run(main())
```

#### Program variables & executor state (`PluginProgramContext`)

`rainbow.rb_sdk.PluginProgramContext` lets the plugin process interact with the
running program (PyFM): read/write program variables and observe execution
state — inside a Step handler or from a resident task, at any time.

- The `on_execute` handler is called **only when PyFM executes this plugin's
  Step**. One Step execution = one handler call, and the Step does not finish
  until you call `ctx.done()` — always call it.
- The plugin process itself stays resident after `ctx.start()`; executor state
  queries and variable access below keep working whether or not a Step is
  executing.

#### Variable naming rules (important)

PyFM variables are a **program-wide shared namespace**. One rule:

- **Modifying an existing variable** — the name passes as-is. Exchanging
  variables between the program and the plugin is the intended usage.
- **Creating a variable that doesn't exist** — the `RBP_` prefix is
  **required** (enforced by the SDK/server; a violation raises
  `RuntimeError`). Applies equally inside and outside Step execution.

For new variable names, a convention that includes the plugin id is strongly
recommended:

```
RBP_{plugin_id}_{name}

e.g. RBP_vision_detect_count, RBP_gripper_last_error
```

Why:

- `RBP_` — instantly identifies plugin-created variables in the program
  editor/UI.
- `{plugin_id}` — **prevents name collisions with other plugins.** If two
  plugins use the same name they overwrite the same variable (`RBP_` alone is
  not something the SDK guards against).

#### Reading / writing variables

```python
value = await ctx.get_variable("counter")                 # read (no name restriction)
await ctx.set_variable("counter", value + 1)              # modify existing variable — allowed
await ctx.set_variable("RBP_my-plugin_result", 42)        # create new variable — RBP_ required
```

`set_variable` always applies to **every running main task** (a plugin belongs
to muscat, not to a specific robot — there is no `robot_model` parameter):

| When | Own program | Other robots' main tasks |
|---|---|---|
| During own Step execution | via the control queryable — **immediate** | broadcast — each at its next Step boundary |
| Outside a Step (resident task, …) | resident endpoint — next Step boundary | same |

`get_variable` has options:

```python
await ctx.get_variable("counter")                          # search all main tasks (first value found)
await ctx.get_variable("counter", robot_model="C500920")   # a specific robot's value
await ctx.get_variable("RBP_TEST", plugin_id="A.plugin")   # the value that plugin last wrote
```

Caveats:

- If no program is running, `set_variable` is **silently ignored** and
  `get_variable` returns `None`. (`RuntimeError` is raised only for real
  errors, like the `RBP_` violation on a new variable — the message is tagged
  `[plugin:{id}]` with the offending plugin.)
- Rarely, a write can be lost if it races the worker's variable flush
  (lock-free read-modify-write). For important values, re-check and retry on
  the next cycle.

#### Per-plugin value storage (meta)

Besides the shared value, each variable entry records which plugin last wrote
what:

```python
# state_dict["variables"] — after A wrote 1 and B wrote 2
"RBP_TEST": {
    "value": 2,                                # shared slot = last written value
    "type": "local",
    "meta": {"writers": {"A.plugin": 1, "B.plugin": 2}},   # per-plugin record
}
```

So the exact value is recoverable even when names collide:

- Plugin SDK: `ctx.get_variable("RBP_TEST", plugin_id="A.plugin")` → `1`
- Program step expression: `COUNT = get_var("A.plugin", "RBP_TEST") + 1` → `2`
- A plain name (`RBP_TEST += 1`) uses the shared slot (last written value) → `3`

#### Executor state

Subscribes to the `muscat/executor/state` publish (0.8 s interval) and exposes
per-robot-model state:

```python
ctx.executor_state("C500920")   # "running" | "paused" | "waiting" | ... | None
ctx.executor_state()            # {"C500920": "paused", "amr": "running"}
ctx.is_paused("C500920")        # whether that model is paused
ctx.is_stopped("C500920")       # stop/error transition of a model seen active this run
```

- States: `idle | running | paused | waiting | stopped | post_start | completed | error`
- A model with no running task is `None` / absent from the dict.
- The publish interval is 0.8 s, so expect up to ~1 s of latency.
- With `IS_DEV=true` there is no publish at all — always `None`.

To get a callback at the moment the state changes, without polling:

```python
@ctx.on_executor_state_change
async def on_change(robot_model: str, state: str) -> None:
    if state == "paused":
        print(f"{robot_model} paused")
```

- Not called for repeated publishes of the same state — fires exactly once
  per per-model state change.
- An exception in the handler is only logged; state tracking keeps running.

#### Responding to pause / stop

```python
@ctx.on_execute
async def handle(args: dict) -> None:
    for i in range(100):
        # stop → CancelledError (propagated to the executor as a stop),
        # pause → waits here until resumed.
        # Inside on_execute this automatically watches only the robot model
        # executing this Step.
        await ctx.check_stop()

        ...  # actual work
        await asyncio.sleep(0.5)

    await ctx.done()
```

Scope priority for `check_stop` / `is_paused` / `is_stopped`:

1. `robot_model` given — that model only
2. Omitted inside `on_execute` — **only the model executing this Step**
   (passed in by the executor)
3. Omitted elsewhere (resident task, …) — all models

A handler doing long-running work must call `check_stop()` every loop
iteration so it reacts to pause/stop immediately. Without it, the plugin keeps
running even after the operator presses Stop.

Variables your plugin wants the Program page variable picker to offer must be
pre-declared in `manifest.json` under `"variables"` (see the manifest section
below).

### C++

C++ plugins use `cpp/` and are built with CMake inside Docker against the
Rainbow Robotics C++ SDK (see _C++ SDK_ below).

```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;
}
```

#### C++ SDK (`rainbow-rb-sdk-dev`)

Both C++ runtimes (`cpp`, `ros2` + `rclcpp`) link the Rainbow Robotics C++ SDK
from the apt package `rainbow-rb-sdk-dev`. The `muscat-pk` dev containers already
have it, so `muscat-pk dev` / `build` need nothing extra. To build outside the
container (your own Ubuntu 24.04 machine, or the robot PC):

```bash
curl -fsSL https://rainbowrobotics.github.io/rb-sdk/rb-sdk-apt-repo.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/rb-sdk-apt.gpg
echo 'deb [signed-by=/usr/share/keyrings/rb-sdk-apt.gpg] https://rainbowrobotics.github.io/rb-sdk stable main' | sudo tee /etc/apt/sources.list.d/rb-sdk.list
sudo apt update && sudo apt install rainbow-rb-sdk-dev
```

- CMake: `find_package(rb_sdk REQUIRED)` + `target_link_libraries(<target> rb_sdk::rb_sdk)` (C++20). pkg-config: `rb_sdk`.
- Headers: `<rainbow/rb_sdk/manipulate/rb_manipulate_sdk.hpp>` (`RBManipulateSDK`),
  `<rainbow/rb_sdk/program/plugin_program_context.hpp>` (`rb_plugin::PluginProgramContext`, for `program.panel` commands — the header's top comment has a full `main()` example).
- The binary is linked **dynamically**; `muscat-pk build` copies the matching `librb_sdk.so` into `dist/<arch>/lib/` (the robot has no SDK installed), so each plugin keeps the SDK version it was built with. The version is the one pinned in `CMakeLists.txt` (`find_package(rb_sdk <version> EXACT REQUIRED)`); change it with `muscat-pk sdk update <version>`.
- UI ↔ backend messaging works from C++ too: `rb_plugin::RBPluginCall` in `<rainbow/rb_sdk/plugin/rb_plugin.hpp>` (see the scaffolded `cpp/main.cpp`).

### ROS2 (rclpy)

ROS2 Python plugins use `ros2_ws/` with `runtime.rosClient: "rclpy"`. relative topic names are placed under the plugin's ROS namespace — the plugin id
with "." → "/" and "-" → "_" (`com.example.my-plugin` → `/com/example/my_plugin`), in dev
and on the robot. Use an absolute name (`/cmd_vel`) for topics shared with other nodes.
`RBPluginCall` works in the node module too (UI messaging and `plugin.router`).

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


#### Talking to an external PC over ROS 2

ROS 2 discovery stays on the robot (`ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST`; `muscat-pk dev`
runs the same), so robots on one LAN don't mix topics. Allow specific PCs from the plugin UI —
Muscat keeps the list per plugin, starts your backend with `ROS_STATIC_PEERS` set to it, and
restarts the plugin when it changes. Your ROS code needs no changes; the PC needs no extra settings.

```tsx
const rb = useRb();
const peers = await rb.rosPeers.get();               // ["192.168.0.50"]
await rb.rosPeers.set(["192.168.0.50", "192.168.0.51"]); // saves + restarts the plugin; rejects on a bad IP
```

- Per plugin: plugin B keeps its allowed PCs when plugin A (allowing the same PC) is stopped or removed.
- It opens communication; it is not access control — a PC that knows the robot's IP can still
  add the robot to its own `ROS_STATIC_PEERS`.
- In `muscat-pk dev` the list is kept in `.muscat-dev/ros-peers.json` (ROS 2 backends).

### ROS2 (rclcpp)

ROS2 C++ plugins use `ros2_ws/` with `runtime.rosClient: "rclcpp"`. The node links
the Rainbow C++ SDK the same way as the `cpp` runtime (see _C++ SDK_ above).

```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");
  }
};
```

---

## Video streaming (MediaMTX)

Muscat runs a MediaMTX media server. The backend publishes a stream over RTSP and
the UI plays it over WebRTC. `muscat-pk dev` runs the same server (or uses a local
Muscat's), so the addresses are identical in dev and on the robot.

| | Address |
| --- | --- |
| Publish (backend) | `rtsp://127.0.0.1:8554/<plugin_id>/<name>` |
| Play (UI) | `http://<host>:8889/<plugin_id>/<name>/` |

- Prefix the path with your plugin id — paths are shared with robot cameras and other plugins.
- The robot runtime has no ffmpeg, GStreamer or OpenCV; bring your own encoder (below).

**Backend (Python)** — use PyAV: add `av` and `numpy` to `requirements.txt`. Its wheels
include FFmpeg, so they ship in the ZIP like any other dependency.

```python
import fractions, time
import av, numpy as np

out = av.open("rtsp://127.0.0.1:8554/__PLUGIN_ID__/cam", mode="w", format="rtsp",
              options={"rtsp_transport": "tcp"})
stream = out.add_stream("libx264", rate=25, options={"preset": "ultrafast", "tune": "zerolatency"})
stream.width, stream.height, stream.pix_fmt = 640, 360, "yuv420p"

i = 0
while True:
    img = np.zeros((360, 640, 3), dtype=np.uint8)          # your RGB frame here
    frame = av.VideoFrame.from_ndarray(img, format="rgb24")
    frame.pts, frame.time_base = i, fractions.Fraction(1, 25)
    for packet in stream.encode(frame):
        out.mux(packet)
    i += 1
    time.sleep(1 / 25)
```

Run the encoder loop in a thread (or `asyncio.to_thread`) so it doesn't block the
`RBPluginCall` handlers.

**UI** — embed MediaMTX's WebRTC player. `location.hostname` is `localhost` in the
preview and the robot's address on the robot:

```tsx
const STREAM = "__PLUGIN_ID__/cam"; // the path the backend publishes

export default function Camera() {
  return (
    <iframe
      src={`${location.protocol}//${location.hostname}:8889/${STREAM}/`}
      allow="autoplay"
      className="aspect-video w-full border-0"
    />
  );
}
```

---

## 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
    }
  ],

  // optional: variables this plugin exposes to pyfm programs — the Program
  // page variable picker lists ONLY declared variables. name must start with
  // RBP_; description is optional but without it the UI can't explain the
  // variable, so write one.
  "variables": [
    { "name": "RBP_grip_force", "type": "number", "init": 0.5, "description": { "ko": "그리퍼 힘", "en": "Gripper force" } },
    { "name": "RBP_target_pose", "type": "array", "init": [0, 0, 0] }
  ],

  // 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` — the plugin's screens; when present it must contain at least one `toolbar` entry. Leave it out (or `[]`) for a backend-only plugin: no UI is built, and Node.js is not needed to build it
- `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
- `variables` — optional array of `{ name, type, init, description? }`:
  - `name` — must start with `RBP_`, then letters/digits/underscore; unique per plugin
  - `type` — `"number" | "string" | "array"`
  - `init` — required initial value, must match `type`
  - `description` — optional `string` or i18n object (`en` required in object form)

`muscat-pk build` throws on any validation error. `muscat-pk dev` prints
warnings — except `variables` errors (e.g. a name without the `RBP_` prefix),
which are hard errors in `dev` / `dev:back` too.

**Backend port rules:**
- Declare a port only if your backend opens a TCP server/listener.
- **Every listening TCP port must be declared.** `muscat-pk dev` and
  `muscat-pk dev:back` watch the backend and stop it the moment it opens a port
  that is not in `ports`. A port outside `28600-28999` can't be declared, so it
  must not be opened either — picking e.g. `5500` is not a way around the rule.
  It would escape this check *and* the robot's install-time conflict check, and
  only collide once it's running on a robot.
- Reserved ports include `502`, `2222`, `4840`, `5170-5179`, `8000-8999`,
  `10000`, `30004`, `34964`, `44818`, `50000-50005`, and `50051`.
- The robot rejects installation (HTTP 409) if a declared port is reserved,
  out of range, or already claimed by another enabled plugin.

**Reaching your backend's ports during development:**
- Declared ports are published to `127.0.0.1` on your machine, so
  `curl http://127.0.0.1:28600` works from the host on macOS, Windows, and Linux.
- On native Linux the dev container uses host networking, so the ports are on
  the host already.
- If a declared port is already taken on your machine, `muscat-pk dev` warns and
  skips publishing that one — the backend still listens inside the container.

---

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

> Switching between a Python and a C++ backend asks whether to replace this README with the matching one (the old file is kept as `README.md.bak`). Add `--readme` to answer yes without the prompt.

---

## 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; with `lang: "cpp"`, the C++ SDK headers
  (`rainbow-rb-sdk-dev`, read out of the `muscat-pk` cpp dev image — build it
  once with `muscat-pk dev:back`).
- `check_project` — what this project must change for the plugin-ui it has
  installed (old APIs such as `connect(App)` or `Slider`, a `vite.config` without
  the `muscat()` preset, `tsc` errors), the same list `muscat-pk update` prints.
  Ask the assistant to fix the project after an update; it re-checks until clean.

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

`muscat-pk new` also writes `AGENTS.md` (read by Codex, Cursor, Gemini CLI, Copilot)
and a `CLAUDE.md` that imports it: the UI rules (plugin-ui components instead of
native `<select>`/`<input>`/`<button>`, design tokens for colors) for assistants that
do not call the MCP tools on their own. Add your own project notes there.

### 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** — register once with:

```bash
muscat-pk mcp --install codex
```

This appends the server to `~/.codex/config.toml` (idempotent — safe to run
again). Equivalent manual config:

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

> Building the other arch (e.g. arm64 on an amd64 PC) runs in an emulated container for
> C++ backends. Docker Desktop has it built in; on Linux enable it once with
> `docker run --privileged --rm tonistiigi/binfmt --install all`, or pass `--arch` for one arch.

- 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":"ewogICJpZCI6ICJfX1BMVUdJTl9JRF9fIiwKICAibmFtZSI6ICJfX1BMVUdJTl9OQU1FX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAibWluTXVzY2F0VmVyc2lvbiI6ICIxLjAuMCIsCiAgImF1dGhvciI6ICJfX1BMVUdJTl9BVVRIT1JfXyIsCiAgImVtYWlsIjogIl9fUExVR0lOX0VNQUlMX18iLAogICJkZXNjcmlwdGlvbiI6IHsKICAgICJrbyI6ICIiLAogICAgImVuIjogIiIKICB9LAogICJpY29ucyI6ICJhc3NldHMvaWNvbi5zdmciLAogICJ0YXJnZXRNb2RlbHMiOiAiYWxsIiwKICAidGFyZ2V0Q2F0ZWdvcnlzIjogImFsbCIsCiAgImNvbnRyaWJ1dGVzIjogWwogICAgewogICAgICAicG9pbnQiOiAidG9vbGJhciIsCiAgICAgICJpY29uIjogImFzc2V0cy9pY29uLnN2ZyIsCiAgICAgICJsYWJlbCI6IHsgImtvIjogIl9fUExVR0lOX05BTUVfXyIsICJlbiI6ICJfX1BMVUdJTl9OQU1FX18iIH0sCiAgICAgICJ1aSI6ICJjb250ZW50IiwKICAgICAgIm9wZW5zIjogInBvcG92ZXIiCiAgICB9CiAgXSwKICAidmFyaWFibGVzIjogW10sCiAgInJ1bnRpbWUiOiB7ICJ0eXBlIjogIl9fUlVOVElNRV9UWVBFX18iLCAiZW50cnkiOiAibWFpbi5weSIgfQp9Cg==","common/package.json":"ewogICJuYW1lIjogIl9fUExVR0lOX0lEX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAicHJpdmF0ZSI6IHRydWUsCiAgInR5cGUiOiAibW9kdWxlIiwKICAiZGVwZW5kZW5jaWVzIjogewogICAgIkByYWluYm93LXJvYm90aWNzL3BsdWdpbi11aSI6ICJfX1JCX1ZFUlNJT05fXyIKICB9LAogICJkZXZEZXBlbmRlbmNpZXMiOiB7CiAgICAiQHRhaWx3aW5kY3NzL3ZpdGUiOiAiXjQuMS4wIiwKICAgICJAcmFpbmJvdy1yb2JvdGljcy9tdXNjYXQtcGx1Z2luLWtpdCI6ICJfX1JCX1ZFUlNJT05fXyIsCiAgICAiQHJhaW5ib3ctcm9ib3RpY3MvcHJldmlldy1ob3N0IjogIl9fUkJfVkVSU0lPTl9fIiwKICAgICJAdHlwZXMvcmVhY3QiOiAiXjE5LjAuMTAiLAogICAgIkB0eXBlcy9yZWFjdC1kb20iOiAiXjE5LjAuNCIsCiAgICAiQHZpdGVqcy9wbHVnaW4tcmVhY3QiOiAiXjQuMC4wIiwKICAgICJyZWFjdCI6ICJeMTkuMC4wIiwKICAgICJyZWFjdC1kb20iOiAiXjE5LjAuMCIsCiAgICAidGFpbHdpbmRjc3MiOiAiXjQuMS4wIiwKICAgICJ0eXBlc2NyaXB0IjogIl41LjguMCIsCiAgICAidml0ZSI6ICJeNi4wLjAiCiAgfQp9Cg==","common/py/main.py":"IiIiCk11c2NhdCBwbHVnaW4gYmFja2VuZCDigJQgX19QTFVHSU5fTkFNRV9fCgpPbi1yb2JvdCAoZGVmYXVsdCk6CiAgbXVzY2F0LXBrIGRldjpiYWNrCiAgcHl0aG9uIG1haW4ucHkKClJlbW90ZSBkZXYgKGZyb20geW91ciBsYXB0b3ApOgogIFNldCBlbnYgdmFycyBiZWZvcmUgcnVubmluZzoKICAgIE1VU0NBVF9ST0JPVF9IT1NUPTE5Mi4xNjguMS4xMDAKICAgIE1VU0NBVF9ST0JPVF9UT0tFTj08c2VydmljZSB0b2tlbj4gICAob3B0aW9uYWw7IG5lZWRlZCBvbmx5IHdoZW4gdGhlIHJvYm90J3MgbG9naW4gcG9saWN5IGlzIG9uKQogIFRoZW46IG11c2NhdC1wayBkZXY6YmFjawoKSGFuZGxlcnM6CiAgcGx1Z2luLnNlcnZlIC8gcGx1Z2luLnN1YnNjcmliZSAvIHBsdWdpbi5wdWJsaXNoICAtPiBwbHVnaW4gVUkgPC0+IGJhY2tlbmQgb25seQogIHBsdWdpbi5yb3V0ZXIub24gLyBzdWJzY3JpYmUgLyBlbWl0ICAgICAgICAgICAgICAgLT4gZXh0ZXJuYWwgZW5kcG9pbnRzCiAgICAoUkVTVCAvIFNvY2tldC5JTyAvIFRDUCAvIE1RVFQgLyBXZWJSVEMgYXQgY29tbW9uL3BsdWdpbi88cGx1Z2luX2lkPi88cGF0aD4pLgogICAgTmVlZHMgYSByb2JvdCBydW5uaW5nIHJhaW5ib3ctcmItc2RrID49IDAuMC45LmRldjU7IG9sZGVyIHJvYm90cyBoYXZlIG5vCiAgICBgcGx1Z2luLnJvdXRlcmAgKEF0dHJpYnV0ZUVycm9yKS4gU2VlIFJFQURNRSAiRXh0ZXJuYWwgZW5kcG9pbnRzIi4KIiIiCgppbXBvcnQgYXN5bmNpbwppbXBvcnQgb3MKZnJvbSB0eXBpbmcgaW1wb3J0IEFueQoKZnJvbSByYWluYm93LnJiX3NkayBpbXBvcnQgUkJNYW5pcHVsYXRlU0RLLCBSQlBsdWdpbkNhbGwKZnJvbSByYWluYm93LnJiX3Nkay5yYl9zZGtfY3BwIGltcG9ydCBDb25uZWN0T3B0aW9ucwoKClBMVUdJTl9OQU1FID0gIl9fUExVR0lOX05BTUVfXyIKCnBsdWdpbiA9IFJCUGx1Z2luQ2FsbCgpCm1hbmlwdWxhdGUgPSBSQk1hbmlwdWxhdGVTREsoKQoKCmRlZiByZWdpc3Rlcl9oYW5kbGVycygpOgogICAgIyBSZWdpc3RlciBoYW5kbGVycyBoZXJlIOKAlCBjYWxsZWQgYWZ0ZXIgY29ubmVjdCgpIHNvIHN1YnNjcmlwdGlvbnMgc3Vydml2ZQogICAgIyBzZXNzaW9uIHJlY29ubmVjdGlvbiBpbiByZW1vdGUtZGV2IG1vZGUuCgogICAgIyAtLS0gUGx1Z2luIFVJIDwtPiBiYWNrZW5kIChub3QgcmVhY2hhYmxlIGZyb20gb3V0c2lkZSBNdXNjYXQpIC0tLQoKICAgIEBwbHVnaW4uc3Vic2NyaWJlKCJldmVudCIpCiAgICBkZWYgb25fdWlfZXZlbnQocGF5bG9hZDogZGljdFtzdHIsIEFueV0gfCBOb25lID0gTm9uZSk6CiAgICAgICAgIiIiSGFuZGxlIG1lc3NhZ2VzIHB1Ymxpc2hlZCBmcm9tIHRoZSBwbHVnaW4gVUkgd2l0aCByYi5wdWIoImV2ZW50IiwgLi4uKS4iIiIKICAgICAgICBwcmludChmIlt7UExVR0lOX05BTUV9XSBldmVudDoiLCBwYXlsb2FkKQoKICAgIEBwbHVnaW4uc2VydmUoImdyaXAiKQogICAgZGVmIGdyaXAocGF5bG9hZDogZGljdFtzdHIsIEFueV0gfCBOb25lID0gTm9uZSk6CiAgICAgICAgIiIiSGFuZGxlIHRoZSBkZWZhdWx0IFVJIGJ1dHRvbjogcmIuYWN0aW9uKCJncmlwIiwgeyB3aWR0aCB9KS4iIiIKICAgICAgICB3aWR0aCA9IChwYXlsb2FkIG9yIHt9KS5nZXQoIndpZHRoIiwgMjApCiAgICAgICAgcHJpbnQoZiJbe1BMVUdJTl9OQU1FfV0gZ3JpcCByZXF1ZXN0ZWQ6IHdpZHRoPXt3aWR0aH0iKQogICAgICAgIHBsdWdpbi5wdWJsaXNoKCJzdGF0ZSIsIHsicmVhZHkiOiBUcnVlLCAibGFzdF9ncmlwX3dpZHRoIjogd2lkdGh9KQogICAgICAgIHJldHVybiB7Im9rIjogVHJ1ZSwgIndpZHRoIjogd2lkdGh9CgogICAgQHBsdWdpbi5zZXJ2ZSgidG9vbC9lY2hvIikKICAgIGRlZiBlY2hvKHBheWxvYWQ6IGRpY3Rbc3RyLCBBbnldIHwgTm9uZSA9IE5vbmUpOgogICAgICAgICIiIlNtYWxsIHF1ZXJ5IGV4YW1wbGUgY2FsbGFibGUgZnJvbSB0aGUgVUkgd2l0aCByYi5hY3Rpb24oInRvb2wvZWNobyIsIC4uLikuIiIiCiAgICAgICAgcmV0dXJuIHsiZWNobyI6IHBheWxvYWQsICJwbHVnaW4iOiBQTFVHSU5fTkFNRX0KCiAgICAjIC0tLSBFeHRlcm5hbCBlbmRwb2ludHMgKFJFU1QgLyBTb2NrZXQuSU8gLyBUQ1AgLyBNUVRUIC8gV2ViUlRDKSAtLS0KICAgICMgRXhwb3NlZCBhcyBjb21tb24vcGx1Z2luLzxwbHVnaW5faWQ+L2hlbGxvLCBlLmcuCiAgICAjICAgY3VybCAtWCBQT1NUIGh0dHA6Ly88cm9ib3Q+L2NvbW1vbi9wbHVnaW4vPHBsdWdpbl9pZD4vaGVsbG8gXAogICAgIyAgICAgICAgLUggJ0NvbnRlbnQtVHlwZTogYXBwbGljYXRpb24vanNvbicgLWQgJ3sibmFtZSI6ICJraW0ifScKICAgICMgUmVzdHJpY3QgdHJhbnNwb3J0cyB3aXRoIGV4cGxpY2l0X3JvdXRlcz1bImFwaSJdIChSRVNUIG9ubHkpLCBldGMuCiAgICAjIFJhaXNlIFBsdWdpblJvdXRlRXJyb3IoNDAzLCAibXNnIikgdG8gc2V0IHRoZSByZXNwb25zZSBzdGF0dXMuCgogICAgQHBsdWdpbi5yb3V0ZXIub24oIi9oZWxsbyIpCiAgICBkZWYgaGVsbG8ocGF5bG9hZDogZGljdFtzdHIsIEFueV0gfCBOb25lID0gTm9uZSwgbWV0YTogZGljdFtzdHIsIEFueV0gfCBOb25lID0gTm9uZSk6CiAgICAgICAgIiIibWV0YSA9IHsidHJhbnNwb3J0IjogImFwaSJ8InNvY2tldCJ8InRjcCJ8Im1xdHQifCJ3ZWJydGMiLCAicHJpbmNpcGFsIjogZGljdCB8IE5vbmV9LiIiIgogICAgICAgIG5hbWUgPSAocGF5bG9hZCBvciB7fSkuZ2V0KCJuYW1lIiwgInRoZXJlIikKICAgICAgICByZXR1cm4geyJtc2ciOiBmImhpIHtuYW1lfSIsICJ2aWEiOiAobWV0YSBvciB7fSkuZ2V0KCJ0cmFuc3BvcnQiKX0KCgpkZWYgbW92ZV9qX2V4YW1wbGUoKToKICAgICIiIgogICAgRXhhbXBsZTogdXNlIG90aGVyIHJvYm90IFNES3MgZnJvbSB0aGUgc2FtZSBiYWNrZW5kLgoKICAgIFRoaXMgZnVuY3Rpb24gaXMgbm90IGNhbGxlZCBhdXRvbWF0aWNhbGx5LiBBZGQgc2FmZXR5IGNoZWNrcyBhbmQgY2FsbCBpdAogICAgZnJvbSB5b3VyIG93biBoYW5kbGVyIHdoZW4gdGhlIHJvYm90IGlzIHJlYWR5LgogICAgIiIiCiAgICByZXR1cm4gbWFuaXB1bGF0ZS5tb3ZlLmNhbGxfbW92ZV9qKAogICAgICAgIHJvYm90X21vZGVsPSJDNTAwOTIwIiwKICAgICAgICB0YXJnZXQ9ewogICAgICAgICAgICAidGFyX3ZhbHVlcyI6IFswLCAwLCAwLCAwLCAwLCAwLCAwXSwKICAgICAgICAgICAgInRhcl9mcmFtZSI6IC0xLAogICAgICAgICAgICAidGFyX3VuaXQiOiAwLAogICAgICAgIH0sCiAgICApCgoKYXN5bmMgZGVmIG1haW4oKToKICAgIHJvYm90X2hvc3QgPSBvcy5nZXRlbnYoIk1VU0NBVF9ST0JPVF9IT1NUIikKICAgIHJvYm90X3Rva2VuID0gb3MuZ2V0ZW52KCJNVVNDQVRfUk9CT1RfVE9LRU4iLCAiIikgICMgZW1wdHkgaXMgZmluZSB3aGVuIHRoZSBsb2dpbiBwb2xpY3kgaXMgb2ZmCgogICAgaWYgcm9ib3RfaG9zdDoKICAgICAgICAjIFJlbW90ZSBkZXY6IGNvbm5lY3QgdG8gdGhlIHJvYm90IGJlZm9yZSByZWdpc3RlcmluZyBhbnkgaGFuZGxlcnMuCiAgICAgICAgIyBjb25uZWN0KCkgY2xvc2VzIGFuZCByZW9wZW5zIHRoZSBaZW5vaCBzZXNzaW9uLCBzbyBoYW5kbGVycyByZWdpc3RlcmVkCiAgICAgICAgIyBiZWZvcmUgdGhpcyBjYWxsIHdvdWxkIGJlIGxvc3QuCiAgICAgICAgb3B0cyA9IENvbm5lY3RPcHRpb25zKCkKICAgICAgICBvcHRzLnRva2VuID0gcm9ib3RfdG9rZW4KICAgICAgICBvcHRzLmhvc3QgPSByb2JvdF9ob3N0CiAgICAgICAgbWFuaXB1bGF0ZS5jb25uZWN0KG9wdHMpCgogICAgcmVnaXN0ZXJfaGFuZGxlcnMoKQoKICAgIHBsdWdpbi5wdWJsaXNoKCJzdGF0ZSIsIHsicmVhZHkiOiBUcnVlLCAicGx1Z2luIjogUExVR0lOX05BTUV9KSAgICAgICAjIC0+IHBsdWdpbiBVSQogICAgcGx1Z2luLnJvdXRlci5lbWl0KCIvc3RhdGUiLCB7InJlYWR5IjogVHJ1ZSwgInBsdWdpbiI6IFBMVUdJTl9OQU1FfSkgICMgLT4gZXh0ZXJuYWwgc3Vic2NyaWJlcnMgb2YgY29tbW9uL3BsdWdpbi88cGx1Z2luX2lkPi9zdGF0ZQogICAgcHJpbnQoZiJbe1BMVUdJTl9OQU1FfV0gYmFja2VuZCByZWFkeSIpCgogICAgdHJ5OgogICAgICAgIHdoaWxlIFRydWU6CiAgICAgICAgICAgIGF3YWl0IGFzeW5jaW8uc2xlZXAoMSkKICAgIGV4Y2VwdCAoS2V5Ym9hcmRJbnRlcnJ1cHQsIGFzeW5jaW8uQ2FuY2VsbGVkRXJyb3IpOgogICAgICAgIHBhc3MKICAgIGZpbmFsbHk6CiAgICAgICAgaWYgcm9ib3RfaG9zdDoKICAgICAgICAgICAgYXdhaXQgbWFuaXB1bGF0ZS5kaXNjb25uZWN0KCkKICAgICAgICBwcmludChmIlt7UExVR0lOX05BTUV9XSBzdG9wcGVkIikKCgppZiBfX25hbWVfXyA9PSAiX19tYWluX18iOgogICAgdHJ5OgogICAgICAgIGFzeW5jaW8ucnVuKG1haW4oKSkKICAgIGV4Y2VwdCBLZXlib2FyZEludGVycnVwdDoKICAgICAgICBwYXNzCg==","common/requirements.txt":"cmFpbmJvdy1yYi1zZGs9PTAuMTAuMgpyYWluYm93LXJiLWZsYXQtYnVmZmVycz09MC4xMC4yCnJhaW5ib3ctcmItemVub2g9PTAuMTAuMgpyZXF1ZXN0cz09Mi4zNC4yCg==","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":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fIENYWCkKCnNldChDTUFLRV9DWFhfU1RBTkRBUkQgMjApCnNldChDTUFLRV9DWFhfU1RBTkRBUkRfUkVRVUlSRUQgT04pCgojIFJhaW5ib3cgUm9ib3RpY3MgQysrIFNESyDigJQgcHJvdmlkZWQgYnkgdGhlIGFwdCBwYWNrYWdlIHJhaW5ib3ctcmItc2RrLWRldgojIChwcmUtaW5zdGFsbGVkIGluIHRoZSBtdXNjYXQtcGsgZGV2IGNvbnRhaW5lcikuIFRoZSB2ZXJzaW9uIGhlcmUgaXMgdGhlIG9uZSB0aGUKIyBkZXYgY29udGFpbmVyIGluc3RhbGxzOyBjaGFuZ2UgaXQgd2l0aCBgbXVzY2F0LXBrIHNkayB1cGRhdGUgPHZlcnNpb24+YC4KZmluZF9wYWNrYWdlKHJiX3NkayAwLjEwLjIgRVhBQ1QgUkVRVUlSRUQpCgojIFRoZSBleGVjdXRhYmxlIG5hbWUgbXVzdCBtYXRjaCBydW50aW1lLmVudHJ5IGluIG1hbmlmZXN0Lmpzb24uCmFkZF9leGVjdXRhYmxlKF9fUExVR0lOX1NMVUdfXyBtYWluLmNwcCkKdGFyZ2V0X2xpbmtfbGlicmFyaWVzKF9fUExVR0lOX1NMVUdfXyBQUklWQVRFIHJiX3Nkazo6cmJfc2RrKQo=","cpp/cpp/main.cpp":"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","readme-cpp/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 (C++ rebuild + restart in 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()
├─ cpp/
│   ├─ CMakeLists.txt   # links rb_sdk::rb_sdk (C++ SDK)
│   └─ main.cpp         # C++ 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)
```

> ROS2 (rclcpp) plugins have `ros2_ws/` instead of `cpp/`.

---

## 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 already serves the
plugin gateway on port 10000. The CLI sees that, does not start its own local Muscat, and
your plugin backend connects to the robot's gateway — exactly what you want when
developing on the robot.

---

## Several developers on one robot

Against a remote robot, `muscat-pk dev` / `dev:back` run your plugin under a dev id of its own,
`<manifest id>.dev-<user>-<random>` (printed at start; the random part is kept in `~/.muscat-pk/dev-id`).
Two machines developing the same plugin on one robot would otherwise register the same topics on its
gateway, and a button in one UI would silently run the other machine's backend. The UI, the backend,
the ROS namespace and external routes (`common/plugin/<dev id>/<path>`) all use the dev id.

Pass `--keep-id` to run under the manifest id instead, e.g. to test program `execute` or an external
client that uses the real id. Then only one machine may be connected to that robot.

---

## 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 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`) from `cpp/main.cpp`, 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" } }
```

### C++ (`cpp`)

C++ plugins build `cpp/` with CMake and run the executable named by
`manifest.json` → `runtime.entry`. The Rainbow Robotics C++ SDK
(`rainbow-rb-sdk-dev`) is pre-installed in the `muscat-pk` dev container — you
don't install anything locally.

```json
{ "runtime": { "type": "cpp", "entry": "__PLUGIN_SLUG__" } }
```

```cmake
# cpp/CMakeLists.txt — the version is the SDK the dev container installs (muscat-pk sdk update <version>)
find_package(rb_sdk 0.10.2 EXACT REQUIRED)
add_executable(__PLUGIN_SLUG__ main.cpp)           # name must equal runtime.entry
target_link_libraries(__PLUGIN_SLUG__ PRIVATE rb_sdk::rb_sdk)
```

Editor support: the SDK is installed only inside the dev container, so `muscat-pk new` (and later
`dev` / `build` / `type change`) copies its headers to `.muscat-dev/sysroot` and writes a `Muscat`
configuration to `.vscode/c_cpp_properties.json`. VS Code's C/C++ extension then resolves `rb_sdk`
names. The copies follow the SDK version above; the build itself never uses them. ROS 2 headers
(`rclcpp`) are not copied.

Headers live under `<rainbow/rb_sdk/...>`:

| Header | Class | Use |
| --- | --- | --- |
| `plugin/rb_plugin.hpp` | `rb_plugin::RBPluginCall` | plugin UI ↔ backend, external endpoints (`router()`) |
| `manipulate/rb_manipulate_sdk.hpp` | `RBManipulateSDK` | control a manipulator |
| `program/rb_program_sdk.hpp` | `RBProgramSDK` | program-side helpers |
| `program/plugin_program_context.hpp` | `rb_plugin::PluginProgramContext` | `program.panel` commands |
| `zenoh_client.hpp` | `ZenohClient` | low-level pub/sub/query |

Payloads are `nlohmann::json` (`#include <nlohmann/json.hpp>`, installed with the SDK).

#### Talking to the plugin UI (`RBPluginCall`)

```cpp
#include <rainbow/rb_sdk/plugin/rb_plugin.hpp>
#include <nlohmann/json.hpp>

using nlohmann::json;
using rb_plugin::RBPluginCall;

int main() {
  // plugin id comes from env RB_PLUGIN_ID (set by muscat-pk dev and by the robot)
  auto plugin = RBPluginCall::get_instance(RBPluginCall::resolve_plugin_id(std::nullopt));

  plugin->publish("state", {{"ready", true}});                 // UI: rb.sub("state", ...)

  auto sub = plugin->subscribe("event",                        // UI: rb.pub("event", ...)
      [](const std::string& topic, const json& payload) { /* ... */ });

  plugin->serve("tool/echo", [](const json& payload) {         // UI: await rb.action("tool/echo", ...)
    return json{{"echo", payload}};
  });

  json res = plugin->call("tool/ping", {{"hello", "plugin"}}, 5.0);  // UI answers with rb.serve("tool/ping", ...)

  for (;;) std::this_thread::sleep_for(std::chrono::seconds(1));    // stay resident
}
```

| C++ | UI (`useRb()`) |
| --- | --- |
| `plugin->serve(topic, fn)` | `await rb.action(topic, payload)` |
| `plugin->subscribe(topic, fn)` | `rb.pub(topic, payload)` |
| `plugin->publish(topic, payload)` | `rb.sub(topic, handler)` |
| `plugin->call(topic, payload, timeout_sec)` | `rb.serve(topic, handler)` |

- Keep the `Subscription` returned by `subscribe`; pass it to `plugin->unsubscribe(std::nullopt, sub)` to remove just that one.
- `call` throws `rb_plugin::RBPluginGatewayError` when the gateway is down or the UI doesn't answer in time.

#### External endpoints (`router()`)

`serve` / `subscribe` / `publish` are **internal only** (plugin UI ↔ backend).
To expose an endpoint to the outside world — REST, Socket.IO, TCP, MQTT,
WebRTC — use `plugin->router()`. The running Muscat (`common`) picks it up
without a restart, and it disappears when the plugin stops.

```cpp
auto& router = plugin->router();

router.on("/hello", [](const json& payload, const json& meta) {       // all 5 transports
  return json{{"msg", "hi " + payload.value("name", std::string("there"))}};
});

router.on("/admin", [](const json& payload, const json& meta) {
  if (!meta.value("principal", json::object()).value("is_admin", false))
    throw rb_plugin::PluginRouteError(403, "admin only");              // becomes the external status
  return json::object();
}, std::vector<std::string>{"api"});                                  // REST only

router.subscribe("/cmd", [](const json& payload) { /* ... */ },
                 std::vector<std::string>{"tcp"});                    // receive external TCP publish

router.emit("/state", {{"busy", true}});                               // push to external subscribers
```

```bash
curl -s -X POST http://<robot>/common/plugin/<plugin_id>/hello \
  -H 'Content-Type: application/json' -d '{"name":"kim"}'
# → {"msg":"hi kim"}
```

| API | Meaning | External address |
| --- | --- | --- |
| `router.on(path, handler, explicit_routes)` | request/response handler | `common/plugin/{plugin_id}/{path}` (REST is always `POST`) |
| `router.subscribe(topic, handler, explicit_events)` | receive external publishes | external side publishes to `common/plugin/{plugin_id}/{topic}` |
| `router.emit(topic, payload)` | plugin → external push | external side subscribes to `common/plugin/{plugin_id}/{topic}` |

- `meta` = `{"transport": "api"|"socket"|"tcp"|"mqtt"|"webrtc", "principal": object | null}`. **Role checks are the plugin's job.**
- Transport names: `api | socket | tcp | mqtt | webrtc`; `subscribe` accepts only `tcp | mqtt | webrtc`. Unknown names or duplicate paths throw `std::invalid_argument`.
- Throw `rb_plugin::PluginRouteError(code, message)` to set the status; any other exception → 500.

| Situation | Status |
| --- | --- |
| No plugin declares that path / plugin is down / transport not allowed | 404 |
| Plugin did not answer within 10 s | 504 |
| `common` ↔ gateway not connected | 503 |

During `muscat-pk dev` the local Muscat runtime takes `router()` registrations on its
gateway and its `common` routes external calls to them like on the robot
(`curl http://localhost:3000/common/plugin/<plugin-id>/<path>`). After
restarting the plugin, external calls may return 504 for about a minute, then 404.

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

A `program.panel` contribution adds a **custom command** to the Program page.
Each time the program reaches that step, the host calls your backend through
`PluginProgramContext` with the step args (what the UI saved with `useRbSave`).

```cpp
#include <rainbow/rb_sdk/program/plugin_program_context.hpp>

using rb_plugin::PluginProgramContext;

int main() {
  PluginProgramContext ctx("__PLUGIN_ID__");

  ctx.set_execute_handler([&](const nlohmann::json& args) {
    auto count = ctx.get_variable("counter");                  // json; null if no program runs
    ctx.set_variable("counter", count.is_number() ? count.get<int>() + 1 : 1);
    ctx.set_variable("RBP___PLUGIN_SLUG___result", 42);        // NEW variables must start with RBP_

    try {
      for (int i = 0; i < 100; ++i) {
        ctx.check_stop();                                      // pause → blocks, stop → throws PluginStopped
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
      }
    } catch (const rb_plugin::PluginStopped&) {
      return;                                                  // program was stopped
    }
    ctx.done();                                                // always call — the step ends here
  });

  ctx.start();                                                 // does not block
  for (;;) std::this_thread::sleep_for(std::chrono::seconds(1));
}
```

- The step does not finish until you call `ctx.done()`.
- `set_execute_handler` must be called before `start()`.
- **New** variables need the `RBP_` prefix (`RBP_{plugin_id}_{name}` recommended); existing ones pass as-is.
- `get_variable(name, robot_model, plugin_id)` — optional filters: a specific robot, or the value a given plugin last wrote.
- Executor state: `ctx.executor_state_for("C500920")`, `ctx.executor_states()`, `ctx.is_paused()`, `ctx.is_stopped()`,
  or `ctx.set_state_change_handler([](const std::string& model, const std::string& state) { ... })`.
- A long-running handler must call `check_stop()` every iteration, or it keeps running after the operator presses Stop.

Variables the Program page variable picker should offer must be declared in
`manifest.json` under `"variables"`.

#### Controlling the robot

```cpp
#include <rainbow/rb_sdk/manipulate/rb_manipulate_sdk.hpp>

RBManipulateSDK manipulate;                       // on the robot: connects to the local Zenoh
manipulate.state.call_servocontrol("C500920", 1);

IPC::MoveInput_TargetT t;
t.tar_values = {0, 0, 90, 0, 90, 0, 0};  // joint degrees, always 7 values (7th = 0 on 6-axis arms)
t.tar_frame = -1;                        // -1 = joint space
t.tar_unit = 0;                          // 0 = mm/deg
manipulate.move.call_move_j("C500920", t, std::nullopt, MoveSpeedArg{1, 60.f, 120.f});
manipulate.move.call_move_wait("C500920", -1);
```

Remote dev (`muscat-pk dev --robot-ip <ip> [--robot-token <token>]`) sets
`MUSCAT_ROBOT_HOST` / `MUSCAT_ROBOT_TOKEN`; connect **before** registering
subscriptions, because `connect()` reopens the Zenoh session. The token is
optional — it is needed only when the robot's login policy is on:

```cpp
if (const char* host = std::getenv("MUSCAT_ROBOT_HOST")) {
  const char* token = std::getenv("MUSCAT_ROBOT_TOKEN");
  manipulate.connect({.token = token ? token : "", .host = host});
}
```

AMR and RB-Y1 SDKs are Python-only for now.

### ROS2 (rclcpp)

ROS2 C++ plugins use `ros2_ws/` with `runtime.rosClient: "rclcpp"`. The node
links the C++ SDK the same way (`find_package(rb_sdk)` + `rb_sdk::rb_sdk`); relative topic names are placed under the plugin's ROS namespace — the plugin id
with "." → "/" and "-" → "_" (`com.example.my-plugin` → `/com/example/my_plugin`), in dev
and on the robot. Use an absolute name (`/cmd_vel`) for topics shared with other nodes.

```cpp
#include "rclcpp/rclcpp.hpp"
#include <rainbow/rb_sdk/manipulate/rb_manipulate_sdk.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");
  }
};

int main(int argc, char** argv) {
  rclcpp::init(argc, argv);
  rclcpp::spin(std::make_shared<__PLUGIN_CLASS__Node>());
  rclcpp::shutdown();
  return 0;
}
```

`RBPluginCall` and `PluginProgramContext` work in an rclcpp node too — create
them in `main()` before `rclcpp::spin`.


#### Talking to an external PC over ROS 2

ROS 2 discovery stays on the robot (`ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST`; `muscat-pk dev`
runs the same), so robots on one LAN don't mix topics. Allow specific PCs from the plugin UI —
Muscat keeps the list per plugin, starts your backend with `ROS_STATIC_PEERS` set to it, and
restarts the plugin when it changes. Your ROS code needs no changes; the PC needs no extra settings.

```tsx
const rb = useRb();
const peers = await rb.rosPeers.get();               // ["192.168.0.50"]
await rb.rosPeers.set(["192.168.0.50", "192.168.0.51"]); // saves + restarts the plugin; rejects on a bad IP
```

- Per plugin: plugin B keeps its allowed PCs when plugin A (allowing the same PC) is stopped or removed.
- It opens communication; it is not access control — a PC that knows the robot's IP can still
  add the robot to its own `ROS_STATIC_PEERS`.
- In `muscat-pk dev` the list is kept in `.muscat-dev/ros-peers.json` (ROS 2 backends).

---

## Video streaming (MediaMTX)

Muscat runs a MediaMTX media server. The backend publishes a stream over RTSP and
the UI plays it over WebRTC. `muscat-pk dev` runs the same server (or uses a local
Muscat's), so the addresses are identical in dev and on the robot.

| | Address |
| --- | --- |
| Publish (backend) | `rtsp://127.0.0.1:8554/<plugin_id>/<name>` |
| Play (UI) | `http://<host>:8889/<plugin_id>/<name>/` |

- Prefix the path with your plugin id — paths are shared with robot cameras and other plugins.
- The robot runtime has no ffmpeg, GStreamer or OpenCV; bring your own encoder (below).

**Backend (C++)** — publish RTSP with an encoder library you bring (e.g. FFmpeg's
libavformat / libx264); the robot has none installed. Ship it with the plugin — see
_Bundling extra shared libraries_.

**UI** — embed MediaMTX's WebRTC player. `location.hostname` is `localhost` in the
preview and the robot's address on the robot:

```tsx
const STREAM = "__PLUGIN_ID__/cam"; // the path the backend publishes

export default function Camera() {
  return (
    <iframe
      src={`${location.protocol}//${location.hostname}:8889/${STREAM}/`}
      allow="autoplay"
      className="aspect-video w-full border-0"
    />
  );
}
```

---

## 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
    }
  ],

  // optional: variables this plugin exposes to pyfm programs — the Program
  // page variable picker lists ONLY declared variables. name must start with
  // RBP_; description is optional but without it the UI can't explain the
  // variable, so write one.
  "variables": [
    { "name": "RBP_grip_force", "type": "number", "init": 0.5, "description": { "ko": "그리퍼 힘", "en": "Gripper force" } },
    { "name": "RBP_target_pose", "type": "array", "init": [0, 0, 0] }
  ],

  // 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": "cpp", "entry": "__PLUGIN_SLUG__" },

  // 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` — the plugin's screens; when present it must contain at least one `toolbar` entry. Leave it out (or `[]`) for a backend-only plugin: no UI is built, and Node.js is not needed to build it
- `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
- `variables` — optional array of `{ name, type, init, description? }`:
  - `name` — must start with `RBP_`, then letters/digits/underscore; unique per plugin
  - `type` — `"number" | "string" | "array"`
  - `init` — required initial value, must match `type`
  - `description` — optional `string` or i18n object (`en` required in object form)

`muscat-pk build` throws on any validation error. `muscat-pk dev` prints
warnings — except `variables` errors (e.g. a name without the `RBP_` prefix),
which are hard errors in `dev` / `dev:back` too.

**Backend port rules:**
- Declare a port only if your backend opens a TCP server/listener.
- **Every listening TCP port must be declared.** `muscat-pk dev` and
  `muscat-pk dev:back` watch the backend and stop it the moment it opens a port
  that is not in `ports`. A port outside `28600-28999` can't be declared, so it
  must not be opened either — picking e.g. `5500` is not a way around the rule.
  It would escape this check *and* the robot's install-time conflict check, and
  only collide once it's running on a robot.
- Reserved ports include `502`, `2222`, `4840`, `5170-5179`, `8000-8999`,
  `10000`, `30004`, `34964`, `44818`, `50000-50005`, and `50051`.
- The robot rejects installation (HTTP 409) if a declared port is reserved,
  out of range, or already claimed by another enabled plugin.

**Reaching your backend's ports during development:**
- Declared ports are published to `127.0.0.1` on your machine, so
  `curl http://127.0.0.1:28600` works from the host on macOS, Windows, and Linux.
- On native Linux the dev container uses host networking, so the ports are on
  the host already.
- If a declared port is already taken on your machine, `muscat-pk dev` warns and
  skips publishing that one — the backend still listens inside the container.

---

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

---

## C++ SDK & dependencies

The dev container has the C++ SDK (`rainbow-rb-sdk-dev`) pre-installed — no local
install needed. The SDK version is the one pinned in `CMakeLists.txt` (`find_package(rb_sdk <version> EXACT REQUIRED)`). Pick a different one with:

```bash
muscat-pk sdk update <version>
```

`muscat-pk build` copies the matching `librb_sdk.so` next to your binary
(`dist/<arch>/lib/`, or `install-<arch>/<pkg>/lib/` for rclcpp), so the robot needs no SDK
install and each plugin keeps the SDK version it was built with.

Other libraries: install them in the build (e.g. vendor them under `cpp/` and
`add_subdirectory`, or link statically) — the robot only has Ubuntu 24.04 base
libraries.

To use the SDK outside a plugin (your own Ubuntu 24.04 machine):

```bash
curl -fsSL https://rainbowrobotics.github.io/rb-sdk/rb-sdk-apt-repo.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/rb-sdk-apt.gpg
echo 'deb [signed-by=/usr/share/keyrings/rb-sdk-apt.gpg] https://rainbowrobotics.github.io/rb-sdk stable main' | sudo tee /etc/apt/sources.list.d/rb-sdk.list
sudo apt update && sudo apt install rainbow-rb-sdk-dev
```


### Bundling extra shared libraries

The robot only has Ubuntu 24.04 base libraries. Copy any other `.so` your executable
needs into `${CMAKE_BINARY_DIR}/lib` — `muscat-pk build` ships that folder as
`dist/<arch>/lib/` and the executable finds it via its RPATH (`$ORIGIN/lib`):

```cmake
# cpp/CMakeLists.txt — third_party/ holds prebuilt libs for amd64 / arm64
set(ARCH_DIR ${CMAKE_SOURCE_DIR}/third_party/${CMAKE_SYSTEM_PROCESSOR})
target_link_libraries(__PLUGIN_SLUG__ PRIVATE ${ARCH_DIR}/libfoo.so)
add_custom_command(TARGET __PLUGIN_SLUG__ POST_BUILD
  COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/lib
  COMMAND ${CMAKE_COMMAND} -E copy ${ARCH_DIR}/libfoo.so ${CMAKE_BINARY_DIR}/lib/)
```

Build them for both arches (`x86_64`, `aarch64`) on Ubuntu 24.04 so they match the robot.
Static linking works too and needs no bundling. For an rclcpp node, `install(FILES ... DESTINATION lib)`
instead — the node finds `install-<arch>/<pkg>/lib/` the same way.
---

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

> Switching between a Python and a C++ backend asks whether to replace this README with the matching one (the old file is kept as `README.md.bak`). Add `--readme` to answer yes without the prompt.

---

## 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; with `lang: "cpp"`, the C++ SDK headers
  (`rainbow-rb-sdk-dev`, read out of the `muscat-pk` cpp dev image — build it
  once with `muscat-pk dev:back`).
- `check_project` — what this project must change for the plugin-ui it has
  installed (old APIs such as `connect(App)` or `Slider`, a `vite.config` without
  the `muscat()` preset, `tsc` errors), the same list `muscat-pk update` prints.
  Ask the assistant to fix the project after an update; it re-checks until clean.

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

`muscat-pk new` also writes `AGENTS.md` (read by Codex, Cursor, Gemini CLI, Copilot)
and a `CLAUDE.md` that imports it: the UI rules (plugin-ui components instead of
native `<select>`/`<input>`/`<button>`, design tokens for colors) for assistants that
do not call the MCP tools on their own. Add your own project notes there.

### 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** — register once with:

```bash
muscat-pk mcp --install codex
```

This appends the server to `~/.codex/config.toml` (idempotent — safe to run
again). Equivalent manual config:

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

> Building the other arch (e.g. arm64 on an amd64 PC) runs in an emulated container for
> C++ backends. Docker Desktop has it built in; on Linux enable it once with
> `docker run --privileged --rm tonistiigi/binfmt --install all`, or pass `--arch` for one arch.

- Builds `ui/content.tsx` → `dist/content.js` (minified)
- Compiles `cpp/` (Release) in the Ubuntu 24.04 container per arch → `dist/<arch>/<entry>` + `dist/<arch>/lib/librb_sdk.so.*`
- ROS2 (rclcpp): runs `colcon build` per arch → `dist/ros2_ws/install-<arch>/`
- Copies `assets/`, `manifest.json`, and `README*.md` into `dist/`
- 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
│   ├─ amd64/            # cpp: <entry> + lib/librb_sdk.so.*
│   ├─ arm64/
│   └─ ros2_ws/          # rclcpp: install-amd64/, install-arm64/
```

---

## All commands

```bash
muscat-pk dev        # UI + backend
muscat-pk dev:ui     # UI preview only (preview-host)
muscat-pk dev:back   # backend only (C++ rebuild + restart in 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 update         # update muscat-plugin-kit itself
muscat-pk uninstall      # remove muscat-pk itself
```
","ros2/ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/__init__.py":"","ros2/ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/node.py":"aW1wb3J0IHJjbHB5CmZyb20gcmNscHkubm9kZSBpbXBvcnQgTm9kZQpmcm9tIHJhaW5ib3cucmJfc2RrIGltcG9ydCBSQk1hbmlwdWxhdGVTREssIFJCUGx1Z2luQ2FsbCAgIyBQeVBJOiByYWluYm93LXJiLXNkawoKCnNkayA9IFJCTWFuaXB1bGF0ZVNESygpCnBsdWdpbiA9IFJCUGx1Z2luQ2FsbCgpCgoKIyBFeHRlcm5hbCBlbmRwb2ludCAoUkVTVCAvIFNvY2tldC5JTyAvIFRDUCAvIE1RVFQgLyBXZWJSVEMpLCBlLmcuCiMgICBjdXJsIC1YIFBPU1QgaHR0cDovLzxyb2JvdD4vY29tbW9uL3BsdWdpbi88cGx1Z2luX2lkPi9oZWxsbyAtZCAneyJuYW1lIjogImtpbSJ9JwpAcGx1Z2luLnJvdXRlci5vbigiL2hlbGxvIikKZGVmIGhlbGxvKHBheWxvYWQ9Tm9uZSwgbWV0YT1Ob25lKToKICAgIG5hbWUgPSAocGF5bG9hZCBvciB7fSkuZ2V0KCJuYW1lIiwgInRoZXJlIikKICAgIHJldHVybiB7Im1zZyI6IGYiaGkge25hbWV9IiwgInZpYSI6IChtZXRhIG9yIHt9KS5nZXQoInRyYW5zcG9ydCIpfQoKCmNsYXNzIF9fUExVR0lOX0NMQVNTX19Ob2RlKE5vZGUpOgogICAgZGVmIF9faW5pdF9fKHNlbGYpOgogICAgICAgIHN1cGVyKCkuX19pbml0X18oIl9fUExVR0lOX1NMVUdfX19ub2RlIikKICAgICAgICAjIEFsc28gY29ubmVjdHMgdGhlIHBsdWdpbiB0byBNdXNjYXQg4oCUIHJvdXRlciBoYW5kbGVycyByZWdpc3RlciBvbiB0aGUgZmlyc3QgY2FsbC4KICAgICAgICBwbHVnaW4ucHVibGlzaCgic3RhdGUiLCB7InJlYWR5IjogVHJ1ZSwgInBsdWdpbiI6ICJfX1BMVUdJTl9OQU1FX18ifSkgICMgLT4gVUkgcmIuc3ViKCJzdGF0ZSIpCiAgICAgICAgc2VsZi5nZXRfbG9nZ2VyKCkuaW5mbygiX19QTFVHSU5fTkFNRV9fIG5vZGUgc3RhcnRlZCIpCiAgICAgICAgIyBzZGsgaXMgYXZhaWxhYmxlIGhlcmUg4oCUIHVzZSBpdCBhbG9uZ3NpZGUgUk9TMiB0b3BpY3MgYXMgbmVlZGVkCgoKZGVmIG1haW4oYXJncz1Ob25lKToKICAgIHJjbHB5LmluaXQoYXJncz1hcmdzKQogICAgbm9kZSA9IF9fUExVR0lOX0NMQVNTX19Ob2RlKCkKICAgIHJjbHB5LnNwaW4obm9kZSkKICAgIG5vZGUuZGVzdHJveV9ub2RlKCkKICAgIHJjbHB5LnNodXRkb3duKCkKCgppZiBfX25hbWVfXyA9PSAiX19tYWluX18iOgogICAgbWFpbigpCg==","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":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fKQoKaWYoTk9UIENNQUtFX0NYWF9TVEFOREFSRCkKICBzZXQoQ01BS0VfQ1hYX1NUQU5EQVJEIDE3KQplbmRpZigpCgpmaW5kX3BhY2thZ2UoYW1lbnRfY21ha2UgUkVRVUlSRUQpCmZpbmRfcGFja2FnZShyY2xjcHAgUkVRVUlSRUQpCiMgUmFpbmJvdyBSb2JvdGljcyBDKysgU0RLIChhcHQ6IHJhaW5ib3ctcmItc2RrLWRldiwgcHJlLWluc3RhbGxlZCBpbiB0aGUgZGV2CiMgY29udGFpbmVyKS4gVGhlIHZlcnNpb24gaGVyZSBpcyB0aGUgb25lIHRoZSBkZXYgY29udGFpbmVyIGluc3RhbGxzOyBjaGFuZ2UgaXQKIyB3aXRoIGBtdXNjYXQtcGsgc2RrIHVwZGF0ZSA8dmVyc2lvbj5gLgpmaW5kX3BhY2thZ2UocmJfc2RrIDAuMTAuMiBFWEFDVCBSRVFVSVJFRCkKCmFkZF9leGVjdXRhYmxlKF9fUExVR0lOX1NMVUdfX19ub2RlIHNyYy9ub2RlLmNwcCkKYW1lbnRfdGFyZ2V0X2RlcGVuZGVuY2llcyhfX1BMVUdJTl9TTFVHX19fbm9kZSByY2xjcHApCnRhcmdldF9saW5rX2xpYnJhcmllcyhfX1BMVUdJTl9TTFVHX19fbm9kZSByYl9zZGs6OnJiX3NkaykKCmluc3RhbGwoVEFSR0VUUyBfX1BMVUdJTl9TTFVHX19fbm9kZQogIERFU1RJTkFUSU9OIGxpYi8ke1BST0pFQ1RfTkFNRX0pCgphbWVudF9wYWNrYWdlKCkK","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":"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","docker/Dockerfile.cpp":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgcHVyZSBDKysgcGx1Z2luIGJhY2sgZW5kLgojIE1hdGNoZXMgdGhlIE11c2NhdCByb2JvdCBiYWNrZW5kIE9TIChVYnVudHUgMjQuMDQpIHNvIHRoZSBjb21waWxlZCBiaW5hcnkKIyBpcyBBQkktY29tcGF0aWJsZSB3aXRoIHRoZSByb2JvdC4gVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCBhbmQgYGJ1aWxkYAojIOKAlCBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUC4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIGJ1aWxkLWVzc2VudGlhbCBcCiAgICAgIGNtYWtlIFwKICAgICYmIHJtIC1yZiAvdmFyL2xpYi9hcHQvbGlzdHMvKgoKIyBSYWluYm93IFJvYm90aWNzIEMrKyBTREsgZm9yIGZpbmRfcGFja2FnZShyYl9zZGspLiBtdXNjYXQtcGsgcGFzc2VzIHRoZSB2ZXJzaW9uIHBpbm5lZCBpbiB0aGUKIyBwcm9qZWN0J3MgQ01ha2VMaXN0cy50eHQgKGZpbmRfcGFja2FnZShyYl9zZGsgPHZlcj4gRVhBQ1QpKTsgd2l0aG91dCBhIHBpbiAoUk9TIDIgcmNscHksIGBtdXNjYXQtcGsgbWNwYAojIG91dHNpZGUgYSBwcm9qZWN0KSB0aGUgbmV3ZXN0IFNESyBpcyBpbnN0YWxsZWQuIFJ1bnRpbWUgYW5kIC1kZXYgYXJlIGluc3RhbGxlZCB0b2dldGhlciBhdCBvbmUgdmVyc2lvbi4KQVJHIFJCX1NES19WRVJTSU9OPQpSVU4gYXB0LWdldCB1cGRhdGUgJiYgYXB0LWdldCBpbnN0YWxsIC15IC0tbm8taW5zdGFsbC1yZWNvbW1lbmRzIGNhLWNlcnRpZmljYXRlcyBjdXJsIFwKICAgICYmIGluc3RhbGwgLWQgL2V0Yy9hcHQva2V5cmluZ3MgXAogICAgJiYgY3VybCAtZnNTTCBodHRwczovL3JhaW5ib3dyb2JvdGljcy5naXRodWIuaW8vcmItc2RrL3JiLXNkay1hcHQtcmVwby5ncGcua2V5IC1vIC9ldGMvYXB0L2tleXJpbmdzL3JiLXNkay5hc2MgXAogICAgJiYgcHJpbnRmICdkZWIgW3NpZ25lZC1ieT0vZXRjL2FwdC9rZXlyaW5ncy9yYi1zZGsuYXNjXSBodHRwczovL3JhaW5ib3dyb2JvdGljcy5naXRodWIuaW8vcmItc2RrICVzIG1haW5cbicgc3RhYmxlIGRldiA+IC9ldGMvYXB0L3NvdXJjZXMubGlzdC5kL3JiLXNkay5saXN0IFwKICAgICYmIGFwdC1nZXQgdXBkYXRlIFwKICAgICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyAicmFpbmJvdy1yYi1zZGske1JCX1NES19WRVJTSU9OOis9JFJCX1NES19WRVJTSU9OfSIgInJhaW5ib3ctcmItc2RrLWRldiR7UkJfU0RLX1ZFUlNJT046Kz0kUkJfU0RLX1ZFUlNJT059IiBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyoKCgpXT1JLRElSIC9wbHVnaW4KCkNNRCBbImJhc2giXQo=","docker/Dockerfile.dev":"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","docker/Dockerfile.python":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgUHl0aG9uIHBsdWdpbiBiYWNrIGVuZC4KIyBNYXRjaGVzIHRoZSBNdXNjYXQgcm9ib3QgYmFja2VuZDogVWJ1bnR1IDI0LjA0ICsgUHl0aG9uIDMuMTIuCiMgVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCAoaG90LXJlbG9hZCkgYW5kIGBtdXNjYXQtcGsgYnVpbGRgIChsb2NrICsgd2hlZWwgdmVuZG9yKS4KIyBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUCDigJQgdGhlIHJvYm90IGluc3RhbGxzIGRlcHMgZnJvbSBkaXN0L3doZWVscy8gb2ZmbGluZS4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIHB5dGhvbjMgXAogICAgICBweXRob24zLXBpcCBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyogXAogICAgJiYgcGlwMyBpbnN0YWxsIHV2PT0wLjguMTggLS1icmVhay1zeXN0ZW0tcGFja2FnZXMKCiMgVE9ETyhjcHAtc2RrKTogdGhlIFB5dGhvbiBTREsgaXMgYSBweWJpbmQgd3JhcHBlciBvdmVyIHRoZSBjcHAgU0RLLCBzbyB0aGUKIyBjcHAgU0RLIHNoYXJlZCBsaWIgbXVzdCBiZSBwcmVzZW50IGZvciB0aGUgcHl0aG9uIG1vZHVsZSB0byBsb2FkLiBJbnN0YWxsIHRoZQojIHJhaW5ib3cgY3BwIFNESyAoYXB0LCBwaW5uZWQgdG8gdGhlIHJvYm90J3MgdmVyc2lvbikgaGVyZSBvbmNlIGl0IGV4aXN0cy4KCgpXT1JLRElSIC9wbHVnaW4KCkNNRCBbImJhc2giXQo="};

package/cli/src/zip.mjs

@@ -0,0 +1,121 @@
+// Minimal ZIP writer (deflate) for `muscat-pk build`, instead of the `zip` CLI that Windows lacks.
+//
+// Entries carry Unix modes because the robot is Linux: C++ binaries and ROS 2 node scripts must stay
+// executable. macOS/Linux store each file's real mode. Windows (NTFS) has no executable bit, so there
+// an ELF binary or a `#!` script is stored as 0755 and everything else as 0644.
+// Like `zip -r`, symlinks are followed and their targets' contents stored. No ZIP64: a plugin ZIP over
+// 4 GB or 65535 entries is refused.
+import { closeSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { deflateRawSync } from "node:zlib";
+
+const CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
+  let c = n;
+  for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+  return c >>> 0;
+});
+
+function crc32(buf) {
+  let c = 0xffffffff;
+  for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+function dosTime(date) {
+  const d = date.getFullYear() < 1980 ? new Date(1980, 0, 1) : date;
+  return {
+    time: (d.getHours() << 11) | (d.getMinutes() << 5) | (d.getSeconds() >> 1),
+    date: ((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate(),
+  };
+}
+
+function looksExecutable(file) {
+  const head = Buffer.alloc(4);
+  const fd = openSync(file, "r");
+  try {
+    readSync(fd, head, 0, 4, 0);
+  } finally {
+    closeSync(fd);
+  }
+  return head.equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])) || (head[0] === 0x23 && head[1] === 0x21);
+}
+
+function unixMode(file, stat) {
+  if (stat.isDirectory()) return 0o40755;
+  if (process.platform !== "win32") return 0o100000 | (stat.mode & 0o777);
+  return 0o100000 | (looksExecutable(file) ? 0o755 : 0o644);
+}
+
+function collect(root, rel, out) {
+  const full = resolve(root, rel);
+  const stat = statSync(full);
+  if (stat.isDirectory()) {
+    out.push({ name: `${rel.split(sep).join("/")}/`, full, stat });
+    for (const child of readdirSync(full).sort()) collect(root, join(rel, child), out);
+  } else {
+    out.push({ name: rel.split(sep).join("/"), full, stat });
+  }
+}
+
+/** Write `entries` (paths relative to `cwd`, files or directories) into a new ZIP at `zipPath`. */
+export function writeZip(zipPath, entries, cwd) {
+  const items = [];
+  for (const e of entries) collect(cwd, relative(cwd, resolve(cwd, e)), items);
+  if (items.length > 0xffff) throw new Error(`too many files for a ZIP (${items.length})`);
+
+  const chunks = [];
+  const central = [];
+  let offset = 0;
+  for (const { name, full, stat } of items) {
+    const isDir = name.endsWith("/");
+    const data = isDir ? Buffer.alloc(0) : readFileSync(full);
+    const deflated = isDir ? data : deflateRawSync(data);
+    const stored = deflated.length >= data.length;
+    const body = stored ? data : deflated;
+    const crc = crc32(data);
+    const nameBuf = Buffer.from(name, "utf8");
+    const { time, date } = dosTime(stat.mtime);
+    if (offset + body.length > 0xffffffff) throw new Error("plugin ZIP would exceed 4 GB");
+
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4); // version needed
+    local.writeUInt16LE(0x0800, 6); // UTF-8 names
+    local.writeUInt16LE(stored ? 0 : 8, 8);
+    local.writeUInt16LE(time, 10);
+    local.writeUInt16LE(date, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(body.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(nameBuf.length, 26);
+    local.writeUInt16LE(0, 28);
+
+    const cdir = Buffer.alloc(46);
+    cdir.writeUInt32LE(0x02014b50, 0);
+    cdir.writeUInt16LE((3 << 8) | 20, 4); // made by Unix, so unzip applies the mode below
+    cdir.writeUInt16LE(20, 6);
+    cdir.writeUInt16LE(0x0800, 8);
+    cdir.writeUInt16LE(stored ? 0 : 8, 10);
+    cdir.writeUInt16LE(time, 12);
+    cdir.writeUInt16LE(date, 14);
+    cdir.writeUInt32LE(crc, 16);
+    cdir.writeUInt32LE(body.length, 20);
+    cdir.writeUInt32LE(data.length, 24);
+    cdir.writeUInt16LE(nameBuf.length, 28);
+    cdir.writeUInt32LE(((unixMode(full, stat) << 16) | (isDir ? 0x10 : 0)) >>> 0, 38);
+    cdir.writeUInt32LE(offset, 42);
+
+    chunks.push(local, nameBuf, body);
+    central.push(cdir, nameBuf);
+    offset += local.length + nameBuf.length + body.length;
+  }
+
+  const centralBuf = Buffer.concat(central);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(items.length, 8);
+  end.writeUInt16LE(items.length, 10);
+  end.writeUInt32LE(centralBuf.length, 12);
+  end.writeUInt32LE(offset, 16);
+  writeFileSync(zipPath, Buffer.concat([...chunks, centralBuf, end]));
+}

package/cli/storybook-dist/project.json

@@ -1 +1 @@
-{"generatedAt":1792723512697,"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":1792728734236,"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/README.md

@@ -390,7 +390,7 @@ def move_j_example():
     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},
+        target={"tar_values": [0, 0, 0, 0, 0, 0, 0], "tar_frame": -1, "tar_unit": 0},
     )
 
 

package/cli/templates/common/py/main.py

@@ -81,8 +81,8 @@ def move_j_example():
     return manipulate.move.call_move_j(
         robot_model="C500920",
         target={
-            "tar_values": [0, 0, 0, 0, 0, 0],
-            "tar_frame": 0,
+            "tar_values": [0, 0, 0, 0, 0, 0, 0],
+            "tar_frame": -1,
             "tar_unit": 0,
         },
     )

package/cli/templates/cpp/cpp/main.cpp

@@ -59,7 +59,7 @@ int main() {
   });
 
   // Example: robot control (not called automatically — add safety checks first).
-  //   IPC::MoveInput_TargetT t; t.tar_values = {0, 0, 0, 0, 0, 0};
+  //   IPC::MoveInput_TargetT t; t.tar_values = {0, 0, 0, 0, 0, 0, 0}; t.tar_frame = -1; t.tar_unit = 0;
   //   manipulate.move.call_move_j("C500920", t);
 
   plugin->publish("state", {{"ready", true}, {"plugin", name}});

package/cli/templates/readme-cpp/README.md

@@ -537,9 +537,9 @@ RBManipulateSDK manipulate;                       // on the robot: connects to t
 manipulate.state.call_servocontrol("C500920", 1);
 
 IPC::MoveInput_TargetT t;
-t.tar_values = {0, 0, 90, 0, 90, 0};
-t.tar_frame = 0;
-t.tar_unit = 1;
+t.tar_values = {0, 0, 90, 0, 90, 0, 0};  // joint degrees, always 7 values (7th = 0 on 6-axis arms)
+t.tar_frame = -1;                        // -1 = joint space
+t.tar_unit = 0;                          // 0 = mm/deg
 manipulate.move.call_move_j("C500920", t, std::nullopt, MoveSpeedArg{1, 60.f, 120.f});
 manipulate.move.call_move_wait("C500920", -1);
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rainbow-robotics/muscat-plugin-kit",
-  "version": "1.10.2-dev.6",
+  "version": "1.10.2-dev.7",
   "type": "module",
   "engines": {
     "node": ">=20"
@@ -52,8 +52,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@rainbow-robotics/plugin-ui": "1.10.2-dev.6",
-    "@rainbow-robotics/preview-host": "1.10.2-dev.6",
+    "@rainbow-robotics/plugin-ui": "1.10.2-dev.7",
+    "@rainbow-robotics/preview-host": "1.10.2-dev.7",
     "@types/react": "^19.0.10",
     "postcss": "^8.5.8",
     "typescript": "^5.8.0",