@rainbow-robotics/muscat-plugin-kit 0.1.2-dev.44 → 0.1.2-dev.45

package/cli/src/ports.mjs

@@ -0,0 +1,160 @@
+// Port contract helpers for plugin back ends.
+import { spawnSync } from "node:child_process";
+
+export const PLUGIN_PORT_MIN = 28600;
+export const PLUGIN_PORT_MAX = 28999;
+export const INTERNAL_DEV_PORTS = new Set([10000]);
+export const RESERVED_BACKEND_PORTS = new Map([
+  [502, "Modbus TCP"],
+  [4840, "OPC-UA"],
+  [10000, "muscat-pk Socket.IO bridge"],
+  [2222, "EtherNet/IP Implicit"],
+  [30004, "RTDE"],
+  [34964, "ProfiNET"],
+  [44818, "EtherNet/IP Explicit"],
+  [50051, "gRPC"],
+]);
+export const RESERVED_BACKEND_PORT_RANGES = [
+  { from: 5170, to: 5179, name: "UI 517x servers" },
+  { from: 8000, to: 8999, name: "Muscat/internal 8000 range" },
+  { from: 50000, to: 50005, name: "robot TCP/UDP ASCII and REST interfaces" },
+];
+
+function reservedPortReason(port) {
+  if (RESERVED_BACKEND_PORTS.has(port)) return RESERVED_BACKEND_PORTS.get(port);
+  const range = RESERVED_BACKEND_PORT_RANGES.find((item) => port >= item.from && port <= item.to);
+  if (!range) return null;
+  return `${range.name} (${range.from}-${range.to})`;
+}
+
+function isPluginManagedPort(port) {
+  return reservedPortReason(port) || (port >= PLUGIN_PORT_MIN && port <= PLUGIN_PORT_MAX);
+}
+
+function isInt(value) {
+  return Number.isInteger(value);
+}
+
+function validatePort(port, field, errors) {
+  if (!isInt(port)) {
+    errors.push(`${field}: must be a port number`);
+    return;
+  }
+  if (port < 1 || port > 65535) {
+    errors.push(`${field}: port must be between 1 and 65535`);
+    return;
+  }
+  const reserved = reservedPortReason(port);
+  if (reserved) {
+    errors.push(`${field}: ${port} is reserved for ${reserved}`);
+    return;
+  }
+  if (port < PLUGIN_PORT_MIN || port > PLUGIN_PORT_MAX) {
+    errors.push(
+      `${field}: external plugin backend ports must be within ${PLUGIN_PORT_MIN}-${PLUGIN_PORT_MAX}`,
+    );
+  }
+}
+
+export function normalizePorts(ports, errors = []) {
+  if (ports === undefined || ports === null) return [];
+  if (!Array.isArray(ports)) {
+    errors.push(`"ports" must be an array`);
+    return [];
+  }
+  if (ports.length === 0) {
+    errors.push(`"ports" must not be empty when provided`);
+    return [];
+  }
+
+  const normalized = [];
+  const seen = new Set();
+  ports.forEach((port, i) => {
+    validatePort(port, `ports[${i}]`, errors);
+    if (!isInt(port)) return;
+    if (seen.has(port)) {
+      errors.push(`"ports" entries must be unique (duplicate: ${port})`);
+      return;
+    }
+    seen.add(port);
+    normalized.push(port);
+  });
+
+  return normalized;
+}
+
+export function validatePorts(ports, errors) {
+  normalizePorts(ports, errors);
+}
+
+export function manifestPortRanges(manifest) {
+  return normalizePorts(manifest?.ports, []);
+}
+
+export function formatPortRange(range) {
+  return String(range);
+}
+
+export function formatPortRanges(ranges) {
+  return ranges.map(formatPortRange).join(", ");
+}
+
+export function portInRanges(port, ranges) {
+  return ranges.includes(port);
+}
+
+export function portEnvFlags(ranges) {
+  if (ranges.length === 0) return [];
+  return ["-e", `RB_PLUGIN_PORTS=${ranges.map(formatPortRange).join(",")}`];
+}
+
+function listeningTcpPorts(container) {
+  const script = `
+for f in /proc/net/tcp /proc/net/tcp6; do
+  [ -r "$f" ] || continue
+  tail -n +2 "$f" | while read -r sl local_address rem_address st rest; do
+    [ "$st" = "0A" ] || continue
+    hex_port="\${local_address##*:}"
+    printf "%d\\n" "0x$hex_port"
+  done
+done | sort -n -u
+`;
+  const r = spawnSync("docker", ["exec", container, "bash", "-lc", script], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0) return [];
+  return String(r.stdout || "")
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((v) => Number(v))
+    .filter((v) => Number.isInteger(v));
+}
+
+export function startPortContractMonitor({ container, ranges, log, intervalMs = 1000 }) {
+  const declared = ranges ?? [];
+  let reported = false;
+  const timer = setInterval(() => {
+    const ports = listeningTcpPorts(container)
+      .filter((port) => !INTERNAL_DEV_PORTS.has(port))
+      .filter((port) => isPluginManagedPort(port));
+    const unexpected = ports.filter((port) => reservedPortReason(port) || !portInRanges(port, declared));
+    if (unexpected.length === 0) return;
+
+    clearInterval(timer);
+    reported = true;
+    const declaredText = declared.length > 0 ? formatPortRanges(declared) : "(none)";
+    log.error(
+      `backend opened reserved or undeclared plugin TCP port(s): ${unexpected.join(", ")}. ` +
+      `Add them to manifest.json "ports" within ${PLUGIN_PORT_MIN}-${PLUGIN_PORT_MAX}. ` +
+      `Declared: ${declaredText}`,
+    );
+    spawnSync("docker", ["rm", "-f", container], { stdio: "ignore" });
+    process.exit(1);
+  }, intervalMs);
+  timer.unref?.();
+
+  return () => {
+    clearInterval(timer);
+    return reported;
+  };
+}

package/cli/src/sdk.mjs

@@ -1,8 +1,13 @@
 // muscat-pk sdk <list|update [version]> — manage the python rainbow-rb-sdk.
-import { spawnSync } from "node:child_process";
+//
+// Pins requirements.txt — the real install happens in the `dev`/`dev:back`
+// Docker container. If a local .venv exists (see devBack.mjs's syncIdeVenv,
+// for editor/linter support), also update it in place so pylint/pyright see
+// the new version immediately; this is best-effort only.
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { findPluginRoot, log } from "./util.mjs";
+import { spawnSync } from "node:child_process";
+import { findPluginRoot, log, venvPython } from "./util.mjs";
 
 const PKG = "rainbow-rb-sdk";
 
@@ -50,15 +55,12 @@ export async function runSdk(args = []) {
     writeFileSync(reqs, content);
     log.ok(`requirements.txt → ${line}`);
 
-    const py = resolve(root, ".venv", "bin", "python");
+    const py = venvPython(resolve(root, ".venv"));
     if (existsSync(py)) {
-      log.step("pip install -r requirements.txt…");
-      spawnSync(py, ["-m", "pip", "install", "-q", "-r", reqs], {
-        cwd: root,
-        stdio: "inherit",
-      });
+      log.step("pip install -r requirements.txt (.venv, for your editor)…");
+      spawnSync(py, ["-m", "pip", "install", "-q", "-r", reqs], { cwd: root, stdio: "inherit" });
     } else {
-      log.warn(".venv not found; run `muscat-pk dev:back` to install.");
+      log.info("Installed automatically on the next `muscat-pk dev` / `dev:back` (Docker container).");
     }
     return;
   }

package/cli/src/storybook.mjs

@@ -0,0 +1,168 @@
+// muscat-pk storybook — serve the bundled Storybook (foundations + muscat) so
+// plugin authors can browse the real rb-components UI while developing.
+//
+// The static build is produced from apps/storybook (MUSCAT_STORYBOOK=true → only
+// the 1.foundations + 4.muscat sections, ordering-number prefixes stripped) and
+// staged into cli/storybook-dist so it ships inside the published muscat-pk.
+// In the monorepo it's built on demand if missing (or with --rebuild).
+import { createServer } from "node:http";
+import {
+  cpSync,
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  rmSync,
+  statSync,
+} from "node:fs";
+import { execSync, spawn } from "node:child_process";
+import { copyFileSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { kitRoot, log, parseArgs } from "./util.mjs";
+
+// Shipped location (under cli/ → included in the npm "files" list).
+const SHIPPED_DIST = resolve(kitRoot, "cli/storybook-dist");
+// Raw .stories.tsx sources, staged alongside the compiled build — the `mcp`
+// command's get_component_example tool reads these directly (real usage
+// code, not just prop types) without needing a Storybook runtime.
+export const SHIPPED_STORIES_SRC = resolve(SHIPPED_DIST, "_stories-src");
+// Monorepo source (absent in an external install).
+const REPO_ROOT = resolve(kitRoot, "../..");
+const REPO_STORYBOOK = resolve(REPO_ROOT, "apps/storybook");
+const REPO_BUILD_OUT = resolve(REPO_STORYBOOK, "storybook-static-muscat");
+const REPO_MUSCAT_STORIES = resolve(REPO_STORYBOOK, "stories/4.muscat");
+const REPO_DESIGN_TOKENS = resolve(
+  REPO_ROOT,
+  "packages/rb-styles/css/output/rb-token.css",
+);
+// Generated Tailwind v4 token file (@theme colors + @utility typo-*), staged so
+// the `mcp` command's *_design_tokens tools work in an external install too.
+export const SHIPPED_DESIGN_TOKENS = resolve(SHIPPED_DIST, "_design-tokens.css");
+
+const CONTENT_TYPE = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm",
+};
+
+// Build apps/storybook (muscat subset) and stage it into cli/storybook-dist.
+// Monorepo only. Outside the monorepo (e.g. re-packing an already-published
+// copy) it's a no-op — the shipped cli/storybook-dist is already in place.
+export function buildStorybook() {
+  if (!existsSync(REPO_STORYBOOK)) {
+    log.info("apps/storybook not found — using the pre-staged storybook-dist.");
+    return;
+  }
+  log.step("building Storybook (foundations + muscat)…");
+  execSync("yarn workspace storybook storybook:build:muscat", {
+    cwd: REPO_ROOT,
+    stdio: "inherit",
+    env: { ...process.env, MUSCAT_STORYBOOK: "true" },
+  });
+  rmSync(SHIPPED_DIST, { recursive: true, force: true });
+  mkdirSync(SHIPPED_DIST, { recursive: true });
+  cpSync(REPO_BUILD_OUT, SHIPPED_DIST, { recursive: true });
+
+  // Stage raw .stories.tsx sources (not just the compiled JS bundle) for the
+  // `mcp` command's get_component_example tool.
+  if (existsSync(REPO_MUSCAT_STORIES)) {
+    cpSync(REPO_MUSCAT_STORIES, SHIPPED_STORIES_SRC, {
+      recursive: true,
+      filter: (src) => statSync(src).isDirectory() || src.endsWith(".stories.tsx"),
+    });
+  }
+
+  // Stage the design-token CSS for the `mcp` command's *_design_tokens tools.
+  if (existsSync(REPO_DESIGN_TOKENS)) {
+    copyFileSync(REPO_DESIGN_TOKENS, SHIPPED_DESIGN_TOKENS);
+  }
+
+  log.ok(`storybook → ${SHIPPED_DIST}`);
+}
+
+function openBrowser(url) {
+  const cmd =
+    process.platform === "darwin"
+      ? "open"
+      : process.platform === "win32"
+        ? "start"
+        : "xdg-open";
+  try {
+    spawn(cmd, [url], {
+      stdio: "ignore",
+      detached: true,
+      shell: process.platform === "win32",
+    }).unref();
+  } catch {
+    /* headless / no browser — the URL is printed anyway */
+  }
+}
+
+function serve(distDir, port) {
+  const server = createServer((req, res) => {
+    const url = decodeURIComponent((req.url || "/").split("?")[0]);
+    const rel = url === "/" ? "/index.html" : url;
+    const filePath = resolve(distDir, `.${rel}`);
+
+    // Serve the file if it's inside distDir and exists; otherwise fall back to
+    // index.html (Storybook is a single-page app).
+    if (
+      filePath.startsWith(distDir) &&
+      existsSync(filePath) &&
+      statSync(filePath).isFile()
+    ) {
+      const type = CONTENT_TYPE[extname(filePath)];
+      if (type) res.setHeader("Content-Type", type);
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      createReadStream(filePath).pipe(res);
+      return;
+    }
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    createReadStream(join(distDir, "index.html")).pipe(res);
+  });
+
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      log.error(`port ${port} is in use — pass a free one with --port <n>.`);
+      process.exit(1);
+    }
+    throw err;
+  });
+
+  server.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    log.ok(`Storybook → ${url}`);
+    openBrowser(url);
+  });
+}
+
+export async function runStorybook(args = []) {
+  const { port = "6007", rebuild } = parseArgs(args, { booleans: ["rebuild"] });
+
+  const staged = existsSync(join(SHIPPED_DIST, "index.html"));
+  if (rebuild || !staged) {
+    if (existsSync(REPO_STORYBOOK)) {
+      buildStorybook();
+    } else if (!staged) {
+      throw new Error(
+        `Storybook build not found at ${SHIPPED_DIST}.\n` +
+          "  This build of muscat-pk was published without the bundled Storybook.",
+      );
+    }
+  }
+
+  serve(SHIPPED_DIST, Number(port));
+}

package/cli/src/templates-embedded.mjs

@@ -1,3 +1,3 @@
 // AUTO-GENERATED by cli/bundle-templates.mjs — do not edit.
 // ponytail: generated at publish time; not tracked in git.
-export const TEMPLATES = {"common/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
├─ 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`)

### useRb() hook

Access the communication API between the plugin module and UI from any plugin component.

```tsx
import { useRb } from "@rainbow-robotics/plugin-ui/sdk";

function App() {
  const rb = useRb();
}
```

### rb API

| Method | Description |
|---|---|
| `rb.pub(topic, payload)` | Publish a message to a topic |
| `rb.sub(topic, handler)` | Subscribe to a topic — returns `{ undeclare() }` |
| `rb.action(topic, payload?)` | Send a request and await a reply |
| `rb.serve(topic, handler)` | Handle incoming requests from the backend |
| `rb.toast(message, type?)` | Host toast notification (`"info" · "success" · "warning" · "error"`) |

All methods support Generic Types:

```tsx
const status = await rb.action<{ ok: boolean }, { id: number }>(
  "get-status",
  { id: 1 },
);

const sub = await rb.sub<{ value: number }>("sensor/data", (data) => {
  console.log(data.value);
});
sub.undeclare(); // cleanup
```

### Topic namespace

Topics are automatically namespaced by plugin ID to prevent collisions across plugins.

```
"sensor/data"   →  plugin/{pluginId}/sensor/data   (auto-namespaced)
"/broadcast/x"  →  broadcast/x                    (leading / = absolute)
```

### UI components

Import Muscat components from `@rainbow-robotics/plugin-ui/react`. The plugin emits
`rb-*` tags; the host renders the actual components.

```tsx
import { connect } from "@rainbow-robotics/plugin-ui/connect";
import { Button, Slider, Text, Switch } from "@rainbow-robotics/plugin-ui/react";
import { useRb } from "@rainbow-robotics/plugin-ui/sdk";

function App() {
  const rb = useRb();
  return <Button label="Run" onPress={() => rb.action("run")} />;
}

connect(App);
```

---

## Backend (`py/main.py`)

The backend communicates with the frontend using `rainbow.rb_sdk.RBPluginCall`.
`muscat-pk dev` starts the Socket.IO bridge in Docker (published on port 10000) and
runs the backend container sharing its network, so the SDK connects at localhost:10000.
`py/main.py` should contain plugin logic only and must not start its own server.

### Python plugin

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

### ROS2 plugin

The node is launched with `--ros-args -r __ns:=/{slug}` automatically by `dev:back`.

```python
# ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/node.py
import rclpy
from rclpy.node import Node
from std_msgs.msg import Float32

class __PLUGIN_CLASS__Node(Node):
    def __init__(self):
        super().__init__("__PLUGIN_SLUG___node")
        # relative topic name — __ns prefix applied automatically
        self.pub = self.create_publisher(Float32, "sensor_data", 10)
        self.create_timer(1.0, self.timer_cb)

    def timer_cb(self):
        self.pub.publish(Float32(data=42.0))
```

---

## manifest.json

```jsonc
{
  // 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.command — adds a step node to the program tree
    {
      "point": "program.command",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "program/content",   // must be unique across all contributions
      "commandInfo": {
        "name": "My Plugin",
        "icon": "assets/icon.svg",
        "funcName": "plugin.run",
        "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"
    },
    // move.rnb — adds a panel to the Move screen right-side area
    {
      "point": "move.rnb",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "move/content"       // must be unique across all contributions
    }
  ],

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

**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 | `commandInfo` required |
|---|---|:---:|
| `toolbar` | Top toolbar button (must have at least one) | — |
| `program.command` | Program tree step node | ✓ |
| `move.rnb` | Move screen right-side panel | — |

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

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

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

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

---

## 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 or venv needed.

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

---

## Shipping

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

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

ZIP layout:

```
__PLUGIN_DIR__-1.0.0.zip
├─ dist/
│   ├─ content.js        # built UI
│   ├─ manifest.json
│   ├─ assets/
│   ├─ README.md
│   ├─ README.ko.md      # if present
│   ├─ main.py           # from py/
│   └─ requirements.txt  # pinned
└─ ros2_ws/install/      # ROS2 only
```

---

## All commands

```bash
muscat-pk dev        # UI + backend
muscat-pk dev:ui     # UI preview only (preview-host)
muscat-pk dev:back   # backend only (Python: watchfiles / ROS2: Docker)
muscat-pk build      # build → dist/ + distributable ZIP (--no-zip to skip)
```

```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":"PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMiAzMiIgd2lkdGg9IjFlbSIgaGVpZ2h0PSIxZW0iIGZpbGw9Im5vbmUiPgogIDxwYXRoIGZpbGw9ImN1cnJlbnRDb2xvciIgZD0iTTE2IDNhMTMgMTMgMCAxIDAgMCAyNiAxMyAxMyAwIDAgMCAwLTI2Wm0wIDRhMyAzIDAgMCAxIDMgM3YyLjE4YTMgMyAwIDAgMSAwIDUuNjRWMjBhMyAzIDAgMSAxLTYgMHYtMi4xOGEzIDMgMCAwIDEgMC01LjY0VjEwYTMgMyAwIDAgMSAzLTNaIi8+Cjwvc3ZnPgo=","common/manifest.json":"ewogICJpZCI6ICJfX1BMVUdJTl9JRF9fIiwKICAibmFtZSI6ICJfX1BMVUdJTl9OQU1FX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAibWluTXVzY2F0VmVyc2lvbiI6ICIxLjAuMCIsCiAgImF1dGhvciI6ICJfX1BMVUdJTl9BVVRIT1JfXyIsCiAgImVtYWlsIjogIl9fUExVR0lOX0VNQUlMX18iLAogICJkZXNjcmlwdGlvbiI6IHsKICAgICJrbyI6ICIiLAogICAgImVuIjogIiIKICB9LAogICJpY29ucyI6ICJhc3NldHMvaWNvbi5zdmciLAogICJ0YXJnZXRNb2RlbHMiOiAiYWxsIiwKICAidGFyZ2V0Q2F0ZWdvcnlzIjogImFsbCIsCiAgImNvbnRyaWJ1dGVzIjogWwogICAgewogICAgICAicG9pbnQiOiAidG9vbGJhciIsCiAgICAgICJpY29uIjogImFzc2V0cy9pY29uLnN2ZyIsCiAgICAgICJsYWJlbCI6IHsgImtvIjogIl9fUExVR0lOX05BTUVfXyIsICJlbiI6ICJfX1BMVUdJTl9OQU1FX18iIH0sCiAgICAgICJ1aSI6ICJjb250ZW50IiwKICAgICAgIm9wZW5zIjogInBvcG92ZXIiCiAgICB9CiAgXSwKICAicnVudGltZSI6IHsgInR5cGUiOiAiX19SVU5USU1FX1RZUEVfXyIsICJlbnRyeSI6ICJtYWluLnB5IiB9Cn0K","common/package.json":"ewogICJuYW1lIjogIl9fUExVR0lOX0lEX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAicHJpdmF0ZSI6IHRydWUsCiAgInR5cGUiOiAibW9kdWxlIiwKICAiZGVwZW5kZW5jaWVzIjogewogICAgIkByYWluYm93LXJvYm90aWNzL3BsdWdpbi11aSI6ICJfX1JCX1ZFUlNJT05fXyIKICB9LAogICJkZXZEZXBlbmRlbmNpZXMiOiB7CiAgICAiQHJhaW5ib3ctcm9ib3RpY3MvbXVzY2F0LXBsdWdpbi1raXQiOiAiX19SQl9WRVJTSU9OX18iLAogICAgIkByYWluYm93LXJvYm90aWNzL3ByZXZpZXctaG9zdCI6ICJfX1JCX1ZFUlNJT05fXyIsCiAgICAiQHZpdGVqcy9wbHVnaW4tcmVhY3QiOiAiXjQuMC4wIiwKICAgICJ0eXBlc2NyaXB0IjogIl41LjguMCIsCiAgICAidml0ZSI6ICJeNi4wLjAiCiAgfQp9Cg==","common/py/main.py":"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","common/requirements.txt":"cmFpbmJvdy1yYi1zZGs9PTAuMC45LmRldjQzCnJhaW5ib3ctcmItZmxhdC1idWZmZXJzPT0wLjAuOS5kZXY0MwpyYWluYm93LXJiLXplbm9oPT0wLjAuOS5kZXY0MwpyZXF1ZXN0cz09Mi4zNC4yCg==","common/tsconfig.json":"ewogICJjb21waWxlck9wdGlvbnMiOiB7CiAgICAidGFyZ2V0IjogIkVTTmV4dCIsCiAgICAibW9kdWxlIjogIkVTTmV4dCIsCiAgICAibW9kdWxlUmVzb2x1dGlvbiI6ICJidW5kbGVyIiwKICAgICJqc3giOiAicmVhY3QtanN4IiwKICAgICJzdHJpY3QiOiB0cnVlLAogICAgInNraXBMaWJDaGVjayI6IHRydWUsCiAgICAibm9FbWl0IjogdHJ1ZSwKICAgICJsaWIiOiBbIkRPTSIsICJET00uSXRlcmFibGUiLCAiRVNOZXh0Il0KICB9LAogICJpbmNsdWRlIjogWyJ1aSJdCn0K","common/ui/content.tsx":"aW1wb3J0IHsgdXNlU3RhdGUgfSBmcm9tICJyZWFjdCI7CmltcG9ydCB7IGNvbm5lY3QgfSBmcm9tICJAcmFpbmJvdy1yb2JvdGljcy9wbHVnaW4tdWkvY29ubmVjdCI7CmltcG9ydCB7IFNsaWRlciwgQnV0dG9uLCBUZXh0LCBTd2l0Y2ggfSBmcm9tICJAcmFpbmJvdy1yb2JvdGljcy9wbHVnaW4tdWkvcmVhY3QiOwppbXBvcnQgeyB1c2VSYiB9IGZyb20gIkByYWluYm93LXJvYm90aWNzL3BsdWdpbi11aS9zZGsiOwoKZnVuY3Rpb24gQXBwKCkgewogIGNvbnN0IHJiID0gdXNlUmIoKTsKICBjb25zdCBbd2lkdGgsIHNldFdpZHRoXSA9IHVzZVN0YXRlKDIwKTsKICBjb25zdCBbb3Blbiwgc2V0T3Blbl0gPSB1c2VTdGF0ZShmYWxzZSk7CgogIHJldHVybiAoCiAgICA8PgogICAgICA8VGV4dD5fX1BMVUdJTl9OQU1FX18gd2lkdGg6IHt3aWR0aH08L1RleHQ+CiAgICAgIDxTbGlkZXIKICAgICAgICB2YWx1ZT17d2lkdGh9CiAgICAgICAgbWluPXswfQogICAgICAgIG1heD17MTAwfQogICAgICAgIG9uQ2hhbmdlPXsoZXZlbnQ6IHsgZGV0YWlsPzogbnVtYmVyIH0pID0+IHNldFdpZHRoKGV2ZW50LmRldGFpbCA/PyAwKX0KICAgICAgLz4KICAgICAgPEJ1dHRvbiBsYWJlbD0iR3JpcCIgb25QcmVzcz17KCkgPT4gcmIuYWN0aW9uKCJncmlwIiwgeyB3aWR0aCB9KX0gLz4KICAgICAgPFN3aXRjaAogICAgICAgIGNoZWNrZWQ9e29wZW59CiAgICAgICAgb25DaGFuZ2U9eyhldmVudDogeyBkZXRhaWw/OiBib29sZWFuIH0pID0+IHsKICAgICAgICAgIGNvbnN0IG5leHQgPSBldmVudC5kZXRhaWwgPz8gZmFsc2U7CiAgICAgICAgICBzZXRPcGVuKG5leHQpOwogICAgICAgICAgcmIudG9hc3QobmV4dCA/ICJvcGVuZWQiIDogImNsb3NlZCIsICJpbmZvIik7CiAgICAgICAgfX0KICAgICAgLz4KICAgIDwvPgogICk7Cn0KCmNvbm5lY3QoQXBwKTsK","common/vite.config.ts":"aW1wb3J0IHsgcmVhZGRpclN5bmMgfSBmcm9tICJmcyI7CmltcG9ydCB7IGJhc2VuYW1lLCBleHRuYW1lLCByZXNvbHZlIH0gZnJvbSAicGF0aCI7CmltcG9ydCByZWFjdCBmcm9tICJAdml0ZWpzL3BsdWdpbi1yZWFjdCI7CmltcG9ydCB7IGRlZmluZUNvbmZpZyB9IGZyb20gInZpdGUiOwoKLy8gUGx1Z2luIFVJIGFuZCBSZWFjdCBhcmUgcHJvdmlkZWQgYnkgTXVzY2F0L3ByZXZpZXctaG9zdCB2aWEgaW1wb3J0IG1hcC4KLy8gVGhleSBtdXN0IE5PVCBiZSBidW5kbGVkIGludG8gdGhlIHBsdWdpbiBaSVAuCmNvbnN0IEhPU1RfUFJPVklERURfRVhURVJOQUxTID0gWwogIC9eQHJhaW5ib3ctcm9ib3RpY3NcL3BsdWdpbi11aShcL3wkKS8sCiAgL15yZWFjdChcL3wkKS8sCiAgL15yZWFjdC1kb20oXC98JCkvLApdOwoKLy8gQWxsIHRvcC1sZXZlbCAudHN4Ly50cyBmaWxlcyBpbiB1aS8gYmVjb21lIHNlcGFyYXRlIGVudHJ5IHBvaW50cy4KLy8gU3ViZGlyZWN0b3JpZXMgKGNvbXBvbmVudHMvLCBob29rcy8sIGV0Yy4pIGFyZSBpbXBvcnRlZCBieSBlbnRyaWVzIGFuZCBidW5kbGVkIGluLgpjb25zdCB1aUVudHJpZXMgPSBPYmplY3QuZnJvbUVudHJpZXMoCiAgcmVhZGRpclN5bmMoInVpIikKICAgIC5maWx0ZXIoKGYpID0+IC9cLih0c3g/fGpzeD8pJC8udGVzdChmKSkKICAgIC5tYXAoKGYpID0+IFtiYXNlbmFtZShmLCBleHRuYW1lKGYpKSwgcmVzb2x2ZSgidWkiLCBmKV0pLAopOwoKZXhwb3J0IGRlZmF1bHQgZGVmaW5lQ29uZmlnKHsKICBwbHVnaW5zOiBbcmVhY3QoKV0sCiAgYnVpbGQ6IHsKICAgIG91dERpcjogImRpc3QiLAogICAgZW1wdHlPdXREaXI6IGZhbHNlLAogICAgcm9sbHVwT3B0aW9uczogewogICAgICBpbnB1dDogdWlFbnRyaWVzLAogICAgICBleHRlcm5hbDogSE9TVF9QUk9WSURFRF9FWFRFUk5BTFMsCiAgICAgIG91dHB1dDogewogICAgICAgIGZvcm1hdDogImVzIiwKICAgICAgICBlbnRyeUZpbGVOYW1lczogIltuYW1lXS5qcyIsCiAgICAgICAgY2h1bmtGaWxlTmFtZXM6ICJjaHVua3MvW25hbWVdLVtoYXNoXS5qcyIsCiAgICAgICAgYXNzZXRGaWxlTmFtZXM6ICJhc3NldHMvW25hbWVdLVtoYXNoXVtleHRuYW1lXSIsCiAgICAgIH0sCiAgICB9LAogIH0sCn0pOwo=","cpp/cpp/CMakeLists.txt":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fIENYWCkKCnNldChDTUFLRV9DWFhfU1RBTkRBUkQgMTcpCnNldChDTUFLRV9DWFhfU1RBTkRBUkRfUkVRVUlSRUQgT04pCgojIFRoZSBleGVjdXRhYmxlIG5hbWUgbXVzdCBtYXRjaCBydW50aW1lLmVudHJ5IGluIG1hbmlmZXN0Lmpzb24uCmFkZF9leGVjdXRhYmxlKF9fUExVR0lOX1NMVUdfXyBtYWluLmNwcCkKCiMgVE9ETyhjcHAtc2RrKTogbGluayB0aGUgcmFpbmJvdyBjcHAgU0RLIGR5bmFtaWNhbGx5ICh0aGUgcm9ib3QgcHJvdmlkZXMgdGhlCiMgLnNvIGF0IHJ1bnRpbWUg4oCUIGRvIE5PVCBidW5kbGUvc3RhdGljLWxpbmsgaXQpLiBPbmNlIHRoZSBTREsgc2hpcHMgYW4gYXB0CiMgcGFja2FnZSB3aXRoIENNYWtlIGNvbmZpZywgZW5hYmxlOgojICAgZmluZF9wYWNrYWdlKHJhaW5ib3dfY3BwX3NkayBSRVFVSVJFRCkKIyAgIHRhcmdldF9saW5rX2xpYnJhcmllcyhfX1BMVUdJTl9TTFVHX18gUFJJVkFURSByYWluYm93OjpjcHBfc2RrKQo=","cpp/cpp/main.cpp":"Ly8gX19QTFVHSU5fTkFNRV9fIOKAlCBDKysgcGx1Z2luIGJhY2sgZW5kLgovLwovLyBUaGUgQysrIHBsdWdpbiBTREsgaXMgbm90IGF2YWlsYWJsZSB5ZXQsIHNvIHRoaXMgaXMgYSBidWlsZC9ydW4gc2tlbGV0b24uCi8vIE9uY2UgdGhlIFNESyBsYW5kcywgY29ubmVjdCB0byB0aGUgcGx1Z2luIGdhdGV3YXkgaGVyZSAodGhlIGhvc3QgZXhwb3NlcyBpdAovLyBhdCB0aGUgUkJfUExVR0lOX0dBVEVXQVkgLyBSQl9QTFVHSU5fSUQgZW52aXJvbm1lbnQgdmFyaWFibGVzKSBhbmQgd2lyZSB1cAovLyBwdWIgLyBzdWIgLyBzZXJ2ZSwgbWlycm9yaW5nIHRoZSBQeXRob24gcmFpbmJvdy5yYl9zZGsuUkJQbHVnaW5DYWxsIEFQSS4KCiNpbmNsdWRlIDxjaHJvbm8+CiNpbmNsdWRlIDxjc3RkbGliPgojaW5jbHVkZSA8aW9zdHJlYW0+CiNpbmNsdWRlIDx0aHJlYWQ+CgppbnQgbWFpbigpIHsKICBjb25zdCBjaGFyKiBwbHVnaW5faWQgPSBzdGQ6OmdldGVudigiUkJfUExVR0lOX0lEIik7CiAgc3RkOjpjb3V0IDw8ICJbX19QTFVHSU5fTkFNRV9fXSBiYWNrZW5kIHJlYWR5IgogICAgICAgICAgICA8PCAocGx1Z2luX2lkID8gc3RkOjpzdHJpbmcoIiAoaWQ9IikgKyBwbHVnaW5faWQgKyAiKSIgOiAiIikKICAgICAgICAgICAgPDwgc3RkOjplbmRsOwoKICAvLyBUT0RPOiBjb25uZWN0IHRvIHRoZSBwbHVnaW4gZ2F0ZXdheSBhbmQgcmVnaXN0ZXIgaGFuZGxlcnMgb25jZSB0aGUKICAvLyAgICAgICBDKysgU0RLIGlzIGF2YWlsYWJsZS4gRm9yIG5vdywganVzdCBrZWVwIHRoZSBwcm9jZXNzIGFsaXZlLgogIHdoaWxlICh0cnVlKSB7CiAgICBzdGQ6OnRoaXNfdGhyZWFkOjpzbGVlcF9mb3Ioc3RkOjpjaHJvbm86OnNlY29uZHMoMSkpOwogIH0KICByZXR1cm4gMDsKfQo=","ros2/ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/__init__.py":"","ros2/ros2_ws/src/__PLUGIN_SLUG__/__PLUGIN_SLUG__/node.py":"aW1wb3J0IHJjbHB5CmZyb20gcmNscHkubm9kZSBpbXBvcnQgTm9kZQpmcm9tIHJhaW5ib3cucmJfc2RrIGltcG9ydCBSQk1hbmlwdWxhdGVTREsgICMgUHlQSTogcmFpbmJvdy1yYi1zZGsKCgpzZGsgPSBSQk1hbmlwdWxhdGVTREsoKQoKCmNsYXNzIF9fUExVR0lOX0NMQVNTX19Ob2RlKE5vZGUpOgogICAgZGVmIF9faW5pdF9fKHNlbGYpOgogICAgICAgIHN1cGVyKCkuX19pbml0X18oIl9fUExVR0lOX1NMVUdfX19ub2RlIikKICAgICAgICBzZWxmLmdldF9sb2dnZXIoKS5pbmZvKCJfX1BMVUdJTl9OQU1FX18gbm9kZSBzdGFydGVkIikKICAgICAgICAjIHNkayBpcyBhdmFpbGFibGUgaGVyZSDigJQgdXNlIGl0IGFsb25nc2lkZSBST1MyIHRvcGljcyBhcyBuZWVkZWQKCgpkZWYgbWFpbihhcmdzPU5vbmUpOgogICAgcmNscHkuaW5pdChhcmdzPWFyZ3MpCiAgICBub2RlID0gX19QTFVHSU5fQ0xBU1NfX05vZGUoKQogICAgcmNscHkuc3Bpbihub2RlKQogICAgbm9kZS5kZXN0cm95X25vZGUoKQogICAgcmNscHkuc2h1dGRvd24oKQoKCmlmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CiAgICBtYWluKCkK","ros2/ros2_ws/src/__PLUGIN_SLUG__/package.xml":"PD94bWwgdmVyc2lvbj0iMS4wIj8+CjxwYWNrYWdlIGZvcm1hdD0iMyI+CiAgPG5hbWU+X19QTFVHSU5fU0xVR19fPC9uYW1lPgogIDx2ZXJzaW9uPjAuMC4xPC92ZXJzaW9uPgogIDxkZXNjcmlwdGlvbj5fX1BMVUdJTl9OQU1FX18gUk9TMiBub2RlPC9kZXNjcmlwdGlvbj4KICA8bWFpbnRhaW5lciBlbWFpbD0idG9kb0BleGFtcGxlLmNvbSI+bWFpbnRhaW5lcjwvbWFpbnRhaW5lcj4KICA8bGljZW5zZT5Qcm9wcmlldGFyeTwvbGljZW5zZT4KICA8ZGVwZW5kPnJjbHB5PC9kZXBlbmQ+CiAgPGV4cG9ydD48YnVpbGRfdHlwZT5hbWVudF9weXRob248L2J1aWxkX3R5cGU+PC9leHBvcnQ+CjwvcGFja2FnZT4K","ros2/ros2_ws/src/__PLUGIN_SLUG__/resource/__PLUGIN_SLUG__":"","ros2/ros2_ws/src/__PLUGIN_SLUG__/setup.py":"ZnJvbSBzZXR1cHRvb2xzIGltcG9ydCBzZXR1cAoKcGFja2FnZV9uYW1lID0gIl9fUExVR0lOX1NMVUdfXyIKCnNldHVwKAogICAgbmFtZT1wYWNrYWdlX25hbWUsCiAgICB2ZXJzaW9uPSIwLjAuMSIsCiAgICBwYWNrYWdlcz1bcGFja2FnZV9uYW1lXSwKICAgIGRhdGFfZmlsZXM9WwogICAgICAgICgic2hhcmUvYW1lbnRfaW5kZXgvcmVzb3VyY2VfaW5kZXgvcGFja2FnZXMiLCBbInJlc291cmNlLyIgKyBwYWNrYWdlX25hbWVdKSwKICAgICAgICAoInNoYXJlLyIgKyBwYWNrYWdlX25hbWUsIFsicGFja2FnZS54bWwiXSksCiAgICBdLAogICAgaW5zdGFsbF9yZXF1aXJlcz1bInNldHVwdG9vbHMiXSwKICAgIHppcF9zYWZlPVRydWUsCiAgICBlbnRyeV9wb2ludHM9ewogICAgICAgICJjb25zb2xlX3NjcmlwdHMiOiBbIl9fUExVR0lOX1NMVUdfX19ub2RlID0gX19QTFVHSU5fU0xVR19fLm5vZGU6bWFpbiJdLAogICAgfSwKKQo=","ros2-cpp/ros2_ws/src/__PLUGIN_SLUG__/CMakeLists.txt":"Y21ha2VfbWluaW11bV9yZXF1aXJlZChWRVJTSU9OIDMuMTYpCnByb2plY3QoX19QTFVHSU5fU0xVR19fKQoKaWYoTk9UIENNQUtFX0NYWF9TVEFOREFSRCkKICBzZXQoQ01BS0VfQ1hYX1NUQU5EQVJEIDE3KQplbmRpZigpCgpmaW5kX3BhY2thZ2UoYW1lbnRfY21ha2UgUkVRVUlSRUQpCmZpbmRfcGFja2FnZShyY2xjcHAgUkVRVUlSRUQpCgphZGRfZXhlY3V0YWJsZShfX1BMVUdJTl9TTFVHX19fbm9kZSBzcmMvbm9kZS5jcHApCmFtZW50X3RhcmdldF9kZXBlbmRlbmNpZXMoX19QTFVHSU5fU0xVR19fX25vZGUgcmNsY3BwKQoKaW5zdGFsbChUQVJHRVRTIF9fUExVR0lOX1NMVUdfX19ub2RlCiAgREVTVElOQVRJT04gbGliLyR7UFJPSkVDVF9OQU1FfSkKCmFtZW50X3BhY2thZ2UoKQo=","ros2-cpp/ros2_ws/src/__PLUGIN_SLUG__/package.xml":"PD94bWwgdmVyc2lvbj0iMS4wIj8+CjxwYWNrYWdlIGZvcm1hdD0iMyI+CiAgPG5hbWU+X19QTFVHSU5fU0xVR19fPC9uYW1lPgogIDx2ZXJzaW9uPjAuMC4xPC92ZXJzaW9uPgogIDxkZXNjcmlwdGlvbj5fX1BMVUdJTl9OQU1FX18gUk9TMiBub2RlIChyY2xjcHApPC9kZXNjcmlwdGlvbj4KICA8bWFpbnRhaW5lciBlbWFpbD0idG9kb0BleGFtcGxlLmNvbSI+bWFpbnRhaW5lcjwvbWFpbnRhaW5lcj4KICA8bGljZW5zZT5Qcm9wcmlldGFyeTwvbGljZW5zZT4KICA8YnVpbGR0b29sX2RlcGVuZD5hbWVudF9jbWFrZTwvYnVpbGR0b29sX2RlcGVuZD4KICA8ZGVwZW5kPnJjbGNwcDwvZGVwZW5kPgogIDxleHBvcnQ+PGJ1aWxkX3R5cGU+YW1lbnRfY21ha2U8L2J1aWxkX3R5cGU+PC9leHBvcnQ+CjwvcGFja2FnZT4K","ros2-cpp/ros2_ws/src/__PLUGIN_SLUG__/src/node.cpp":"Ly8gX19QTFVHSU5fTkFNRV9fIOKAlCBST1MyIG5vZGUgKHJjbGNwcCkuCi8vCi8vIFRoZSBub2RlIGlzIGxhdW5jaGVkIHdpdGggYC0tcm9zLWFyZ3MgLXIgX19uczo9L3tzbHVnfWAgYXV0b21hdGljYWxseSBieQovLyBkZXY6YmFjay4gUk9TMiB0b3BpY3MgYXJlIGJyaWRnZWQgdG8gdGhlIHBsdWdpbiBjb21tdW5pY2F0aW9uIGxheWVyLCBzbyBhCi8vIHBsYWluIHJjbGNwcCBub2RlIGlzIGFsbCB5b3UgbmVlZCDigJQgcmVsYXRpdmUgdG9waWMgbmFtZXMgZ2V0IHRoZSBuYW1lc3BhY2UKLy8gcHJlZml4IGFwcGxpZWQgYXV0b21hdGljYWxseS4KI2luY2x1ZGUgInJjbGNwcC9yY2xjcHAuaHBwIgoKY2xhc3MgX19QTFVHSU5fQ0xBU1NfX05vZGUgOiBwdWJsaWMgcmNsY3BwOjpOb2RlIHsKcHVibGljOgogIF9fUExVR0lOX0NMQVNTX19Ob2RlKCkgOiBOb2RlKCJfX1BMVUdJTl9TTFVHX19fbm9kZSIpIHsKICAgIFJDTENQUF9JTkZPKHRoaXMtPmdldF9sb2dnZXIoKSwgIl9fUExVR0lOX05BTUVfXyBub2RlIHN0YXJ0ZWQiKTsKICAgIC8vIGNyZWF0ZSBwdWJsaXNoZXJzIC8gc3Vic2NyaWJlcnMgLyBzZXJ2aWNlcyBoZXJlCiAgfQp9OwoKaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KSB7CiAgcmNsY3BwOjppbml0KGFyZ2MsIGFyZ3YpOwogIHJjbGNwcDo6c3BpbihzdGQ6Om1ha2Vfc2hhcmVkPF9fUExVR0lOX0NMQVNTX19Ob2RlPigpKTsKICByY2xjcHA6OnNodXRkb3duKCk7CiAgcmV0dXJuIDA7Cn0K","docker/Dockerfile.bridge":"IyBTb2NrZXQuSU8gYnJpZGdlIGNvbnRhaW5lciDigJQgdGhlIGZyb250ZW5kIChwcmV2aWV3LWhvc3QpIGFuZCB0aGUgYmFja2VuZAojIGNvbnRhaW5lciByZW5kZXp2b3VzIGhlcmUgZHVyaW5nIGBtdXNjYXQtcGsgZGV2YC4KIyAgIC0gZnJvbnRlbmQgKGhvc3QpICDihpIgcHVibGlzaGVkIHBvcnQgbG9jYWxob3N0OjEwMDAwCiMgICAtIGJhY2tlbmQgY29udGFpbmVyIOKGkiBzaGFyZXMgdGhpcyBjb250YWluZXIncyBuZXRucyAoLS1uZXR3b3JrIGNvbnRhaW5lcjopLAojICAgICAgICAgICAgICAgICAgICAgICAgIHNvIGl0IHJlYWNoZXMgdGhlIGJyaWRnZSBhdCBsb2NhbGhvc3Q6MTAwMDAgdG9vCiMgQnVpbGQgY29udGV4dCBpcyB0aGUgYGNsaS9gIGRpciBzbyBpdCBjYW4gY29weSBzcmMvc29ja2V0QnJpZGdlLm1qcy4KRlJPTSBub2RlOjIwLXNsaW0KTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKV09SS0RJUiAvYnJpZGdlCkNPUFkgZG9ja2VyL2JyaWRnZS1wYWNrYWdlLmpzb24gcGFja2FnZS5qc29uClJVTiBucG0gaW5zdGFsbCAtLW9taXQ9ZGV2IC0tbm8tYXVkaXQgLS1uby1mdW5kCgpDT1BZIHNyYy9zb2NrZXRCcmlkZ2UubWpzIC4vc29ja2V0QnJpZGdlLm1qcwoKRVhQT1NFIDEwMDAwCkNNRCBbIm5vZGUiLCAic29ja2V0QnJpZGdlLm1qcyJdCg==","docker/Dockerfile.cpp":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgcHVyZSBDKysgcGx1Z2luIGJhY2sgZW5kLgojIE1hdGNoZXMgdGhlIE11c2NhdCByb2JvdCBiYWNrZW5kIE9TIChVYnVudHUgMjQuMDQpIHNvIHRoZSBjb21waWxlZCBiaW5hcnkKIyBpcyBBQkktY29tcGF0aWJsZSB3aXRoIHRoZSByb2JvdC4gVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCBhbmQgYGJ1aWxkYAojIOKAlCBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUC4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIGJ1aWxkLWVzc2VudGlhbCBcCiAgICAgIGNtYWtlIFwKICAgICYmIHJtIC1yZiAvdmFyL2xpYi9hcHQvbGlzdHMvKgoKIyBUT0RPKGNwcC1zZGspOiBpbnN0YWxsIHRoZSByYWluYm93IGNwcCBTREsgKGRldiBwYWNrYWdlKSBoZXJlLCBwaW5uZWQgdG8gdGhlCiMgcm9ib3QncyB2ZXJzaW9uLCBzbyBwbHVnaW5zIGJ1aWxkL2xpbmsgYWdhaW5zdCB0aGUgc2FtZSBTREsgYXMgcHJvZHVjdGlvbi4KIyBQbGFuOiBhcHQgcGFja2FnZSArIGR5bmFtaWMgbGluayAodGhlIHJvYm90IHByb3ZpZGVzIHRoZSAuc28gYXQgcnVudGltZTsKIyB3ZSBkbyBOT1QgYnVuZGxlIGl0IGludG8gdGhlIHBsdWdpbiBiaW5hcnkpLiBlLmcuOgojICAgUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSByYWluYm93LWNwcC1zZGstZGV2PTxyb2JvdC12ZXJzaW9uPiBcCiMgICAgICAgJiYgcm0gLXJmIC92YXIvbGliL2FwdC9saXN0cy8qCgpXT1JLRElSIC9wbHVnaW4KCkNNRCBbImJhc2giXQo=","docker/Dockerfile.dev":"IyBEZXYtb25seSBjb250YWluZXIgZm9yIHRoZSBST1MyIHBsdWdpbiBiYWNrIGVuZC4KIyBNYXRjaGVzIHRoZSBNdXNjYXQgcm9ib3QgYmFja2VuZDogUk9TMiBKYXp6eSArIFB5dGhvbiAzLjEyIChVYnVudHUgMjQuMDQpLgojIFVzZWQgYnkgYG11c2NhdC1wayBkZXY6YmFja2Ag4oCUIE5PVCBzaGlwcGVkIGluIHRoZSBwbHVnaW4gWklQLgpGUk9NIHJvczpqYXp6eS1yb3MtYmFzZQpMQUJFTCBjb20ucmFpbmJvdy1yb2JvdGljcy5tdXNjYXQtcGs9InRydWUiCgpSVU4gYXB0LWdldCB1cGRhdGUgJiYgYXB0LWdldCBpbnN0YWxsIC15IC0tbm8taW5zdGFsbC1yZWNvbW1lbmRzIFwKICAgICAgcHl0aG9uMy1waXAgXAogICAgICBweXRob24zLWNvbGNvbi1jb21tb24tZXh0ZW5zaW9ucyBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyoKCldPUktESVIgL3BsdWdpbgoKQ01EIFsiYmFzaCJdCg==","docker/Dockerfile.python":"IyBEZXYvYnVpbGQgY29udGFpbmVyIGZvciB0aGUgUHl0aG9uIHBsdWdpbiBiYWNrIGVuZC4KIyBNYXRjaGVzIHRoZSBNdXNjYXQgcm9ib3QgYmFja2VuZDogVWJ1bnR1IDI0LjA0ICsgUHl0aG9uIDMuMTIuCiMgVXNlZCBieSBgbXVzY2F0LXBrIGRldjpiYWNrYCAoaG90LXJlbG9hZCkgYW5kIGBtdXNjYXQtcGsgYnVpbGRgIChsb2NrICsgd2hlZWwgdmVuZG9yKS4KIyBOT1Qgc2hpcHBlZCBpbiB0aGUgcGx1Z2luIFpJUCDigJQgdGhlIHJvYm90IGluc3RhbGxzIGRlcHMgZnJvbSBkaXN0L3doZWVscy8gb2ZmbGluZS4KRlJPTSB1YnVudHU6MjQuMDQKTEFCRUwgY29tLnJhaW5ib3ctcm9ib3RpY3MubXVzY2F0LXBrPSJ0cnVlIgoKUlVOIGFwdC1nZXQgdXBkYXRlICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBcCiAgICAgIHB5dGhvbjMgXAogICAgICBweXRob24zLXBpcCBcCiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLyogXAogICAgJiYgcGlwMyBpbnN0YWxsIHV2PT0wLjguMTggLS1icmVhay1zeXN0ZW0tcGFja2FnZXMKCiMgVE9ETyhjcHAtc2RrKTogdGhlIFB5dGhvbiBTREsgaXMgYSBweWJpbmQgd3JhcHBlciBvdmVyIHRoZSBjcHAgU0RLLCBzbyB0aGUKIyBjcHAgU0RLIHNoYXJlZCBsaWIgbXVzdCBiZSBwcmVzZW50IGZvciB0aGUgcHl0aG9uIG1vZHVsZSB0byBsb2FkLiBJbnN0YWxsIHRoZQojIHJhaW5ib3cgY3BwIFNESyAoYXB0LCBwaW5uZWQgdG8gdGhlIHJvYm90J3MgdmVyc2lvbikgaGVyZSBvbmNlIGl0IGV4aXN0cy4KCldPUktESVIgL3BsdWdpbgoKQ01EIFsiYmFzaCJdCg==","docker/bridge-package.json":"ewogICJuYW1lIjogIm11c2NhdC1way1icmlkZ2UiLAogICJwcml2YXRlIjogdHJ1ZSwKICAidHlwZSI6ICJtb2R1bGUiLAogICJkZXBlbmRlbmNpZXMiOiB7CiAgICAic29ja2V0LmlvIjogIl40LjguMSIKICB9Cn0K"};
+export const TEMPLATES = {"common/.mcp.json":"ewogICJtY3BTZXJ2ZXJzIjogewogICAgIm11c2NhdCI6IHsKICAgICAgImNvbW1hbmQiOiAibXVzY2F0LXBrIiwKICAgICAgImFyZ3MiOiBbIm1jcCJdCiAgICB9CiAgfQp9Cg==","common/README.md":"# __PLUGIN_NAME__

A Muscat plugin project. Build, develop, and ship with `muscat-pk` CLI.

## Quick start

```bash
muscat-pk dev        # UI preview + backend together
muscat-pk dev:ui     # UI preview only
muscat-pk dev:back   # backend only (Python watchfiles / ROS2 Docker)
muscat-pk build      # build + distributable ZIP
```

---

## Project structure

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

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

---

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

### JavaScript dependencies

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

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

The scaffold keeps this split:

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

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

### Styles

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

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

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

#### Tailwind

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

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

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

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

```css
@layer theme, utilities;

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

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

#### SCSS, Sass, and Less

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

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

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

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

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

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

#### Emotion

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

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

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

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

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

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

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

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

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

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

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

### useRb() hook

Access the communication API between the plugin module and UI from any plugin component.

```tsx
import { useRb } from "@rainbow-robotics/plugin-ui/sdk";

function App() {
  const rb = useRb();
}
```

### rb API

| Method                                                                                                             | Description                                                                                                                                                |
| ------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rb.pub(topic, payload)`                                                                                           | Publish a message to a topic                                                                                                                               |
| `rb.sub(topic, handler)`                                                                                           | Subscribe to a topic — returns `{ undeclare() }`                                                                                                           |
| `rb.action(topic, payload?)`                                                                                       | Send a request and await a reply                                                                                                                           |
| `rb.serve(topic, handler)`                                                                                         | Handle incoming requests from the backend                                                                                                                  |
| `rb.toast({ title?, message, type?, actionLabel?, handleActionClick?, closeOnActionClick?, duration?, onClose? })` | Show a host toast notification. `message` accepts a string or `ReactElement`. `type` can be `"info"`, `"danger"`, `"warning"`, `"caution"`, or `"success"` |
| `rb.alert({ title?, message, buttonText? })`                                                                       | Show a host alert dialog. Resolves when the dialog is closed                                                                                               |
| `rb.confirm({ title?, message, buttonText? })`                                                                     | Show a host confirmation dialog. `buttonText` accepts `{ yes, no }`. Resolves to `true` or `false`                                                         |
| `rb.prompt({ title?, message, value?, placeholder?, buttonText? })`                                                | Show a host prompt dialog. `buttonText` accepts `{ yes, no }`. Resolves to the entered string or `undefined`                                               |

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


All methods support Generic Types:

```tsx
const status = await rb.action<{ ok: boolean }, { id: number }>(
  "get-status",
  { id: 1 },
);

const sub = await rb.sub<{ value: number }>("sensor/data", (data) => {
  console.log(data.value);
});
sub.undeclare(); // cleanup

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

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

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

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

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

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

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

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

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

### UI components

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

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

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

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

---

## Developing directly on the robot PC

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

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

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

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

---

## Backend runtimes

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

### Frontend-only (`none`)

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

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

### Python

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

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

plugin = RBPluginCall()


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


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


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


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


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


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

#### Program step backend (`program.step`)

When your plugin contributes a `program.step`, the backend handles each step
execution through `PluginProgramContext` — receiving the step args, checking for
stop/pause, reading/writing program variables, and signalling completion.

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

manifest.json:
  "runtime": {"type": "python", "entry": "main.py"},
  "contributes": [{"point": "program.step", "label": "My Plugin Step"}]

Program step config:
  funcName: rb_program_sdk.plugin_execute
  args:
    plugin_id: "my-plugin"
    message: "hello"         # plugin-author-defined arg
"""
import asyncio
from rainbow.rb_sdk import PluginProgramContext

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


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

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

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

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

    # finish the step
    await ctx.done()


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

### C++

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

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

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

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

### ROS2 (rclpy)

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

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

sdk = RBManipulateSDK()


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

### ROS2 (rclcpp)

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

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

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

---

## manifest.json

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

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

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

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

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

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

  "contributes": [
    // program.command — adds a step node to the program tree
    {
      "point": "program.command",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "program/content",   // must be unique across all contributions
      "commandInfo": {
        "name": "My Plugin",
        "icon": "assets/icon.svg",
        "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"
    },
    // move.rnb — adds a panel to the Move screen right-side area
    {
      "point": "move.rnb",
      "icon": "assets/icon.svg",
      "label": { "ko": "내 플러그인", "en": "My Plugin" },
      "ui": "move/content"       // must be unique across all contributions
    }
  ],

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

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

**Backend types:**

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

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

**Contribution points:**

| point | Where it appears | `commandInfo` required |
|---|---|:---:|
| `toolbar` | Top toolbar button (must have at least one) | — |
| `program.command` | Program tree step node | ✓ |
| `move.rnb` | Move screen right-side panel | — |

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

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

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

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

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

---

## Localized documentation

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

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

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

---

## Installing Python dependencies

Add any package with an optional version pin to `requirements.txt`:

```
rainbow-rb-sdk
rainbow-rb-flat-buffers
numpy==1.26.4
opencv-python
```

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

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

---

## Switching backend type

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

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

---

## AI coding assistants (MCP)

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

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

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

### Register the server

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

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

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

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

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

---

## Shipping

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

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

ZIP layout:

```
__PLUGIN_DIR__-1.0.0.zip
├─ dist/
│   ├─ content.js        # built UI
│   ├─ manifest.json
│   ├─ assets/
│   ├─ README.md
│   ├─ README.ko.md      # if present
│   ├─ main.py           # from py/
│   └─ requirements.txt  # pinned
└─ ros2_ws/install/      # ROS2 only
```

---

## All commands

```bash
muscat-pk dev        # UI + backend
muscat-pk dev:ui     # UI preview only (preview-host)
muscat-pk dev:back   # backend only (Python: watchfiles / ROS2: Docker)
muscat-pk build      # build → dist/ + distributable ZIP (--no-zip to skip)
muscat-pk storybook  # browse the rb-components UI library in a browser
muscat-pk mcp        # MCP server for AI assistants (components/tokens/SDK docs)
```

```bash
muscat-pk type change    # switch backend type
muscat-pk sdk list       # show current Python SDK version
muscat-pk sdk update     # update Python SDK to latest
muscat-pk update         # update muscat-plugin-kit itself
muscat-pk uninstall      # remove muscat-pk itself
```
","common/assets/icon.svg":"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","common/manifest.json":"ewogICJpZCI6ICJfX1BMVUdJTl9JRF9fIiwKICAibmFtZSI6ICJfX1BMVUdJTl9OQU1FX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAibWluTXVzY2F0VmVyc2lvbiI6ICIxLjAuMCIsCiAgImF1dGhvciI6ICJfX1BMVUdJTl9BVVRIT1JfXyIsCiAgImVtYWlsIjogIl9fUExVR0lOX0VNQUlMX18iLAogICJkZXNjcmlwdGlvbiI6IHsKICAgICJrbyI6ICIiLAogICAgImVuIjogIiIKICB9LAogICJpY29ucyI6ICJhc3NldHMvaWNvbi5zdmciLAogICJ0YXJnZXRNb2RlbHMiOiAiYWxsIiwKICAidGFyZ2V0Q2F0ZWdvcnlzIjogImFsbCIsCiAgImNvbnRyaWJ1dGVzIjogWwogICAgewogICAgICAicG9pbnQiOiAidG9vbGJhciIsCiAgICAgICJpY29uIjogImFzc2V0cy9pY29uLnN2ZyIsCiAgICAgICJsYWJlbCI6IHsgImtvIjogIl9fUExVR0lOX05BTUVfXyIsICJlbiI6ICJfX1BMVUdJTl9OQU1FX18iIH0sCiAgICAgICJ1aSI6ICJjb250ZW50IiwKICAgICAgIm9wZW5zIjogInBvcG92ZXIiCiAgICB9CiAgXSwKICAicnVudGltZSI6IHsgInR5cGUiOiAiX19SVU5USU1FX1RZUEVfXyIsICJlbnRyeSI6ICJtYWluLnB5IiB9Cn0K","common/package.json":"ewogICJuYW1lIjogIl9fUExVR0lOX0lEX18iLAogICJ2ZXJzaW9uIjogIjEuMC4wIiwKICAicHJpdmF0ZSI6IHRydWUsCiAgInR5cGUiOiAibW9kdWxlIiwKICAiZGVwZW5kZW5jaWVzIjogewogICAgIkByYWluYm93LXJvYm90aWNzL3BsdWdpbi11aSI6ICJfX1JCX1ZFUlNJT05fXyIKICB9LAogICJkZXZEZXBlbmRlbmNpZXMiOiB7CiAgICAiQHRhaWx3aW5kY3NzL3ZpdGUiOiAiXjQuMS4wIiwKICAgICJAcmFpbmJvdy1yb2JvdGljcy9tdXNjYXQtcGx1Z2luLWtpdCI6ICJfX1JCX1ZFUlNJT05fXyIsCiAgICAiQHJhaW5ib3ctcm9ib3RpY3MvcHJldmlldy1ob3N0IjogIl9fUkJfVkVSU0lPTl9fIiwKICAgICJAdml0ZWpzL3BsdWdpbi1yZWFjdCI6ICJeNC4wLjAiLAogICAgInRhaWx3aW5kY3NzIjogIl40LjEuMCIsCiAgICAidHlwZXNjcmlwdCI6ICJeNS44LjAiLAogICAgInZpdGUiOiAiXjYuMC4wIgogIH0KfQo=","common/py/main.py":"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","common/requirements.txt":"cmFpbmJvdy1yYi1zZGs9PTAuMC45LmRldjQzCnJhaW5ib3ctcmItZmxhdC1idWZmZXJzPT0wLjAuOS5kZXY0MwpyYWluYm93LXJiLXplbm9oPT0wLjAuOS5kZXY0MwpyZXF1ZXN0cz09Mi4zNC4yCg==","common/tsconfig.json":"ewogICJjb21waWxlck9wdGlvbnMiOiB7CiAgICAidGFyZ2V0IjogIkVTTmV4dCIsCiAgICAibW9kdWxlIjogIkVTTmV4dCIsCiAgICAibW9kdWxlUmVzb2x1dGlvbiI6ICJidW5kbGVyIiwKICAgICJqc3giOiAicmVhY3QtanN4IiwKICAgICJzdHJpY3QiOiB0cnVlLAogICAgInNraXBMaWJDaGVjayI6IHRydWUsCiAgICAibm9FbWl0IjogdHJ1ZSwKICAgICJsaWIiOiBbIkRPTSIsICJET00uSXRlcmFibGUiLCAiRVNOZXh0Il0KICB9LAogICJpbmNsdWRlIjogWyJ1aSJdCn0K","common/ui/content.tsx":"import { useMemo, useState } from "react";
import {
  RBCheckBox,
  RBLabelButton,
  RBRadioBox,
  RBSelectBox,
  RBSlider,
  RBSwitch,
  RBTextArea,
  RBTextField,
  RBTextInput,
  Option
} from "@rainbow-robotics/plugin-ui/react";
import { useRb } from "@rainbow-robotics/plugin-ui/sdk";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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